plc4net/tools/code-gen/src/generated/MSpecParser.cs

//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//      https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     ANTLR Version: 4.13.2
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

// Generated from code-generation/protocol-base-mspec/src/main/antlr4/org/apache/plc4x/plugins/codegenerator/language/mspec/MSpec.g4 by ANTLR 4.13.2

// 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 org.apache.plc4net.tools.codegen.grammar {
using System;
using System.IO;
using System.Text;
using System.Diagnostics;
using System.Collections.Generic;
using Antlr4.Runtime;
using Antlr4.Runtime.Atn;
using Antlr4.Runtime.Misc;
using Antlr4.Runtime.Tree;
using DFA = Antlr4.Runtime.Dfa.DFA;

[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.13.2")]
[System.CLSCompliant(false)]
public partial class MSpecParser : Parser {
	protected static DFA[] decisionToDFA;
	protected static PredictionContextCache sharedContextCache = new PredictionContextCache();
	public const int
		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 
		T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 
		T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, 
		TICK=25, LBRACKET=26, RBRACKET=27, LRBRACKET=28, RRBRACKET=29, LCBRACKET=30, 
		RCBRACKET=31, ASTERISK=32, CONSTANTS=33, GLOBALS=34, CONTEXT=35, TYPE=36, 
		DISCRIMINATEDTYPE=37, DATAIO=38, ENUM=39, BATCHSET=40, ABSTRACT=41, ARRAY=42, 
		ASSERT=43, CHECKSUM=44, CONST=45, DISCRIMINATOR=46, IMPLICIT=47, MANUALARRAY=48, 
		MANUAL=49, OPTIONAL=50, PADDING=51, PEEK=52, RESERVED=53, SIMPLE=54, STATE=55, 
		TYPESWITCH=56, UNKNOWN=57, VALIDATION=58, VIRTUAL=59, BIT=60, BYTE=61, 
		INT=62, VINT=63, UINT=64, VUINT=65, FLOAT=66, UFLOAT=67, STRING=68, VSTRING=69, 
		TIME=70, DATE=71, DATETIME=72, SHOULD_FAIL=73, ARRAY_LOOP_TYPE=74, INTEGER_LITERAL=75, 
		FLOAT_LITERAL=76, HEX_LITERAL=77, BOOLEAN_LITERAL=78, STRING_LITERAL=79, 
		IDENTIFIER_LITERAL=80, LINE_COMMENT=81, BLOCK_COMMENT=82, EmptyLine=83, 
		NEWLINE=84, WS=85;
	public const int
		RULE_file = 0, RULE_contantsDefinition = 1, RULE_globalsDefinition = 2, 
		RULE_contextDefintion = 3, RULE_complexTypeDefinition = 4, RULE_complexType = 5, 
		RULE_fieldDefinition = 6, RULE_batchSetDefinition = 7, RULE_dataIoDefinition = 8, 
		RULE_field = 9, RULE_abstractField = 10, RULE_arrayField = 11, RULE_assertField = 12, 
		RULE_checksumField = 13, RULE_constField = 14, RULE_discriminatorField = 15, 
		RULE_enumField = 16, RULE_implicitField = 17, RULE_manualArrayField = 18, 
		RULE_manualField = 19, RULE_optionalField = 20, RULE_paddingField = 21, 
		RULE_peekField = 22, RULE_reservedField = 23, RULE_simpleField = 24, RULE_stateField = 25, 
		RULE_typeSwitchField = 26, RULE_unknownField = 27, RULE_validationField = 28, 
		RULE_virtualField = 29, RULE_enumValueDefinition = 30, RULE_typeReference = 31, 
		RULE_caseStatement = 32, RULE_dataType = 33, RULE_attribute = 34, RULE_attributeList = 35, 
		RULE_argument = 36, RULE_argumentList = 37, RULE_expression = 38, RULE_multipleExpressions = 39, 
		RULE_multipleVariableLiterals = 40, RULE_variableLiteral = 41, RULE_innerExpression = 42, 
		RULE_valueLiteral = 43, RULE_idExpression = 44, RULE_binaryOperator = 45;
	public static readonly string[] ruleNames = {
		"file", "contantsDefinition", "globalsDefinition", "contextDefintion", 
		"complexTypeDefinition", "complexType", "fieldDefinition", "batchSetDefinition", 
		"dataIoDefinition", "field", "abstractField", "arrayField", "assertField", 
		"checksumField", "constField", "discriminatorField", "enumField", "implicitField", 
		"manualArrayField", "manualField", "optionalField", "paddingField", "peekField", 
		"reservedField", "simpleField", "stateField", "typeSwitchField", "unknownField", 
		"validationField", "virtualField", "enumValueDefinition", "typeReference", 
		"caseStatement", "dataType", "attribute", "attributeList", "argument", 
		"argumentList", "expression", "multipleExpressions", "multipleVariableLiterals", 
		"variableLiteral", "innerExpression", "valueLiteral", "idExpression", 
		"binaryOperator"
	};

	private static readonly string[] _LiteralNames = {
		null, "'='", "','", "'.'", "'?'", "':'", "'\"'", "'!'", "'+'", "'-'", 
		"'/'", "'^'", "'=='", "'!='", "'>>'", "'<<'", "'>'", "'<'", "'>='", "'<='", 
		"'&&'", "'||'", "'&'", "'|'", "'%'", "'''", "'['", "']'", "'('", "')'", 
		"'{'", "'}'", "'*'", "'constants'", "'globals'", "'context'", "'type'", 
		"'discriminatedType'", "'dataIo'", "'enum'", "'batchSet'", "'abstract'", 
		"'array'", "'assert'", "'checksum'", "'const'", "'discriminator'", "'implicit'", 
		"'manualArray'", "'manual'", "'optional'", "'padding'", "'peek'", "'reserved'", 
		"'simple'", "'state'", "'typeSwitch'", "'unknown'", "'validation'", "'virtual'", 
		"'bit'", "'byte'", "'int'", "'vint'", "'uint'", "'vuint'", "'float'", 
		"'ufloat'", "'string'", "'vstring'", "'time'", "'date'", "'dateTime'", 
		"'shouldFail'"
	};
	private static readonly string[] _SymbolicNames = {
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, "TICK", "LBRACKET", "RBRACKET", "LRBRACKET", "RRBRACKET", "LCBRACKET", 
		"RCBRACKET", "ASTERISK", "CONSTANTS", "GLOBALS", "CONTEXT", "TYPE", "DISCRIMINATEDTYPE", 
		"DATAIO", "ENUM", "BATCHSET", "ABSTRACT", "ARRAY", "ASSERT", "CHECKSUM", 
		"CONST", "DISCRIMINATOR", "IMPLICIT", "MANUALARRAY", "MANUAL", "OPTIONAL", 
		"PADDING", "PEEK", "RESERVED", "SIMPLE", "STATE", "TYPESWITCH", "UNKNOWN", 
		"VALIDATION", "VIRTUAL", "BIT", "BYTE", "INT", "VINT", "UINT", "VUINT", 
		"FLOAT", "UFLOAT", "STRING", "VSTRING", "TIME", "DATE", "DATETIME", "SHOULD_FAIL", 
		"ARRAY_LOOP_TYPE", "INTEGER_LITERAL", "FLOAT_LITERAL", "HEX_LITERAL", 
		"BOOLEAN_LITERAL", "STRING_LITERAL", "IDENTIFIER_LITERAL", "LINE_COMMENT", 
		"BLOCK_COMMENT", "EmptyLine", "NEWLINE", "WS"
	};
	public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);

	[NotNull]
	public override IVocabulary Vocabulary
	{
		get
		{
			return DefaultVocabulary;
		}
	}

	public override string GrammarFileName { get { return "MSpec.g4"; } }

	public override string[] RuleNames { get { return ruleNames; } }

	public override int[] SerializedAtn { get { return _serializedATN; } }

	static MSpecParser() {
		decisionToDFA = new DFA[_ATN.NumberOfDecisions];
		for (int i = 0; i < _ATN.NumberOfDecisions; i++) {
			decisionToDFA[i] = new DFA(_ATN.GetDecisionState(i), i);
		}
	}

		public MSpecParser(ITokenStream input) : this(input, Console.Out, Console.Error) { }

		public MSpecParser(ITokenStream input, TextWriter output, TextWriter errorOutput)
		: base(input, output, errorOutput)
	{
		Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache);
	}

	public partial class FileContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(MSpecParser.Eof, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ContantsDefinitionContext contantsDefinition() {
			return GetRuleContext<ContantsDefinitionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public GlobalsDefinitionContext globalsDefinition() {
			return GetRuleContext<GlobalsDefinitionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ContextDefintionContext contextDefintion() {
			return GetRuleContext<ContextDefintionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ComplexTypeDefinitionContext[] complexTypeDefinition() {
			return GetRuleContexts<ComplexTypeDefinitionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ComplexTypeDefinitionContext complexTypeDefinition(int i) {
			return GetRuleContext<ComplexTypeDefinitionContext>(i);
		}
		public FileContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_file; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterFile(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitFile(this);
		}
	}

	[RuleVersion(0)]
	public FileContext file() {
		FileContext _localctx = new FileContext(Context, State);
		EnterRule(_localctx, 0, RULE_file);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 93;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,0,Context) ) {
			case 1:
				{
				State = 92;
				contantsDefinition();
				}
				break;
			}
			State = 96;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,1,Context) ) {
			case 1:
				{
				State = 95;
				globalsDefinition();
				}
				break;
			}
			State = 99;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,2,Context) ) {
			case 1:
				{
				State = 98;
				contextDefintion();
				}
				break;
			}
			State = 104;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==LBRACKET) {
				{
				{
				State = 101;
				complexTypeDefinition();
				}
				}
				State = 106;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 107;
			Match(Eof);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ContantsDefinitionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] LBRACKET() { return GetTokens(MSpecParser.LBRACKET); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACKET(int i) {
			return GetToken(MSpecParser.LBRACKET, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONSTANTS() { return GetToken(MSpecParser.CONSTANTS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] RBRACKET() { return GetTokens(MSpecParser.RBRACKET); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACKET(int i) {
			return GetToken(MSpecParser.RBRACKET, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ConstFieldContext[] constField() {
			return GetRuleContexts<ConstFieldContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ConstFieldContext constField(int i) {
			return GetRuleContext<ConstFieldContext>(i);
		}
		public ContantsDefinitionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_contantsDefinition; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterContantsDefinition(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitContantsDefinition(this);
		}
	}

	[RuleVersion(0)]
	public ContantsDefinitionContext contantsDefinition() {
		ContantsDefinitionContext _localctx = new ContantsDefinitionContext(Context, State);
		EnterRule(_localctx, 2, RULE_contantsDefinition);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 109;
			Match(LBRACKET);
			State = 110;
			Match(CONSTANTS);
			State = 117;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==LBRACKET) {
				{
				{
				State = 111;
				Match(LBRACKET);
				State = 112;
				constField();
				State = 113;
				Match(RBRACKET);
				}
				}
				State = 119;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 120;
			Match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class GlobalsDefinitionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACKET() { return GetToken(MSpecParser.LBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode GLOBALS() { return GetToken(MSpecParser.GLOBALS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACKET() { return GetToken(MSpecParser.RBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public FieldDefinitionContext[] fieldDefinition() {
			return GetRuleContexts<FieldDefinitionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public FieldDefinitionContext fieldDefinition(int i) {
			return GetRuleContext<FieldDefinitionContext>(i);
		}
		public GlobalsDefinitionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_globalsDefinition; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterGlobalsDefinition(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitGlobalsDefinition(this);
		}
	}

	[RuleVersion(0)]
	public GlobalsDefinitionContext globalsDefinition() {
		GlobalsDefinitionContext _localctx = new GlobalsDefinitionContext(Context, State);
		EnterRule(_localctx, 4, RULE_globalsDefinition);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 122;
			Match(LBRACKET);
			State = 123;
			Match(GLOBALS);
			State = 127;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==LBRACKET) {
				{
				{
				State = 124;
				fieldDefinition();
				}
				}
				State = 129;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 130;
			Match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ContextDefintionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACKET() { return GetToken(MSpecParser.LBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONTEXT() { return GetToken(MSpecParser.CONTEXT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACKET() { return GetToken(MSpecParser.RBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public FieldDefinitionContext[] fieldDefinition() {
			return GetRuleContexts<FieldDefinitionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public FieldDefinitionContext fieldDefinition(int i) {
			return GetRuleContext<FieldDefinitionContext>(i);
		}
		public ContextDefintionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_contextDefintion; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterContextDefintion(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitContextDefintion(this);
		}
	}

	[RuleVersion(0)]
	public ContextDefintionContext contextDefintion() {
		ContextDefintionContext _localctx = new ContextDefintionContext(Context, State);
		EnterRule(_localctx, 6, RULE_contextDefintion);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 132;
			Match(LBRACKET);
			State = 133;
			Match(CONTEXT);
			State = 137;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==LBRACKET) {
				{
				{
				State = 134;
				fieldDefinition();
				}
				}
				State = 139;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 140;
			Match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ComplexTypeDefinitionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACKET() { return GetToken(MSpecParser.LBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ComplexTypeContext complexType() {
			return GetRuleContext<ComplexTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACKET() { return GetToken(MSpecParser.RBRACKET, 0); }
		public ComplexTypeDefinitionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_complexTypeDefinition; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterComplexTypeDefinition(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitComplexTypeDefinition(this);
		}
	}

	[RuleVersion(0)]
	public ComplexTypeDefinitionContext complexTypeDefinition() {
		ComplexTypeDefinitionContext _localctx = new ComplexTypeDefinitionContext(Context, State);
		EnterRule(_localctx, 8, RULE_complexTypeDefinition);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 142;
			Match(LBRACKET);
			State = 143;
			complexType();
			State = 144;
			Match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ComplexTypeContext : ParserRuleContext {
		public IdExpressionContext name;
		public ArgumentListContext @params;
		public AttributeListContext attributes;
		public DataTypeContext type;
		public EnumValueDefinitionContext enumValues;
		public DataIoDefinitionContext dataIoTypeSwitch;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TYPE() { return GetToken(MSpecParser.TYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public AttributeListContext attributeList() {
			return GetRuleContext<AttributeListContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LRBRACKET() { return GetToken(MSpecParser.LRBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RRBRACKET() { return GetToken(MSpecParser.RRBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public FieldDefinitionContext[] fieldDefinition() {
			return GetRuleContexts<FieldDefinitionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public FieldDefinitionContext fieldDefinition(int i) {
			return GetRuleContext<FieldDefinitionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public BatchSetDefinitionContext[] batchSetDefinition() {
			return GetRuleContexts<BatchSetDefinitionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public BatchSetDefinitionContext batchSetDefinition(int i) {
			return GetRuleContext<BatchSetDefinitionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ArgumentListContext argumentList() {
			return GetRuleContext<ArgumentListContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DISCRIMINATEDTYPE() { return GetToken(MSpecParser.DISCRIMINATEDTYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ENUM() { return GetToken(MSpecParser.ENUM, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DataTypeContext dataType() {
			return GetRuleContext<DataTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public EnumValueDefinitionContext[] enumValueDefinition() {
			return GetRuleContexts<EnumValueDefinitionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public EnumValueDefinitionContext enumValueDefinition(int i) {
			return GetRuleContext<EnumValueDefinitionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DATAIO() { return GetToken(MSpecParser.DATAIO, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DataIoDefinitionContext dataIoDefinition() {
			return GetRuleContext<DataIoDefinitionContext>(0);
		}
		public ComplexTypeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_complexType; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterComplexType(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitComplexType(this);
		}
	}

	[RuleVersion(0)]
	public ComplexTypeContext complexType() {
		ComplexTypeContext _localctx = new ComplexTypeContext(Context, State);
		EnterRule(_localctx, 10, RULE_complexType);
		int _la;
		try {
			State = 207;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case TYPE:
				EnterOuterAlt(_localctx, 1);
				{
				State = 146;
				Match(TYPE);
				State = 147;
				_localctx.name = idExpression();
				State = 152;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==LRBRACKET) {
					{
					State = 148;
					Match(LRBRACKET);
					State = 149;
					_localctx.@params = argumentList();
					State = 150;
					Match(RRBRACKET);
					}
				}

				State = 154;
				_localctx.attributes = attributeList();
				State = 159;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==LBRACKET) {
					{
					State = 157;
					ErrorHandler.Sync(this);
					switch ( Interpreter.AdaptivePredict(TokenStream,8,Context) ) {
					case 1:
						{
						State = 155;
						fieldDefinition();
						}
						break;
					case 2:
						{
						State = 156;
						batchSetDefinition();
						}
						break;
					}
					}
					State = 161;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				}
				break;
			case DISCRIMINATEDTYPE:
				EnterOuterAlt(_localctx, 2);
				{
				State = 162;
				Match(DISCRIMINATEDTYPE);
				State = 163;
				_localctx.name = idExpression();
				State = 168;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==LRBRACKET) {
					{
					State = 164;
					Match(LRBRACKET);
					State = 165;
					_localctx.@params = argumentList();
					State = 166;
					Match(RRBRACKET);
					}
				}

				State = 170;
				_localctx.attributes = attributeList();
				State = 175;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==LBRACKET) {
					{
					State = 173;
					ErrorHandler.Sync(this);
					switch ( Interpreter.AdaptivePredict(TokenStream,11,Context) ) {
					case 1:
						{
						State = 171;
						fieldDefinition();
						}
						break;
					case 2:
						{
						State = 172;
						batchSetDefinition();
						}
						break;
					}
					}
					State = 177;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				}
				break;
			case ENUM:
				EnterOuterAlt(_localctx, 3);
				{
				State = 178;
				Match(ENUM);
				State = 180;
				ErrorHandler.Sync(this);
				switch ( Interpreter.AdaptivePredict(TokenStream,13,Context) ) {
				case 1:
					{
					State = 179;
					_localctx.type = dataType();
					}
					break;
				}
				State = 182;
				_localctx.name = idExpression();
				State = 187;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==LRBRACKET) {
					{
					State = 183;
					Match(LRBRACKET);
					State = 184;
					_localctx.@params = argumentList();
					State = 185;
					Match(RRBRACKET);
					}
				}

				State = 189;
				_localctx.attributes = attributeList();
				State = 193;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==LBRACKET) {
					{
					{
					State = 190;
					_localctx.enumValues = enumValueDefinition();
					}
					}
					State = 195;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				}
				break;
			case DATAIO:
				EnterOuterAlt(_localctx, 4);
				{
				State = 196;
				Match(DATAIO);
				State = 197;
				_localctx.name = idExpression();
				State = 202;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==LRBRACKET) {
					{
					State = 198;
					Match(LRBRACKET);
					State = 199;
					_localctx.@params = argumentList();
					State = 200;
					Match(RRBRACKET);
					}
				}

				{
				State = 204;
				_localctx.attributes = attributeList();
				}
				State = 205;
				_localctx.dataIoTypeSwitch = dataIoDefinition();
				}
				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 FieldDefinitionContext : ParserRuleContext {
		public AttributeListContext attributes;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACKET() { return GetToken(MSpecParser.LBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public FieldContext field() {
			return GetRuleContext<FieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACKET() { return GetToken(MSpecParser.RBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public AttributeListContext attributeList() {
			return GetRuleContext<AttributeListContext>(0);
		}
		public FieldDefinitionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_fieldDefinition; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterFieldDefinition(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitFieldDefinition(this);
		}
	}

	[RuleVersion(0)]
	public FieldDefinitionContext fieldDefinition() {
		FieldDefinitionContext _localctx = new FieldDefinitionContext(Context, State);
		EnterRule(_localctx, 12, RULE_fieldDefinition);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 209;
			Match(LBRACKET);
			State = 210;
			field();
			{
			State = 211;
			_localctx.attributes = attributeList();
			}
			State = 212;
			Match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class BatchSetDefinitionContext : ParserRuleContext {
		public AttributeListContext attributes;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACKET() { return GetToken(MSpecParser.LBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BATCHSET() { return GetToken(MSpecParser.BATCHSET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACKET() { return GetToken(MSpecParser.RBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public AttributeListContext attributeList() {
			return GetRuleContext<AttributeListContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public FieldDefinitionContext[] fieldDefinition() {
			return GetRuleContexts<FieldDefinitionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public FieldDefinitionContext fieldDefinition(int i) {
			return GetRuleContext<FieldDefinitionContext>(i);
		}
		public BatchSetDefinitionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_batchSetDefinition; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterBatchSetDefinition(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitBatchSetDefinition(this);
		}
	}

	[RuleVersion(0)]
	public BatchSetDefinitionContext batchSetDefinition() {
		BatchSetDefinitionContext _localctx = new BatchSetDefinitionContext(Context, State);
		EnterRule(_localctx, 14, RULE_batchSetDefinition);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 214;
			Match(LBRACKET);
			State = 215;
			Match(BATCHSET);
			State = 216;
			_localctx.attributes = attributeList();
			State = 218;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			do {
				{
				{
				State = 217;
				fieldDefinition();
				}
				}
				State = 220;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			} while ( _la==LBRACKET );
			State = 222;
			Match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DataIoDefinitionContext : ParserRuleContext {
		public MultipleExpressionsContext @params;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] LBRACKET() { return GetTokens(MSpecParser.LBRACKET); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACKET(int i) {
			return GetToken(MSpecParser.LBRACKET, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeSwitchFieldContext typeSwitchField() {
			return GetRuleContext<TypeSwitchFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] RBRACKET() { return GetTokens(MSpecParser.RBRACKET); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACKET(int i) {
			return GetToken(MSpecParser.RBRACKET, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MultipleExpressionsContext multipleExpressions() {
			return GetRuleContext<MultipleExpressionsContext>(0);
		}
		public DataIoDefinitionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_dataIoDefinition; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterDataIoDefinition(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitDataIoDefinition(this);
		}
	}

	[RuleVersion(0)]
	public DataIoDefinitionContext dataIoDefinition() {
		DataIoDefinitionContext _localctx = new DataIoDefinitionContext(Context, State);
		EnterRule(_localctx, 16, RULE_dataIoDefinition);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 224;
			Match(LBRACKET);
			State = 225;
			typeSwitchField();
			State = 230;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==LBRACKET) {
				{
				State = 226;
				Match(LBRACKET);
				State = 227;
				_localctx.@params = multipleExpressions();
				State = 228;
				Match(RBRACKET);
				}
			}

			State = 232;
			Match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FieldContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public AbstractFieldContext abstractField() {
			return GetRuleContext<AbstractFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ArrayFieldContext arrayField() {
			return GetRuleContext<ArrayFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public AssertFieldContext assertField() {
			return GetRuleContext<AssertFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ChecksumFieldContext checksumField() {
			return GetRuleContext<ChecksumFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ConstFieldContext constField() {
			return GetRuleContext<ConstFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DiscriminatorFieldContext discriminatorField() {
			return GetRuleContext<DiscriminatorFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public EnumFieldContext enumField() {
			return GetRuleContext<EnumFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ImplicitFieldContext implicitField() {
			return GetRuleContext<ImplicitFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ManualArrayFieldContext manualArrayField() {
			return GetRuleContext<ManualArrayFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ManualFieldContext manualField() {
			return GetRuleContext<ManualFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public OptionalFieldContext optionalField() {
			return GetRuleContext<OptionalFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public PaddingFieldContext paddingField() {
			return GetRuleContext<PaddingFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public PeekFieldContext peekField() {
			return GetRuleContext<PeekFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ReservedFieldContext reservedField() {
			return GetRuleContext<ReservedFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SimpleFieldContext simpleField() {
			return GetRuleContext<SimpleFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public StateFieldContext stateField() {
			return GetRuleContext<StateFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeSwitchFieldContext typeSwitchField() {
			return GetRuleContext<TypeSwitchFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public UnknownFieldContext unknownField() {
			return GetRuleContext<UnknownFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ValidationFieldContext validationField() {
			return GetRuleContext<ValidationFieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public VirtualFieldContext virtualField() {
			return GetRuleContext<VirtualFieldContext>(0);
		}
		public FieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_field; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitField(this);
		}
	}

	[RuleVersion(0)]
	public FieldContext field() {
		FieldContext _localctx = new FieldContext(Context, State);
		EnterRule(_localctx, 18, RULE_field);
		try {
			State = 254;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case ABSTRACT:
				EnterOuterAlt(_localctx, 1);
				{
				State = 234;
				abstractField();
				}
				break;
			case ARRAY:
				EnterOuterAlt(_localctx, 2);
				{
				State = 235;
				arrayField();
				}
				break;
			case ASSERT:
				EnterOuterAlt(_localctx, 3);
				{
				State = 236;
				assertField();
				}
				break;
			case CHECKSUM:
				EnterOuterAlt(_localctx, 4);
				{
				State = 237;
				checksumField();
				}
				break;
			case CONST:
				EnterOuterAlt(_localctx, 5);
				{
				State = 238;
				constField();
				}
				break;
			case DISCRIMINATOR:
				EnterOuterAlt(_localctx, 6);
				{
				State = 239;
				discriminatorField();
				}
				break;
			case ENUM:
				EnterOuterAlt(_localctx, 7);
				{
				State = 240;
				enumField();
				}
				break;
			case IMPLICIT:
				EnterOuterAlt(_localctx, 8);
				{
				State = 241;
				implicitField();
				}
				break;
			case MANUALARRAY:
				EnterOuterAlt(_localctx, 9);
				{
				State = 242;
				manualArrayField();
				}
				break;
			case MANUAL:
				EnterOuterAlt(_localctx, 10);
				{
				State = 243;
				manualField();
				}
				break;
			case OPTIONAL:
				EnterOuterAlt(_localctx, 11);
				{
				State = 244;
				optionalField();
				}
				break;
			case PADDING:
				EnterOuterAlt(_localctx, 12);
				{
				State = 245;
				paddingField();
				}
				break;
			case PEEK:
				EnterOuterAlt(_localctx, 13);
				{
				State = 246;
				peekField();
				}
				break;
			case RESERVED:
				EnterOuterAlt(_localctx, 14);
				{
				State = 247;
				reservedField();
				}
				break;
			case SIMPLE:
				EnterOuterAlt(_localctx, 15);
				{
				State = 248;
				simpleField();
				}
				break;
			case STATE:
				EnterOuterAlt(_localctx, 16);
				{
				State = 249;
				stateField();
				}
				break;
			case TYPESWITCH:
				EnterOuterAlt(_localctx, 17);
				{
				State = 250;
				typeSwitchField();
				}
				break;
			case UNKNOWN:
				EnterOuterAlt(_localctx, 18);
				{
				State = 251;
				unknownField();
				}
				break;
			case VALIDATION:
				EnterOuterAlt(_localctx, 19);
				{
				State = 252;
				validationField();
				}
				break;
			case VIRTUAL:
				EnterOuterAlt(_localctx, 20);
				{
				State = 253;
				virtualField();
				}
				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 AbstractFieldContext : ParserRuleContext {
		public TypeReferenceContext type;
		public IdExpressionContext name;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ABSTRACT() { return GetToken(MSpecParser.ABSTRACT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeReferenceContext typeReference() {
			return GetRuleContext<TypeReferenceContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		public AbstractFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_abstractField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterAbstractField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitAbstractField(this);
		}
	}

	[RuleVersion(0)]
	public AbstractFieldContext abstractField() {
		AbstractFieldContext _localctx = new AbstractFieldContext(Context, State);
		EnterRule(_localctx, 20, RULE_abstractField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 256;
			Match(ABSTRACT);
			State = 257;
			_localctx.type = typeReference();
			State = 258;
			_localctx.name = idExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ArrayFieldContext : ParserRuleContext {
		public TypeReferenceContext type;
		public IdExpressionContext name;
		public IToken loopType;
		public ExpressionContext loopExpression;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY() { return GetToken(MSpecParser.ARRAY, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeReferenceContext typeReference() {
			return GetRuleContext<TypeReferenceContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY_LOOP_TYPE() { return GetToken(MSpecParser.ARRAY_LOOP_TYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ArrayFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_arrayField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterArrayField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitArrayField(this);
		}
	}

	[RuleVersion(0)]
	public ArrayFieldContext arrayField() {
		ArrayFieldContext _localctx = new ArrayFieldContext(Context, State);
		EnterRule(_localctx, 22, RULE_arrayField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 260;
			Match(ARRAY);
			State = 261;
			_localctx.type = typeReference();
			State = 262;
			_localctx.name = idExpression();
			State = 263;
			_localctx.loopType = Match(ARRAY_LOOP_TYPE);
			State = 264;
			_localctx.loopExpression = expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AssertFieldContext : ParserRuleContext {
		public TypeReferenceContext type;
		public IdExpressionContext name;
		public ExpressionContext condition;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASSERT() { return GetToken(MSpecParser.ASSERT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeReferenceContext typeReference() {
			return GetRuleContext<TypeReferenceContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public AssertFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_assertField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterAssertField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitAssertField(this);
		}
	}

	[RuleVersion(0)]
	public AssertFieldContext assertField() {
		AssertFieldContext _localctx = new AssertFieldContext(Context, State);
		EnterRule(_localctx, 24, RULE_assertField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 266;
			Match(ASSERT);
			State = 267;
			_localctx.type = typeReference();
			State = 268;
			_localctx.name = idExpression();
			State = 269;
			_localctx.condition = expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ChecksumFieldContext : ParserRuleContext {
		public DataTypeContext type;
		public IdExpressionContext name;
		public ExpressionContext checksumExpression;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CHECKSUM() { return GetToken(MSpecParser.CHECKSUM, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DataTypeContext dataType() {
			return GetRuleContext<DataTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ChecksumFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_checksumField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterChecksumField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitChecksumField(this);
		}
	}

	[RuleVersion(0)]
	public ChecksumFieldContext checksumField() {
		ChecksumFieldContext _localctx = new ChecksumFieldContext(Context, State);
		EnterRule(_localctx, 26, RULE_checksumField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 271;
			Match(CHECKSUM);
			State = 272;
			_localctx.type = dataType();
			State = 273;
			_localctx.name = idExpression();
			State = 274;
			_localctx.checksumExpression = expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ConstFieldContext : ParserRuleContext {
		public TypeReferenceContext type;
		public IdExpressionContext name;
		public ValueLiteralContext expected;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONST() { return GetToken(MSpecParser.CONST, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeReferenceContext typeReference() {
			return GetRuleContext<TypeReferenceContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ValueLiteralContext valueLiteral() {
			return GetRuleContext<ValueLiteralContext>(0);
		}
		public ConstFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_constField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterConstField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitConstField(this);
		}
	}

	[RuleVersion(0)]
	public ConstFieldContext constField() {
		ConstFieldContext _localctx = new ConstFieldContext(Context, State);
		EnterRule(_localctx, 28, RULE_constField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 276;
			Match(CONST);
			State = 277;
			_localctx.type = typeReference();
			State = 278;
			_localctx.name = idExpression();
			State = 279;
			_localctx.expected = valueLiteral();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DiscriminatorFieldContext : ParserRuleContext {
		public TypeReferenceContext type;
		public IdExpressionContext name;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DISCRIMINATOR() { return GetToken(MSpecParser.DISCRIMINATOR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeReferenceContext typeReference() {
			return GetRuleContext<TypeReferenceContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		public DiscriminatorFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_discriminatorField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterDiscriminatorField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitDiscriminatorField(this);
		}
	}

	[RuleVersion(0)]
	public DiscriminatorFieldContext discriminatorField() {
		DiscriminatorFieldContext _localctx = new DiscriminatorFieldContext(Context, State);
		EnterRule(_localctx, 30, RULE_discriminatorField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 281;
			Match(DISCRIMINATOR);
			State = 282;
			_localctx.type = typeReference();
			State = 283;
			_localctx.name = idExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class EnumFieldContext : ParserRuleContext {
		public TypeReferenceContext type;
		public IdExpressionContext name;
		public IdExpressionContext fieldName;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ENUM() { return GetToken(MSpecParser.ENUM, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeReferenceContext typeReference() {
			return GetRuleContext<TypeReferenceContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext[] idExpression() {
			return GetRuleContexts<IdExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression(int i) {
			return GetRuleContext<IdExpressionContext>(i);
		}
		public EnumFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_enumField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterEnumField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitEnumField(this);
		}
	}

	[RuleVersion(0)]
	public EnumFieldContext enumField() {
		EnumFieldContext _localctx = new EnumFieldContext(Context, State);
		EnterRule(_localctx, 32, RULE_enumField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 285;
			Match(ENUM);
			State = 286;
			_localctx.type = typeReference();
			State = 287;
			_localctx.name = idExpression();
			State = 288;
			_localctx.fieldName = idExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ImplicitFieldContext : ParserRuleContext {
		public DataTypeContext type;
		public IdExpressionContext name;
		public ExpressionContext serializeExpression;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IMPLICIT() { return GetToken(MSpecParser.IMPLICIT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DataTypeContext dataType() {
			return GetRuleContext<DataTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ImplicitFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_implicitField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterImplicitField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitImplicitField(this);
		}
	}

	[RuleVersion(0)]
	public ImplicitFieldContext implicitField() {
		ImplicitFieldContext _localctx = new ImplicitFieldContext(Context, State);
		EnterRule(_localctx, 34, RULE_implicitField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 290;
			Match(IMPLICIT);
			State = 291;
			_localctx.type = dataType();
			State = 292;
			_localctx.name = idExpression();
			State = 293;
			_localctx.serializeExpression = expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ManualArrayFieldContext : ParserRuleContext {
		public TypeReferenceContext type;
		public IdExpressionContext name;
		public IToken loopType;
		public ExpressionContext loopExpression;
		public ExpressionContext parseExpression;
		public ExpressionContext serializeExpression;
		public ExpressionContext lengthExpression;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MANUALARRAY() { return GetToken(MSpecParser.MANUALARRAY, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeReferenceContext typeReference() {
			return GetRuleContext<TypeReferenceContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY_LOOP_TYPE() { return GetToken(MSpecParser.ARRAY_LOOP_TYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public ManualArrayFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_manualArrayField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterManualArrayField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitManualArrayField(this);
		}
	}

	[RuleVersion(0)]
	public ManualArrayFieldContext manualArrayField() {
		ManualArrayFieldContext _localctx = new ManualArrayFieldContext(Context, State);
		EnterRule(_localctx, 36, RULE_manualArrayField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 295;
			Match(MANUALARRAY);
			State = 296;
			_localctx.type = typeReference();
			State = 297;
			_localctx.name = idExpression();
			State = 298;
			_localctx.loopType = Match(ARRAY_LOOP_TYPE);
			State = 299;
			_localctx.loopExpression = expression();
			State = 300;
			_localctx.parseExpression = expression();
			State = 301;
			_localctx.serializeExpression = expression();
			State = 302;
			_localctx.lengthExpression = expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ManualFieldContext : ParserRuleContext {
		public TypeReferenceContext type;
		public IdExpressionContext name;
		public ExpressionContext parseExpression;
		public ExpressionContext serializeExpression;
		public ExpressionContext lengthExpression;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MANUAL() { return GetToken(MSpecParser.MANUAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeReferenceContext typeReference() {
			return GetRuleContext<TypeReferenceContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public ManualFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_manualField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterManualField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitManualField(this);
		}
	}

	[RuleVersion(0)]
	public ManualFieldContext manualField() {
		ManualFieldContext _localctx = new ManualFieldContext(Context, State);
		EnterRule(_localctx, 38, RULE_manualField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 304;
			Match(MANUAL);
			State = 305;
			_localctx.type = typeReference();
			State = 306;
			_localctx.name = idExpression();
			State = 307;
			_localctx.parseExpression = expression();
			State = 308;
			_localctx.serializeExpression = expression();
			State = 309;
			_localctx.lengthExpression = expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class OptionalFieldContext : ParserRuleContext {
		public TypeReferenceContext type;
		public IdExpressionContext name;
		public ExpressionContext condition;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OPTIONAL() { return GetToken(MSpecParser.OPTIONAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeReferenceContext typeReference() {
			return GetRuleContext<TypeReferenceContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public OptionalFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_optionalField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterOptionalField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitOptionalField(this);
		}
	}

	[RuleVersion(0)]
	public OptionalFieldContext optionalField() {
		OptionalFieldContext _localctx = new OptionalFieldContext(Context, State);
		EnterRule(_localctx, 40, RULE_optionalField);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 311;
			Match(OPTIONAL);
			State = 312;
			_localctx.type = typeReference();
			State = 313;
			_localctx.name = idExpression();
			State = 315;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==TICK || _la==ASTERISK) {
				{
				State = 314;
				_localctx.condition = expression();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class PaddingFieldContext : ParserRuleContext {
		public DataTypeContext type;
		public IdExpressionContext name;
		public ExpressionContext paddingValue;
		public ExpressionContext timesPadding;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PADDING() { return GetToken(MSpecParser.PADDING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DataTypeContext dataType() {
			return GetRuleContext<DataTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public PaddingFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_paddingField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterPaddingField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitPaddingField(this);
		}
	}

	[RuleVersion(0)]
	public PaddingFieldContext paddingField() {
		PaddingFieldContext _localctx = new PaddingFieldContext(Context, State);
		EnterRule(_localctx, 42, RULE_paddingField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 317;
			Match(PADDING);
			State = 318;
			_localctx.type = dataType();
			State = 319;
			_localctx.name = idExpression();
			State = 320;
			_localctx.paddingValue = expression();
			State = 321;
			_localctx.timesPadding = expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class PeekFieldContext : ParserRuleContext {
		public TypeReferenceContext type;
		public IdExpressionContext name;
		public ExpressionContext offset;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PEEK() { return GetToken(MSpecParser.PEEK, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeReferenceContext typeReference() {
			return GetRuleContext<TypeReferenceContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public PeekFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_peekField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterPeekField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitPeekField(this);
		}
	}

	[RuleVersion(0)]
	public PeekFieldContext peekField() {
		PeekFieldContext _localctx = new PeekFieldContext(Context, State);
		EnterRule(_localctx, 44, RULE_peekField);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 323;
			Match(PEEK);
			State = 324;
			_localctx.type = typeReference();
			State = 325;
			_localctx.name = idExpression();
			State = 327;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==TICK || _la==ASTERISK) {
				{
				State = 326;
				_localctx.offset = expression();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ReservedFieldContext : ParserRuleContext {
		public DataTypeContext type;
		public ExpressionContext expected;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RESERVED() { return GetToken(MSpecParser.RESERVED, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DataTypeContext dataType() {
			return GetRuleContext<DataTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ReservedFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_reservedField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterReservedField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitReservedField(this);
		}
	}

	[RuleVersion(0)]
	public ReservedFieldContext reservedField() {
		ReservedFieldContext _localctx = new ReservedFieldContext(Context, State);
		EnterRule(_localctx, 46, RULE_reservedField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 329;
			Match(RESERVED);
			State = 330;
			_localctx.type = dataType();
			State = 331;
			_localctx.expected = expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SimpleFieldContext : ParserRuleContext {
		public TypeReferenceContext type;
		public IdExpressionContext name;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SIMPLE() { return GetToken(MSpecParser.SIMPLE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeReferenceContext typeReference() {
			return GetRuleContext<TypeReferenceContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		public SimpleFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_simpleField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterSimpleField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitSimpleField(this);
		}
	}

	[RuleVersion(0)]
	public SimpleFieldContext simpleField() {
		SimpleFieldContext _localctx = new SimpleFieldContext(Context, State);
		EnterRule(_localctx, 48, RULE_simpleField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 333;
			Match(SIMPLE);
			State = 334;
			_localctx.type = typeReference();
			State = 335;
			_localctx.name = idExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class StateFieldContext : ParserRuleContext {
		public IdExpressionContext name;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STATE() { return GetToken(MSpecParser.STATE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		public StateFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_stateField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterStateField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitStateField(this);
		}
	}

	[RuleVersion(0)]
	public StateFieldContext stateField() {
		StateFieldContext _localctx = new StateFieldContext(Context, State);
		EnterRule(_localctx, 50, RULE_stateField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 337;
			Match(STATE);
			State = 338;
			_localctx.name = idExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TypeSwitchFieldContext : ParserRuleContext {
		public MultipleVariableLiteralsContext discriminators;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TYPESWITCH() { return GetToken(MSpecParser.TYPESWITCH, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public MultipleVariableLiteralsContext multipleVariableLiterals() {
			return GetRuleContext<MultipleVariableLiteralsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CaseStatementContext[] caseStatement() {
			return GetRuleContexts<CaseStatementContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public CaseStatementContext caseStatement(int i) {
			return GetRuleContext<CaseStatementContext>(i);
		}
		public TypeSwitchFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_typeSwitchField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterTypeSwitchField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitTypeSwitchField(this);
		}
	}

	[RuleVersion(0)]
	public TypeSwitchFieldContext typeSwitchField() {
		TypeSwitchFieldContext _localctx = new TypeSwitchFieldContext(Context, State);
		EnterRule(_localctx, 52, RULE_typeSwitchField);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 340;
			Match(TYPESWITCH);
			State = 341;
			_localctx.discriminators = multipleVariableLiterals();
			State = 345;
			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 = 342;
					caseStatement();
					}
					} 
				}
				State = 347;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,23,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class UnknownFieldContext : ParserRuleContext {
		public DataTypeContext type;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UNKNOWN() { return GetToken(MSpecParser.UNKNOWN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DataTypeContext dataType() {
			return GetRuleContext<DataTypeContext>(0);
		}
		public UnknownFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_unknownField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterUnknownField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitUnknownField(this);
		}
	}

	[RuleVersion(0)]
	public UnknownFieldContext unknownField() {
		UnknownFieldContext _localctx = new UnknownFieldContext(Context, State);
		EnterRule(_localctx, 54, RULE_unknownField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 348;
			Match(UNKNOWN);
			State = 349;
			_localctx.type = dataType();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ValidationFieldContext : ParserRuleContext {
		public ExpressionContext validationExpression;
		public IToken description;
		public IToken shouldFail;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VALIDATION() { return GetToken(MSpecParser.VALIDATION, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SHOULD_FAIL() { return GetToken(MSpecParser.SHOULD_FAIL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRING_LITERAL() { return GetToken(MSpecParser.STRING_LITERAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BOOLEAN_LITERAL() { return GetToken(MSpecParser.BOOLEAN_LITERAL, 0); }
		public ValidationFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_validationField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterValidationField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitValidationField(this);
		}
	}

	[RuleVersion(0)]
	public ValidationFieldContext validationField() {
		ValidationFieldContext _localctx = new ValidationFieldContext(Context, State);
		EnterRule(_localctx, 56, RULE_validationField);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 351;
			Match(VALIDATION);
			State = 352;
			_localctx.validationExpression = expression();
			State = 354;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==STRING_LITERAL) {
				{
				State = 353;
				_localctx.description = Match(STRING_LITERAL);
				}
			}

			State = 359;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==SHOULD_FAIL) {
				{
				State = 356;
				Match(SHOULD_FAIL);
				State = 357;
				Match(T__0);
				State = 358;
				_localctx.shouldFail = Match(BOOLEAN_LITERAL);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class VirtualFieldContext : ParserRuleContext {
		public TypeReferenceContext type;
		public IdExpressionContext name;
		public ExpressionContext valueExpression;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VIRTUAL() { return GetToken(MSpecParser.VIRTUAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeReferenceContext typeReference() {
			return GetRuleContext<TypeReferenceContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public VirtualFieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_virtualField; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterVirtualField(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitVirtualField(this);
		}
	}

	[RuleVersion(0)]
	public VirtualFieldContext virtualField() {
		VirtualFieldContext _localctx = new VirtualFieldContext(Context, State);
		EnterRule(_localctx, 58, RULE_virtualField);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 361;
			Match(VIRTUAL);
			State = 362;
			_localctx.type = typeReference();
			State = 363;
			_localctx.name = idExpression();
			State = 364;
			_localctx.valueExpression = expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class EnumValueDefinitionContext : ParserRuleContext {
		public ExpressionContext valueExpression;
		public IToken name;
		public MultipleExpressionsContext constantValueExpressions;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] LBRACKET() { return GetTokens(MSpecParser.LBRACKET); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACKET(int i) {
			return GetToken(MSpecParser.LBRACKET, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] RBRACKET() { return GetTokens(MSpecParser.RBRACKET); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACKET(int i) {
			return GetToken(MSpecParser.RBRACKET, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER_LITERAL() { return GetToken(MSpecParser.IDENTIFIER_LITERAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MultipleExpressionsContext multipleExpressions() {
			return GetRuleContext<MultipleExpressionsContext>(0);
		}
		public EnumValueDefinitionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_enumValueDefinition; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterEnumValueDefinition(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitEnumValueDefinition(this);
		}
	}

	[RuleVersion(0)]
	public EnumValueDefinitionContext enumValueDefinition() {
		EnumValueDefinitionContext _localctx = new EnumValueDefinitionContext(Context, State);
		EnterRule(_localctx, 60, RULE_enumValueDefinition);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 366;
			Match(LBRACKET);
			State = 368;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==TICK || _la==ASTERISK) {
				{
				State = 367;
				_localctx.valueExpression = expression();
				}
			}

			State = 370;
			_localctx.name = Match(IDENTIFIER_LITERAL);
			State = 375;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==LBRACKET) {
				{
				State = 371;
				Match(LBRACKET);
				State = 372;
				_localctx.constantValueExpressions = multipleExpressions();
				State = 373;
				Match(RBRACKET);
				}
			}

			State = 377;
			Match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TypeReferenceContext : ParserRuleContext {
		public IToken complexTypeReference;
		public MultipleExpressionsContext @params;
		public DataTypeContext simpleTypeReference;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER_LITERAL() { return GetToken(MSpecParser.IDENTIFIER_LITERAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LRBRACKET() { return GetToken(MSpecParser.LRBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RRBRACKET() { return GetToken(MSpecParser.RRBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public MultipleExpressionsContext multipleExpressions() {
			return GetRuleContext<MultipleExpressionsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DataTypeContext dataType() {
			return GetRuleContext<DataTypeContext>(0);
		}
		public TypeReferenceContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_typeReference; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterTypeReference(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitTypeReference(this);
		}
	}

	[RuleVersion(0)]
	public TypeReferenceContext typeReference() {
		TypeReferenceContext _localctx = new TypeReferenceContext(Context, State);
		EnterRule(_localctx, 62, RULE_typeReference);
		int _la;
		try {
			State = 387;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case IDENTIFIER_LITERAL:
				EnterOuterAlt(_localctx, 1);
				{
				State = 379;
				_localctx.complexTypeReference = Match(IDENTIFIER_LITERAL);
				State = 384;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==LRBRACKET) {
					{
					State = 380;
					Match(LRBRACKET);
					State = 381;
					_localctx.@params = multipleExpressions();
					State = 382;
					Match(RRBRACKET);
					}
				}

				}
				break;
			case BIT:
			case BYTE:
			case INT:
			case VINT:
			case UINT:
			case VUINT:
			case FLOAT:
			case UFLOAT:
			case STRING:
			case VSTRING:
			case TIME:
			case DATE:
			case DATETIME:
				EnterOuterAlt(_localctx, 2);
				{
				State = 386;
				_localctx.simpleTypeReference = dataType();
				}
				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 CaseStatementContext : ParserRuleContext {
		public MultipleExpressionsContext discriminatorValues;
		public IToken nameWildcard;
		public IToken name;
		public ArgumentListContext @params;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACKET() { return GetToken(MSpecParser.LBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACKET() { return GetToken(MSpecParser.RBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER_LITERAL() { return GetToken(MSpecParser.IDENTIFIER_LITERAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LRBRACKET() { return GetToken(MSpecParser.LRBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RRBRACKET() { return GetToken(MSpecParser.RRBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public FieldDefinitionContext[] fieldDefinition() {
			return GetRuleContexts<FieldDefinitionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public FieldDefinitionContext fieldDefinition(int i) {
			return GetRuleContext<FieldDefinitionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public BatchSetDefinitionContext[] batchSetDefinition() {
			return GetRuleContexts<BatchSetDefinitionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public BatchSetDefinitionContext batchSetDefinition(int i) {
			return GetRuleContext<BatchSetDefinitionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MultipleExpressionsContext multipleExpressions() {
			return GetRuleContext<MultipleExpressionsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASTERISK() { return GetToken(MSpecParser.ASTERISK, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ArgumentListContext argumentList() {
			return GetRuleContext<ArgumentListContext>(0);
		}
		public CaseStatementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_caseStatement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterCaseStatement(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitCaseStatement(this);
		}
	}

	[RuleVersion(0)]
	public CaseStatementContext caseStatement() {
		CaseStatementContext _localctx = new CaseStatementContext(Context, State);
		EnterRule(_localctx, 64, RULE_caseStatement);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 389;
			Match(LBRACKET);
			State = 391;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,30,Context) ) {
			case 1:
				{
				State = 390;
				_localctx.discriminatorValues = multipleExpressions();
				}
				break;
			}
			State = 394;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==ASTERISK) {
				{
				State = 393;
				_localctx.nameWildcard = Match(ASTERISK);
				}
			}

			State = 396;
			_localctx.name = Match(IDENTIFIER_LITERAL);
			State = 401;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==LRBRACKET) {
				{
				State = 397;
				Match(LRBRACKET);
				State = 398;
				_localctx.@params = argumentList();
				State = 399;
				Match(RRBRACKET);
				}
			}

			State = 407;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==LBRACKET) {
				{
				State = 405;
				ErrorHandler.Sync(this);
				switch ( Interpreter.AdaptivePredict(TokenStream,33,Context) ) {
				case 1:
					{
					State = 403;
					fieldDefinition();
					}
					break;
				case 2:
					{
					State = 404;
					batchSetDefinition();
					}
					break;
				}
				}
				State = 409;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 410;
			Match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DataTypeContext : ParserRuleContext {
		public IToken @base;
		public IToken size;
		public ExpressionContext length;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BIT() { return GetToken(MSpecParser.BIT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BYTE() { return GetToken(MSpecParser.BYTE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT() { return GetToken(MSpecParser.INT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INTEGER_LITERAL() { return GetToken(MSpecParser.INTEGER_LITERAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VINT() { return GetToken(MSpecParser.VINT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT() { return GetToken(MSpecParser.UINT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VUINT() { return GetToken(MSpecParser.VUINT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT() { return GetToken(MSpecParser.FLOAT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UFLOAT() { return GetToken(MSpecParser.UFLOAT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRING() { return GetToken(MSpecParser.STRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VSTRING() { return GetToken(MSpecParser.VSTRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TIME() { return GetToken(MSpecParser.TIME, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DATE() { return GetToken(MSpecParser.DATE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DATETIME() { return GetToken(MSpecParser.DATETIME, 0); }
		public DataTypeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_dataType; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterDataType(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitDataType(this);
		}
	}

	[RuleVersion(0)]
	public DataTypeContext dataType() {
		DataTypeContext _localctx = new DataTypeContext(Context, State);
		EnterRule(_localctx, 66, RULE_dataType);
		try {
			State = 433;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case BIT:
				EnterOuterAlt(_localctx, 1);
				{
				State = 412;
				_localctx.@base = Match(BIT);
				}
				break;
			case BYTE:
				EnterOuterAlt(_localctx, 2);
				{
				State = 413;
				_localctx.@base = Match(BYTE);
				}
				break;
			case INT:
				EnterOuterAlt(_localctx, 3);
				{
				State = 414;
				_localctx.@base = Match(INT);
				State = 415;
				_localctx.size = Match(INTEGER_LITERAL);
				}
				break;
			case VINT:
				EnterOuterAlt(_localctx, 4);
				{
				State = 416;
				_localctx.@base = Match(VINT);
				}
				break;
			case UINT:
				EnterOuterAlt(_localctx, 5);
				{
				State = 417;
				_localctx.@base = Match(UINT);
				State = 418;
				_localctx.size = Match(INTEGER_LITERAL);
				}
				break;
			case VUINT:
				EnterOuterAlt(_localctx, 6);
				{
				State = 419;
				_localctx.@base = Match(VUINT);
				}
				break;
			case FLOAT:
				EnterOuterAlt(_localctx, 7);
				{
				State = 420;
				_localctx.@base = Match(FLOAT);
				State = 421;
				_localctx.size = Match(INTEGER_LITERAL);
				}
				break;
			case UFLOAT:
				EnterOuterAlt(_localctx, 8);
				{
				State = 422;
				_localctx.@base = Match(UFLOAT);
				State = 423;
				_localctx.size = Match(INTEGER_LITERAL);
				}
				break;
			case STRING:
				EnterOuterAlt(_localctx, 9);
				{
				State = 424;
				_localctx.@base = Match(STRING);
				State = 425;
				_localctx.size = Match(INTEGER_LITERAL);
				}
				break;
			case VSTRING:
				EnterOuterAlt(_localctx, 10);
				{
				State = 426;
				_localctx.@base = Match(VSTRING);
				State = 428;
				ErrorHandler.Sync(this);
				switch ( Interpreter.AdaptivePredict(TokenStream,35,Context) ) {
				case 1:
					{
					State = 427;
					_localctx.length = expression();
					}
					break;
				}
				}
				break;
			case TIME:
				EnterOuterAlt(_localctx, 11);
				{
				State = 430;
				_localctx.@base = Match(TIME);
				}
				break;
			case DATE:
				EnterOuterAlt(_localctx, 12);
				{
				State = 431;
				_localctx.@base = Match(DATE);
				}
				break;
			case DATETIME:
				EnterOuterAlt(_localctx, 13);
				{
				State = 432;
				_localctx.@base = Match(DATETIME);
				}
				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 AttributeContext : ParserRuleContext {
		public IToken name;
		public ExpressionContext value;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER_LITERAL() { return GetToken(MSpecParser.IDENTIFIER_LITERAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public AttributeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_attribute; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterAttribute(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitAttribute(this);
		}
	}

	[RuleVersion(0)]
	public AttributeContext attribute() {
		AttributeContext _localctx = new AttributeContext(Context, State);
		EnterRule(_localctx, 68, RULE_attribute);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 435;
			_localctx.name = Match(IDENTIFIER_LITERAL);
			State = 436;
			Match(T__0);
			State = 437;
			_localctx.value = expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AttributeListContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public AttributeContext[] attribute() {
			return GetRuleContexts<AttributeContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public AttributeContext attribute(int i) {
			return GetRuleContext<AttributeContext>(i);
		}
		public AttributeListContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_attributeList; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterAttributeList(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitAttributeList(this);
		}
	}

	[RuleVersion(0)]
	public AttributeListContext attributeList() {
		AttributeListContext _localctx = new AttributeListContext(Context, State);
		EnterRule(_localctx, 70, RULE_attributeList);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 442;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==IDENTIFIER_LITERAL) {
				{
				{
				State = 439;
				attribute();
				}
				}
				State = 444;
				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 ArgumentContext : ParserRuleContext {
		public TypeReferenceContext type;
		public IdExpressionContext name;
		[System.Diagnostics.DebuggerNonUserCode] public TypeReferenceContext typeReference() {
			return GetRuleContext<TypeReferenceContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		public ArgumentContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_argument; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterArgument(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitArgument(this);
		}
	}

	[RuleVersion(0)]
	public ArgumentContext argument() {
		ArgumentContext _localctx = new ArgumentContext(Context, State);
		EnterRule(_localctx, 72, RULE_argument);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 445;
			_localctx.type = typeReference();
			State = 446;
			_localctx.name = idExpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ArgumentListContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ArgumentContext[] argument() {
			return GetRuleContexts<ArgumentContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ArgumentContext argument(int i) {
			return GetRuleContext<ArgumentContext>(i);
		}
		public ArgumentListContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_argumentList; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterArgumentList(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitArgumentList(this);
		}
	}

	[RuleVersion(0)]
	public ArgumentListContext argumentList() {
		ArgumentListContext _localctx = new ArgumentListContext(Context, State);
		EnterRule(_localctx, 74, RULE_argumentList);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 448;
			argument();
			State = 453;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==T__1) {
				{
				{
				State = 449;
				Match(T__1);
				State = 450;
				argument();
				}
				}
				State = 455;
				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 ExpressionContext : ParserRuleContext {
		public InnerExpressionContext expr;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] TICK() { return GetTokens(MSpecParser.TICK); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TICK(int i) {
			return GetToken(MSpecParser.TICK, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public InnerExpressionContext innerExpression() {
			return GetRuleContext<InnerExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASTERISK() { return GetToken(MSpecParser.ASTERISK, 0); }
		public ExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_expression; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitExpression(this);
		}
	}

	[RuleVersion(0)]
	public ExpressionContext expression() {
		ExpressionContext _localctx = new ExpressionContext(Context, State);
		EnterRule(_localctx, 76, RULE_expression);
		try {
			State = 461;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case TICK:
				EnterOuterAlt(_localctx, 1);
				{
				State = 456;
				Match(TICK);
				State = 457;
				_localctx.expr = innerExpression(0);
				State = 458;
				Match(TICK);
				}
				break;
			case ASTERISK:
				EnterOuterAlt(_localctx, 2);
				{
				State = 460;
				Match(ASTERISK);
				}
				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 MultipleExpressionsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public MultipleExpressionsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_multipleExpressions; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterMultipleExpressions(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitMultipleExpressions(this);
		}
	}

	[RuleVersion(0)]
	public MultipleExpressionsContext multipleExpressions() {
		MultipleExpressionsContext _localctx = new MultipleExpressionsContext(Context, State);
		EnterRule(_localctx, 78, RULE_multipleExpressions);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 463;
			expression();
			State = 468;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==T__1) {
				{
				{
				State = 464;
				Match(T__1);
				State = 465;
				expression();
				}
				}
				State = 470;
				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 MultipleVariableLiteralsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public VariableLiteralContext[] variableLiteral() {
			return GetRuleContexts<VariableLiteralContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public VariableLiteralContext variableLiteral(int i) {
			return GetRuleContext<VariableLiteralContext>(i);
		}
		public MultipleVariableLiteralsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_multipleVariableLiterals; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterMultipleVariableLiterals(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitMultipleVariableLiterals(this);
		}
	}

	[RuleVersion(0)]
	public MultipleVariableLiteralsContext multipleVariableLiterals() {
		MultipleVariableLiteralsContext _localctx = new MultipleVariableLiteralsContext(Context, State);
		EnterRule(_localctx, 80, RULE_multipleVariableLiterals);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 471;
			variableLiteral(0);
			State = 476;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==T__1) {
				{
				{
				State = 472;
				Match(T__1);
				State = 473;
				variableLiteral(0);
				}
				}
				State = 478;
				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 VariableLiteralContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER_LITERAL() { return GetToken(MSpecParser.IDENTIFIER_LITERAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public VariableLiteralContext variableLiteral() {
			return GetRuleContext<VariableLiteralContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACKET() { return GetToken(MSpecParser.RBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] LBRACKET() { return GetTokens(MSpecParser.LBRACKET); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACKET(int i) {
			return GetToken(MSpecParser.LBRACKET, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] INTEGER_LITERAL() { return GetTokens(MSpecParser.INTEGER_LITERAL); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INTEGER_LITERAL(int i) {
			return GetToken(MSpecParser.INTEGER_LITERAL, i);
		}
		public VariableLiteralContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_variableLiteral; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterVariableLiteral(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitVariableLiteral(this);
		}
	}

	[RuleVersion(0)]
	public VariableLiteralContext variableLiteral() {
		return variableLiteral(0);
	}

	private VariableLiteralContext variableLiteral(int _p) {
		ParserRuleContext _parentctx = Context;
		int _parentState = State;
		VariableLiteralContext _localctx = new VariableLiteralContext(Context, _parentState);
		VariableLiteralContext _prevctx = _localctx;
		int _startState = 82;
		EnterRecursionRule(_localctx, 82, RULE_variableLiteral, _p);
		int _la;
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 484;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,42,Context) ) {
			case 1:
				{
				State = 480;
				Match(IDENTIFIER_LITERAL);
				}
				break;
			case 2:
				{
				State = 481;
				Match(IDENTIFIER_LITERAL);
				State = 482;
				Match(T__2);
				State = 483;
				variableLiteral(2);
				}
				break;
			}
			Context.Stop = TokenStream.LT(-1);
			State = 500;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,45,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( ParseListeners!=null )
						TriggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new VariableLiteralContext(_parentctx, _parentState);
					PushNewRecursionContext(_localctx, _startState, RULE_variableLiteral);
					State = 486;
					if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)");
					State = 488;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					do {
						{
						{
						State = 487;
						Match(LBRACKET);
						}
						}
						State = 490;
						ErrorHandler.Sync(this);
						_la = TokenStream.LA(1);
					} while ( _la==LBRACKET );
					State = 493;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					do {
						{
						{
						State = 492;
						Match(INTEGER_LITERAL);
						}
						}
						State = 495;
						ErrorHandler.Sync(this);
						_la = TokenStream.LA(1);
					} while ( _la==INTEGER_LITERAL );
					State = 497;
					Match(RBRACKET);
					}
					} 
				}
				State = 502;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,45,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			UnrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public partial class InnerExpressionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ValueLiteralContext valueLiteral() {
			return GetRuleContext<ValueLiteralContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY_LOOP_TYPE() { return GetToken(MSpecParser.ARRAY_LOOP_TYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public IdExpressionContext idExpression() {
			return GetRuleContext<IdExpressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LRBRACKET() { return GetToken(MSpecParser.LRBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RRBRACKET() { return GetToken(MSpecParser.RRBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] LBRACKET() { return GetTokens(MSpecParser.LBRACKET); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACKET(int i) {
			return GetToken(MSpecParser.LBRACKET, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public InnerExpressionContext[] innerExpression() {
			return GetRuleContexts<InnerExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public InnerExpressionContext innerExpression(int i) {
			return GetRuleContext<InnerExpressionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACKET() { return GetToken(MSpecParser.RBRACKET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public BinaryOperatorContext binaryOperator() {
			return GetRuleContext<BinaryOperatorContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] INTEGER_LITERAL() { return GetTokens(MSpecParser.INTEGER_LITERAL); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INTEGER_LITERAL(int i) {
			return GetToken(MSpecParser.INTEGER_LITERAL, i);
		}
		public InnerExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_innerExpression; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterInnerExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitInnerExpression(this);
		}
	}

	[RuleVersion(0)]
	public InnerExpressionContext innerExpression() {
		return innerExpression(0);
	}

	private InnerExpressionContext innerExpression(int _p) {
		ParserRuleContext _parentctx = Context;
		int _parentState = State;
		InnerExpressionContext _localctx = new InnerExpressionContext(Context, _parentState);
		InnerExpressionContext _prevctx = _localctx;
		int _startState = 84;
		EnterRecursionRule(_localctx, 84, RULE_innerExpression, _p);
		int _la;
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 537;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,50,Context) ) {
			case 1:
				{
				State = 504;
				valueLiteral();
				}
				break;
			case 2:
				{
				State = 505;
				Match(ARRAY_LOOP_TYPE);
				}
				break;
			case 3:
				{
				State = 506;
				idExpression();
				State = 519;
				ErrorHandler.Sync(this);
				switch ( Interpreter.AdaptivePredict(TokenStream,48,Context) ) {
				case 1:
					{
					State = 507;
					Match(LRBRACKET);
					State = 516;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8321498944L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 131071L) != 0)) {
						{
						State = 508;
						innerExpression(0);
						State = 513;
						ErrorHandler.Sync(this);
						_la = TokenStream.LA(1);
						while (_la==T__1) {
							{
							{
							State = 509;
							Match(T__1);
							State = 510;
							innerExpression(0);
							}
							}
							State = 515;
							ErrorHandler.Sync(this);
							_la = TokenStream.LA(1);
						}
						}
					}

					State = 518;
					Match(RRBRACKET);
					}
					break;
				}
				State = 525;
				ErrorHandler.Sync(this);
				switch ( Interpreter.AdaptivePredict(TokenStream,49,Context) ) {
				case 1:
					{
					State = 521;
					Match(LBRACKET);
					State = 522;
					innerExpression(0);
					State = 523;
					Match(RBRACKET);
					}
					break;
				}
				}
				break;
			case 4:
				{
				State = 527;
				Match(LRBRACKET);
				State = 528;
				innerExpression(0);
				State = 529;
				Match(RRBRACKET);
				}
				break;
			case 5:
				{
				State = 531;
				Match(T__5);
				State = 532;
				innerExpression(0);
				State = 533;
				Match(T__5);
				}
				break;
			case 6:
				{
				State = 535;
				Match(T__6);
				State = 536;
				innerExpression(1);
				}
				break;
			}
			Context.Stop = TokenStream.LT(-1);
			State = 566;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,54,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( ParseListeners!=null )
						TriggerExitRuleEvent();
					_prevctx = _localctx;
					{
					State = 564;
					ErrorHandler.Sync(this);
					switch ( Interpreter.AdaptivePredict(TokenStream,53,Context) ) {
					case 1:
						{
						_localctx = new InnerExpressionContext(_parentctx, _parentState);
						PushNewRecursionContext(_localctx, _startState, RULE_innerExpression);
						State = 539;
						if (!(Precpred(Context, 7))) throw new FailedPredicateException(this, "Precpred(Context, 7)");
						State = 540;
						Match(T__2);
						State = 541;
						innerExpression(8);
						}
						break;
					case 2:
						{
						_localctx = new InnerExpressionContext(_parentctx, _parentState);
						PushNewRecursionContext(_localctx, _startState, RULE_innerExpression);
						State = 542;
						if (!(Precpred(Context, 5))) throw new FailedPredicateException(this, "Precpred(Context, 5)");
						State = 543;
						binaryOperator();
						State = 544;
						innerExpression(6);
						}
						break;
					case 3:
						{
						_localctx = new InnerExpressionContext(_parentctx, _parentState);
						PushNewRecursionContext(_localctx, _startState, RULE_innerExpression);
						State = 546;
						if (!(Precpred(Context, 4))) throw new FailedPredicateException(this, "Precpred(Context, 4)");
						State = 547;
						Match(T__3);
						State = 548;
						innerExpression(0);
						State = 549;
						Match(T__4);
						State = 550;
						innerExpression(5);
						}
						break;
					case 4:
						{
						_localctx = new InnerExpressionContext(_parentctx, _parentState);
						PushNewRecursionContext(_localctx, _startState, RULE_innerExpression);
						State = 552;
						if (!(Precpred(Context, 6))) throw new FailedPredicateException(this, "Precpred(Context, 6)");
						State = 554;
						ErrorHandler.Sync(this);
						_la = TokenStream.LA(1);
						do {
							{
							{
							State = 553;
							Match(LBRACKET);
							}
							}
							State = 556;
							ErrorHandler.Sync(this);
							_la = TokenStream.LA(1);
						} while ( _la==LBRACKET );
						State = 559;
						ErrorHandler.Sync(this);
						_la = TokenStream.LA(1);
						do {
							{
							{
							State = 558;
							Match(INTEGER_LITERAL);
							}
							}
							State = 561;
							ErrorHandler.Sync(this);
							_la = TokenStream.LA(1);
						} while ( _la==INTEGER_LITERAL );
						State = 563;
						Match(RBRACKET);
						}
						break;
					}
					} 
				}
				State = 568;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,54,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			UnrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public partial class ValueLiteralContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BOOLEAN_LITERAL() { return GetToken(MSpecParser.BOOLEAN_LITERAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode HEX_LITERAL() { return GetToken(MSpecParser.HEX_LITERAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INTEGER_LITERAL() { return GetToken(MSpecParser.INTEGER_LITERAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT_LITERAL() { return GetToken(MSpecParser.FLOAT_LITERAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRING_LITERAL() { return GetToken(MSpecParser.STRING_LITERAL, 0); }
		public ValueLiteralContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_valueLiteral; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterValueLiteral(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitValueLiteral(this);
		}
	}

	[RuleVersion(0)]
	public ValueLiteralContext valueLiteral() {
		ValueLiteralContext _localctx = new ValueLiteralContext(Context, State);
		EnterRule(_localctx, 86, RULE_valueLiteral);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 569;
			_la = TokenStream.LA(1);
			if ( !(((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & 31L) != 0)) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class IdExpressionContext : ParserRuleContext {
		public IToken id;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER_LITERAL() { return GetToken(MSpecParser.IDENTIFIER_LITERAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY_LOOP_TYPE() { return GetToken(MSpecParser.ARRAY_LOOP_TYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONSTANTS() { return GetToken(MSpecParser.CONSTANTS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode GLOBALS() { return GetToken(MSpecParser.GLOBALS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONTEXT() { return GetToken(MSpecParser.CONTEXT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TYPE() { return GetToken(MSpecParser.TYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DISCRIMINATEDTYPE() { return GetToken(MSpecParser.DISCRIMINATEDTYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DATAIO() { return GetToken(MSpecParser.DATAIO, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ENUM() { return GetToken(MSpecParser.ENUM, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BATCHSET() { return GetToken(MSpecParser.BATCHSET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ABSTRACT() { return GetToken(MSpecParser.ABSTRACT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY() { return GetToken(MSpecParser.ARRAY, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASSERT() { return GetToken(MSpecParser.ASSERT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CHECKSUM() { return GetToken(MSpecParser.CHECKSUM, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONST() { return GetToken(MSpecParser.CONST, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DISCRIMINATOR() { return GetToken(MSpecParser.DISCRIMINATOR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IMPLICIT() { return GetToken(MSpecParser.IMPLICIT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MANUALARRAY() { return GetToken(MSpecParser.MANUALARRAY, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MANUAL() { return GetToken(MSpecParser.MANUAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OPTIONAL() { return GetToken(MSpecParser.OPTIONAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PADDING() { return GetToken(MSpecParser.PADDING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PEEK() { return GetToken(MSpecParser.PEEK, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RESERVED() { return GetToken(MSpecParser.RESERVED, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SIMPLE() { return GetToken(MSpecParser.SIMPLE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STATE() { return GetToken(MSpecParser.STATE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TYPESWITCH() { return GetToken(MSpecParser.TYPESWITCH, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UNKNOWN() { return GetToken(MSpecParser.UNKNOWN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VALIDATION() { return GetToken(MSpecParser.VALIDATION, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VIRTUAL() { return GetToken(MSpecParser.VIRTUAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BIT() { return GetToken(MSpecParser.BIT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BYTE() { return GetToken(MSpecParser.BYTE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT() { return GetToken(MSpecParser.INT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VINT() { return GetToken(MSpecParser.VINT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT() { return GetToken(MSpecParser.UINT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VUINT() { return GetToken(MSpecParser.VUINT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT() { return GetToken(MSpecParser.FLOAT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UFLOAT() { return GetToken(MSpecParser.UFLOAT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRING() { return GetToken(MSpecParser.STRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VSTRING() { return GetToken(MSpecParser.VSTRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TIME() { return GetToken(MSpecParser.TIME, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DATE() { return GetToken(MSpecParser.DATE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DATETIME() { return GetToken(MSpecParser.DATETIME, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SHOULD_FAIL() { return GetToken(MSpecParser.SHOULD_FAIL, 0); }
		public IdExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_idExpression; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterIdExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitIdExpression(this);
		}
	}

	[RuleVersion(0)]
	public IdExpressionContext idExpression() {
		IdExpressionContext _localctx = new IdExpressionContext(Context, State);
		EnterRule(_localctx, 88, RULE_idExpression);
		try {
			State = 614;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case IDENTIFIER_LITERAL:
				EnterOuterAlt(_localctx, 1);
				{
				State = 571;
				_localctx.id = Match(IDENTIFIER_LITERAL);
				}
				break;
			case ARRAY_LOOP_TYPE:
				EnterOuterAlt(_localctx, 2);
				{
				State = 572;
				_localctx.id = Match(ARRAY_LOOP_TYPE);
				}
				break;
			case CONSTANTS:
				EnterOuterAlt(_localctx, 3);
				{
				State = 573;
				_localctx.id = Match(CONSTANTS);
				}
				break;
			case GLOBALS:
				EnterOuterAlt(_localctx, 4);
				{
				State = 574;
				_localctx.id = Match(GLOBALS);
				}
				break;
			case CONTEXT:
				EnterOuterAlt(_localctx, 5);
				{
				State = 575;
				_localctx.id = Match(CONTEXT);
				}
				break;
			case TYPE:
				EnterOuterAlt(_localctx, 6);
				{
				State = 576;
				_localctx.id = Match(TYPE);
				}
				break;
			case DISCRIMINATEDTYPE:
				EnterOuterAlt(_localctx, 7);
				{
				State = 577;
				_localctx.id = Match(DISCRIMINATEDTYPE);
				}
				break;
			case DATAIO:
				EnterOuterAlt(_localctx, 8);
				{
				State = 578;
				_localctx.id = Match(DATAIO);
				}
				break;
			case ENUM:
				EnterOuterAlt(_localctx, 9);
				{
				State = 579;
				_localctx.id = Match(ENUM);
				}
				break;
			case BATCHSET:
				EnterOuterAlt(_localctx, 10);
				{
				State = 580;
				_localctx.id = Match(BATCHSET);
				}
				break;
			case ABSTRACT:
				EnterOuterAlt(_localctx, 11);
				{
				State = 581;
				_localctx.id = Match(ABSTRACT);
				}
				break;
			case ARRAY:
				EnterOuterAlt(_localctx, 12);
				{
				State = 582;
				_localctx.id = Match(ARRAY);
				}
				break;
			case ASSERT:
				EnterOuterAlt(_localctx, 13);
				{
				State = 583;
				_localctx.id = Match(ASSERT);
				}
				break;
			case CHECKSUM:
				EnterOuterAlt(_localctx, 14);
				{
				State = 584;
				_localctx.id = Match(CHECKSUM);
				}
				break;
			case CONST:
				EnterOuterAlt(_localctx, 15);
				{
				State = 585;
				_localctx.id = Match(CONST);
				}
				break;
			case DISCRIMINATOR:
				EnterOuterAlt(_localctx, 16);
				{
				State = 586;
				_localctx.id = Match(DISCRIMINATOR);
				}
				break;
			case IMPLICIT:
				EnterOuterAlt(_localctx, 17);
				{
				State = 587;
				_localctx.id = Match(IMPLICIT);
				}
				break;
			case MANUALARRAY:
				EnterOuterAlt(_localctx, 18);
				{
				State = 588;
				_localctx.id = Match(MANUALARRAY);
				}
				break;
			case MANUAL:
				EnterOuterAlt(_localctx, 19);
				{
				State = 589;
				_localctx.id = Match(MANUAL);
				}
				break;
			case OPTIONAL:
				EnterOuterAlt(_localctx, 20);
				{
				State = 590;
				_localctx.id = Match(OPTIONAL);
				}
				break;
			case PADDING:
				EnterOuterAlt(_localctx, 21);
				{
				State = 591;
				_localctx.id = Match(PADDING);
				}
				break;
			case PEEK:
				EnterOuterAlt(_localctx, 22);
				{
				State = 592;
				_localctx.id = Match(PEEK);
				}
				break;
			case RESERVED:
				EnterOuterAlt(_localctx, 23);
				{
				State = 593;
				_localctx.id = Match(RESERVED);
				}
				break;
			case SIMPLE:
				EnterOuterAlt(_localctx, 24);
				{
				State = 594;
				_localctx.id = Match(SIMPLE);
				}
				break;
			case STATE:
				EnterOuterAlt(_localctx, 25);
				{
				State = 595;
				_localctx.id = Match(STATE);
				}
				break;
			case TYPESWITCH:
				EnterOuterAlt(_localctx, 26);
				{
				State = 596;
				_localctx.id = Match(TYPESWITCH);
				}
				break;
			case UNKNOWN:
				EnterOuterAlt(_localctx, 27);
				{
				State = 597;
				_localctx.id = Match(UNKNOWN);
				}
				break;
			case VALIDATION:
				EnterOuterAlt(_localctx, 28);
				{
				State = 598;
				_localctx.id = Match(VALIDATION);
				}
				break;
			case VIRTUAL:
				EnterOuterAlt(_localctx, 29);
				{
				State = 599;
				_localctx.id = Match(VIRTUAL);
				}
				break;
			case BIT:
				EnterOuterAlt(_localctx, 30);
				{
				State = 600;
				_localctx.id = Match(BIT);
				}
				break;
			case BYTE:
				EnterOuterAlt(_localctx, 31);
				{
				State = 601;
				_localctx.id = Match(BYTE);
				}
				break;
			case INT:
				EnterOuterAlt(_localctx, 32);
				{
				State = 602;
				_localctx.id = Match(INT);
				}
				break;
			case VINT:
				EnterOuterAlt(_localctx, 33);
				{
				State = 603;
				_localctx.id = Match(VINT);
				}
				break;
			case UINT:
				EnterOuterAlt(_localctx, 34);
				{
				State = 604;
				_localctx.id = Match(UINT);
				}
				break;
			case VUINT:
				EnterOuterAlt(_localctx, 35);
				{
				State = 605;
				_localctx.id = Match(VUINT);
				}
				break;
			case FLOAT:
				EnterOuterAlt(_localctx, 36);
				{
				State = 606;
				_localctx.id = Match(FLOAT);
				}
				break;
			case UFLOAT:
				EnterOuterAlt(_localctx, 37);
				{
				State = 607;
				_localctx.id = Match(UFLOAT);
				}
				break;
			case STRING:
				EnterOuterAlt(_localctx, 38);
				{
				State = 608;
				_localctx.id = Match(STRING);
				}
				break;
			case VSTRING:
				EnterOuterAlt(_localctx, 39);
				{
				State = 609;
				_localctx.id = Match(VSTRING);
				}
				break;
			case TIME:
				EnterOuterAlt(_localctx, 40);
				{
				State = 610;
				_localctx.id = Match(TIME);
				}
				break;
			case DATE:
				EnterOuterAlt(_localctx, 41);
				{
				State = 611;
				_localctx.id = Match(DATE);
				}
				break;
			case DATETIME:
				EnterOuterAlt(_localctx, 42);
				{
				State = 612;
				_localctx.id = Match(DATETIME);
				}
				break;
			case SHOULD_FAIL:
				EnterOuterAlt(_localctx, 43);
				{
				State = 613;
				_localctx.id = Match(SHOULD_FAIL);
				}
				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 BinaryOperatorContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ASTERISK() { return GetToken(MSpecParser.ASTERISK, 0); }
		public BinaryOperatorContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_binaryOperator; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.EnterBinaryOperator(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IMSpecListener typedListener = listener as IMSpecListener;
			if (typedListener != null) typedListener.ExitBinaryOperator(this);
		}
	}

	[RuleVersion(0)]
	public BinaryOperatorContext binaryOperator() {
		BinaryOperatorContext _localctx = new BinaryOperatorContext(Context, State);
		EnterRule(_localctx, 90, RULE_binaryOperator);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 616;
			_la = TokenStream.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 4328521472L) != 0)) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public override bool Sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 41: return variableLiteral_sempred((VariableLiteralContext)_localctx, predIndex);
		case 42: return innerExpression_sempred((InnerExpressionContext)_localctx, predIndex);
		}
		return true;
	}
	private bool variableLiteral_sempred(VariableLiteralContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0: return Precpred(Context, 1);
		}
		return true;
	}
	private bool innerExpression_sempred(InnerExpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 1: return Precpred(Context, 7);
		case 2: return Precpred(Context, 5);
		case 3: return Precpred(Context, 4);
		case 4: return Precpred(Context, 6);
		}
		return true;
	}

	private static int[] _serializedATN = {
		4,1,85,619,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,1,0,3,0,94,8,0,1,0,3,0,97,8,0,1,0,3,0,100,
		8,0,1,0,5,0,103,8,0,10,0,12,0,106,9,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,
		5,1,116,8,1,10,1,12,1,119,9,1,1,1,1,1,1,2,1,2,1,2,5,2,126,8,2,10,2,12,
		2,129,9,2,1,2,1,2,1,3,1,3,1,3,5,3,136,8,3,10,3,12,3,139,9,3,1,3,1,3,1,
		4,1,4,1,4,1,4,1,5,1,5,1,5,1,5,1,5,1,5,3,5,153,8,5,1,5,1,5,1,5,5,5,158,
		8,5,10,5,12,5,161,9,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,169,8,5,1,5,1,5,1,5,
		5,5,174,8,5,10,5,12,5,177,9,5,1,5,1,5,3,5,181,8,5,1,5,1,5,1,5,1,5,1,5,
		3,5,188,8,5,1,5,1,5,5,5,192,8,5,10,5,12,5,195,9,5,1,5,1,5,1,5,1,5,1,5,
		1,5,3,5,203,8,5,1,5,1,5,1,5,3,5,208,8,5,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,
		7,1,7,4,7,219,8,7,11,7,12,7,220,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,8,3,8,231,
		8,8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,
		9,1,9,1,9,1,9,1,9,1,9,3,9,255,8,9,1,10,1,10,1,10,1,10,1,11,1,11,1,11,1,
		11,1,11,1,11,1,12,1,12,1,12,1,12,1,12,1,13,1,13,1,13,1,13,1,13,1,14,1,
		14,1,14,1,14,1,14,1,15,1,15,1,15,1,15,1,16,1,16,1,16,1,16,1,16,1,17,1,
		17,1,17,1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,19,1,
		19,1,19,1,19,1,19,1,19,1,19,1,20,1,20,1,20,1,20,3,20,316,8,20,1,21,1,21,
		1,21,1,21,1,21,1,21,1,22,1,22,1,22,1,22,3,22,328,8,22,1,23,1,23,1,23,1,
		23,1,24,1,24,1,24,1,24,1,25,1,25,1,25,1,26,1,26,1,26,5,26,344,8,26,10,
		26,12,26,347,9,26,1,27,1,27,1,27,1,28,1,28,1,28,3,28,355,8,28,1,28,1,28,
		1,28,3,28,360,8,28,1,29,1,29,1,29,1,29,1,29,1,30,1,30,3,30,369,8,30,1,
		30,1,30,1,30,1,30,1,30,3,30,376,8,30,1,30,1,30,1,31,1,31,1,31,1,31,1,31,
		3,31,385,8,31,1,31,3,31,388,8,31,1,32,1,32,3,32,392,8,32,1,32,3,32,395,
		8,32,1,32,1,32,1,32,1,32,1,32,3,32,402,8,32,1,32,1,32,5,32,406,8,32,10,
		32,12,32,409,9,32,1,32,1,32,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,
		33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,3,33,429,8,33,1,33,1,33,1,33,3,33,
		434,8,33,1,34,1,34,1,34,1,34,1,35,5,35,441,8,35,10,35,12,35,444,9,35,1,
		36,1,36,1,36,1,37,1,37,1,37,5,37,452,8,37,10,37,12,37,455,9,37,1,38,1,
		38,1,38,1,38,1,38,3,38,462,8,38,1,39,1,39,1,39,5,39,467,8,39,10,39,12,
		39,470,9,39,1,40,1,40,1,40,5,40,475,8,40,10,40,12,40,478,9,40,1,41,1,41,
		1,41,1,41,1,41,3,41,485,8,41,1,41,1,41,4,41,489,8,41,11,41,12,41,490,1,
		41,4,41,494,8,41,11,41,12,41,495,1,41,5,41,499,8,41,10,41,12,41,502,9,
		41,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,5,42,512,8,42,10,42,12,42,515,
		9,42,3,42,517,8,42,1,42,3,42,520,8,42,1,42,1,42,1,42,1,42,3,42,526,8,42,
		1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,3,42,538,8,42,1,42,1,
		42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,4,
		42,555,8,42,11,42,12,42,556,1,42,4,42,560,8,42,11,42,12,42,561,1,42,5,
		42,565,8,42,10,42,12,42,568,9,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,3,44,615,8,44,1,45,1,45,
		1,45,0,2,82,84,46,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,0,2,1,0,75,79,2,0,8,24,32,32,706,0,93,1,0,0,0,2,109,1,0,0,0,4,
		122,1,0,0,0,6,132,1,0,0,0,8,142,1,0,0,0,10,207,1,0,0,0,12,209,1,0,0,0,
		14,214,1,0,0,0,16,224,1,0,0,0,18,254,1,0,0,0,20,256,1,0,0,0,22,260,1,0,
		0,0,24,266,1,0,0,0,26,271,1,0,0,0,28,276,1,0,0,0,30,281,1,0,0,0,32,285,
		1,0,0,0,34,290,1,0,0,0,36,295,1,0,0,0,38,304,1,0,0,0,40,311,1,0,0,0,42,
		317,1,0,0,0,44,323,1,0,0,0,46,329,1,0,0,0,48,333,1,0,0,0,50,337,1,0,0,
		0,52,340,1,0,0,0,54,348,1,0,0,0,56,351,1,0,0,0,58,361,1,0,0,0,60,366,1,
		0,0,0,62,387,1,0,0,0,64,389,1,0,0,0,66,433,1,0,0,0,68,435,1,0,0,0,70,442,
		1,0,0,0,72,445,1,0,0,0,74,448,1,0,0,0,76,461,1,0,0,0,78,463,1,0,0,0,80,
		471,1,0,0,0,82,484,1,0,0,0,84,537,1,0,0,0,86,569,1,0,0,0,88,614,1,0,0,
		0,90,616,1,0,0,0,92,94,3,2,1,0,93,92,1,0,0,0,93,94,1,0,0,0,94,96,1,0,0,
		0,95,97,3,4,2,0,96,95,1,0,0,0,96,97,1,0,0,0,97,99,1,0,0,0,98,100,3,6,3,
		0,99,98,1,0,0,0,99,100,1,0,0,0,100,104,1,0,0,0,101,103,3,8,4,0,102,101,
		1,0,0,0,103,106,1,0,0,0,104,102,1,0,0,0,104,105,1,0,0,0,105,107,1,0,0,
		0,106,104,1,0,0,0,107,108,5,0,0,1,108,1,1,0,0,0,109,110,5,26,0,0,110,117,
		5,33,0,0,111,112,5,26,0,0,112,113,3,28,14,0,113,114,5,27,0,0,114,116,1,
		0,0,0,115,111,1,0,0,0,116,119,1,0,0,0,117,115,1,0,0,0,117,118,1,0,0,0,
		118,120,1,0,0,0,119,117,1,0,0,0,120,121,5,27,0,0,121,3,1,0,0,0,122,123,
		5,26,0,0,123,127,5,34,0,0,124,126,3,12,6,0,125,124,1,0,0,0,126,129,1,0,
		0,0,127,125,1,0,0,0,127,128,1,0,0,0,128,130,1,0,0,0,129,127,1,0,0,0,130,
		131,5,27,0,0,131,5,1,0,0,0,132,133,5,26,0,0,133,137,5,35,0,0,134,136,3,
		12,6,0,135,134,1,0,0,0,136,139,1,0,0,0,137,135,1,0,0,0,137,138,1,0,0,0,
		138,140,1,0,0,0,139,137,1,0,0,0,140,141,5,27,0,0,141,7,1,0,0,0,142,143,
		5,26,0,0,143,144,3,10,5,0,144,145,5,27,0,0,145,9,1,0,0,0,146,147,5,36,
		0,0,147,152,3,88,44,0,148,149,5,28,0,0,149,150,3,74,37,0,150,151,5,29,
		0,0,151,153,1,0,0,0,152,148,1,0,0,0,152,153,1,0,0,0,153,154,1,0,0,0,154,
		159,3,70,35,0,155,158,3,12,6,0,156,158,3,14,7,0,157,155,1,0,0,0,157,156,
		1,0,0,0,158,161,1,0,0,0,159,157,1,0,0,0,159,160,1,0,0,0,160,208,1,0,0,
		0,161,159,1,0,0,0,162,163,5,37,0,0,163,168,3,88,44,0,164,165,5,28,0,0,
		165,166,3,74,37,0,166,167,5,29,0,0,167,169,1,0,0,0,168,164,1,0,0,0,168,
		169,1,0,0,0,169,170,1,0,0,0,170,175,3,70,35,0,171,174,3,12,6,0,172,174,
		3,14,7,0,173,171,1,0,0,0,173,172,1,0,0,0,174,177,1,0,0,0,175,173,1,0,0,
		0,175,176,1,0,0,0,176,208,1,0,0,0,177,175,1,0,0,0,178,180,5,39,0,0,179,
		181,3,66,33,0,180,179,1,0,0,0,180,181,1,0,0,0,181,182,1,0,0,0,182,187,
		3,88,44,0,183,184,5,28,0,0,184,185,3,74,37,0,185,186,5,29,0,0,186,188,
		1,0,0,0,187,183,1,0,0,0,187,188,1,0,0,0,188,189,1,0,0,0,189,193,3,70,35,
		0,190,192,3,60,30,0,191,190,1,0,0,0,192,195,1,0,0,0,193,191,1,0,0,0,193,
		194,1,0,0,0,194,208,1,0,0,0,195,193,1,0,0,0,196,197,5,38,0,0,197,202,3,
		88,44,0,198,199,5,28,0,0,199,200,3,74,37,0,200,201,5,29,0,0,201,203,1,
		0,0,0,202,198,1,0,0,0,202,203,1,0,0,0,203,204,1,0,0,0,204,205,3,70,35,
		0,205,206,3,16,8,0,206,208,1,0,0,0,207,146,1,0,0,0,207,162,1,0,0,0,207,
		178,1,0,0,0,207,196,1,0,0,0,208,11,1,0,0,0,209,210,5,26,0,0,210,211,3,
		18,9,0,211,212,3,70,35,0,212,213,5,27,0,0,213,13,1,0,0,0,214,215,5,26,
		0,0,215,216,5,40,0,0,216,218,3,70,35,0,217,219,3,12,6,0,218,217,1,0,0,
		0,219,220,1,0,0,0,220,218,1,0,0,0,220,221,1,0,0,0,221,222,1,0,0,0,222,
		223,5,27,0,0,223,15,1,0,0,0,224,225,5,26,0,0,225,230,3,52,26,0,226,227,
		5,26,0,0,227,228,3,78,39,0,228,229,5,27,0,0,229,231,1,0,0,0,230,226,1,
		0,0,0,230,231,1,0,0,0,231,232,1,0,0,0,232,233,5,27,0,0,233,17,1,0,0,0,
		234,255,3,20,10,0,235,255,3,22,11,0,236,255,3,24,12,0,237,255,3,26,13,
		0,238,255,3,28,14,0,239,255,3,30,15,0,240,255,3,32,16,0,241,255,3,34,17,
		0,242,255,3,36,18,0,243,255,3,38,19,0,244,255,3,40,20,0,245,255,3,42,21,
		0,246,255,3,44,22,0,247,255,3,46,23,0,248,255,3,48,24,0,249,255,3,50,25,
		0,250,255,3,52,26,0,251,255,3,54,27,0,252,255,3,56,28,0,253,255,3,58,29,
		0,254,234,1,0,0,0,254,235,1,0,0,0,254,236,1,0,0,0,254,237,1,0,0,0,254,
		238,1,0,0,0,254,239,1,0,0,0,254,240,1,0,0,0,254,241,1,0,0,0,254,242,1,
		0,0,0,254,243,1,0,0,0,254,244,1,0,0,0,254,245,1,0,0,0,254,246,1,0,0,0,
		254,247,1,0,0,0,254,248,1,0,0,0,254,249,1,0,0,0,254,250,1,0,0,0,254,251,
		1,0,0,0,254,252,1,0,0,0,254,253,1,0,0,0,255,19,1,0,0,0,256,257,5,41,0,
		0,257,258,3,62,31,0,258,259,3,88,44,0,259,21,1,0,0,0,260,261,5,42,0,0,
		261,262,3,62,31,0,262,263,3,88,44,0,263,264,5,74,0,0,264,265,3,76,38,0,
		265,23,1,0,0,0,266,267,5,43,0,0,267,268,3,62,31,0,268,269,3,88,44,0,269,
		270,3,76,38,0,270,25,1,0,0,0,271,272,5,44,0,0,272,273,3,66,33,0,273,274,
		3,88,44,0,274,275,3,76,38,0,275,27,1,0,0,0,276,277,5,45,0,0,277,278,3,
		62,31,0,278,279,3,88,44,0,279,280,3,86,43,0,280,29,1,0,0,0,281,282,5,46,
		0,0,282,283,3,62,31,0,283,284,3,88,44,0,284,31,1,0,0,0,285,286,5,39,0,
		0,286,287,3,62,31,0,287,288,3,88,44,0,288,289,3,88,44,0,289,33,1,0,0,0,
		290,291,5,47,0,0,291,292,3,66,33,0,292,293,3,88,44,0,293,294,3,76,38,0,
		294,35,1,0,0,0,295,296,5,48,0,0,296,297,3,62,31,0,297,298,3,88,44,0,298,
		299,5,74,0,0,299,300,3,76,38,0,300,301,3,76,38,0,301,302,3,76,38,0,302,
		303,3,76,38,0,303,37,1,0,0,0,304,305,5,49,0,0,305,306,3,62,31,0,306,307,
		3,88,44,0,307,308,3,76,38,0,308,309,3,76,38,0,309,310,3,76,38,0,310,39,
		1,0,0,0,311,312,5,50,0,0,312,313,3,62,31,0,313,315,3,88,44,0,314,316,3,
		76,38,0,315,314,1,0,0,0,315,316,1,0,0,0,316,41,1,0,0,0,317,318,5,51,0,
		0,318,319,3,66,33,0,319,320,3,88,44,0,320,321,3,76,38,0,321,322,3,76,38,
		0,322,43,1,0,0,0,323,324,5,52,0,0,324,325,3,62,31,0,325,327,3,88,44,0,
		326,328,3,76,38,0,327,326,1,0,0,0,327,328,1,0,0,0,328,45,1,0,0,0,329,330,
		5,53,0,0,330,331,3,66,33,0,331,332,3,76,38,0,332,47,1,0,0,0,333,334,5,
		54,0,0,334,335,3,62,31,0,335,336,3,88,44,0,336,49,1,0,0,0,337,338,5,55,
		0,0,338,339,3,88,44,0,339,51,1,0,0,0,340,341,5,56,0,0,341,345,3,80,40,
		0,342,344,3,64,32,0,343,342,1,0,0,0,344,347,1,0,0,0,345,343,1,0,0,0,345,
		346,1,0,0,0,346,53,1,0,0,0,347,345,1,0,0,0,348,349,5,57,0,0,349,350,3,
		66,33,0,350,55,1,0,0,0,351,352,5,58,0,0,352,354,3,76,38,0,353,355,5,79,
		0,0,354,353,1,0,0,0,354,355,1,0,0,0,355,359,1,0,0,0,356,357,5,73,0,0,357,
		358,5,1,0,0,358,360,5,78,0,0,359,356,1,0,0,0,359,360,1,0,0,0,360,57,1,
		0,0,0,361,362,5,59,0,0,362,363,3,62,31,0,363,364,3,88,44,0,364,365,3,76,
		38,0,365,59,1,0,0,0,366,368,5,26,0,0,367,369,3,76,38,0,368,367,1,0,0,0,
		368,369,1,0,0,0,369,370,1,0,0,0,370,375,5,80,0,0,371,372,5,26,0,0,372,
		373,3,78,39,0,373,374,5,27,0,0,374,376,1,0,0,0,375,371,1,0,0,0,375,376,
		1,0,0,0,376,377,1,0,0,0,377,378,5,27,0,0,378,61,1,0,0,0,379,384,5,80,0,
		0,380,381,5,28,0,0,381,382,3,78,39,0,382,383,5,29,0,0,383,385,1,0,0,0,
		384,380,1,0,0,0,384,385,1,0,0,0,385,388,1,0,0,0,386,388,3,66,33,0,387,
		379,1,0,0,0,387,386,1,0,0,0,388,63,1,0,0,0,389,391,5,26,0,0,390,392,3,
		78,39,0,391,390,1,0,0,0,391,392,1,0,0,0,392,394,1,0,0,0,393,395,5,32,0,
		0,394,393,1,0,0,0,394,395,1,0,0,0,395,396,1,0,0,0,396,401,5,80,0,0,397,
		398,5,28,0,0,398,399,3,74,37,0,399,400,5,29,0,0,400,402,1,0,0,0,401,397,
		1,0,0,0,401,402,1,0,0,0,402,407,1,0,0,0,403,406,3,12,6,0,404,406,3,14,
		7,0,405,403,1,0,0,0,405,404,1,0,0,0,406,409,1,0,0,0,407,405,1,0,0,0,407,
		408,1,0,0,0,408,410,1,0,0,0,409,407,1,0,0,0,410,411,5,27,0,0,411,65,1,
		0,0,0,412,434,5,60,0,0,413,434,5,61,0,0,414,415,5,62,0,0,415,434,5,75,
		0,0,416,434,5,63,0,0,417,418,5,64,0,0,418,434,5,75,0,0,419,434,5,65,0,
		0,420,421,5,66,0,0,421,434,5,75,0,0,422,423,5,67,0,0,423,434,5,75,0,0,
		424,425,5,68,0,0,425,434,5,75,0,0,426,428,5,69,0,0,427,429,3,76,38,0,428,
		427,1,0,0,0,428,429,1,0,0,0,429,434,1,0,0,0,430,434,5,70,0,0,431,434,5,
		71,0,0,432,434,5,72,0,0,433,412,1,0,0,0,433,413,1,0,0,0,433,414,1,0,0,
		0,433,416,1,0,0,0,433,417,1,0,0,0,433,419,1,0,0,0,433,420,1,0,0,0,433,
		422,1,0,0,0,433,424,1,0,0,0,433,426,1,0,0,0,433,430,1,0,0,0,433,431,1,
		0,0,0,433,432,1,0,0,0,434,67,1,0,0,0,435,436,5,80,0,0,436,437,5,1,0,0,
		437,438,3,76,38,0,438,69,1,0,0,0,439,441,3,68,34,0,440,439,1,0,0,0,441,
		444,1,0,0,0,442,440,1,0,0,0,442,443,1,0,0,0,443,71,1,0,0,0,444,442,1,0,
		0,0,445,446,3,62,31,0,446,447,3,88,44,0,447,73,1,0,0,0,448,453,3,72,36,
		0,449,450,5,2,0,0,450,452,3,72,36,0,451,449,1,0,0,0,452,455,1,0,0,0,453,
		451,1,0,0,0,453,454,1,0,0,0,454,75,1,0,0,0,455,453,1,0,0,0,456,457,5,25,
		0,0,457,458,3,84,42,0,458,459,5,25,0,0,459,462,1,0,0,0,460,462,5,32,0,
		0,461,456,1,0,0,0,461,460,1,0,0,0,462,77,1,0,0,0,463,468,3,76,38,0,464,
		465,5,2,0,0,465,467,3,76,38,0,466,464,1,0,0,0,467,470,1,0,0,0,468,466,
		1,0,0,0,468,469,1,0,0,0,469,79,1,0,0,0,470,468,1,0,0,0,471,476,3,82,41,
		0,472,473,5,2,0,0,473,475,3,82,41,0,474,472,1,0,0,0,475,478,1,0,0,0,476,
		474,1,0,0,0,476,477,1,0,0,0,477,81,1,0,0,0,478,476,1,0,0,0,479,480,6,41,
		-1,0,480,485,5,80,0,0,481,482,5,80,0,0,482,483,5,3,0,0,483,485,3,82,41,
		2,484,479,1,0,0,0,484,481,1,0,0,0,485,500,1,0,0,0,486,488,10,1,0,0,487,
		489,5,26,0,0,488,487,1,0,0,0,489,490,1,0,0,0,490,488,1,0,0,0,490,491,1,
		0,0,0,491,493,1,0,0,0,492,494,5,75,0,0,493,492,1,0,0,0,494,495,1,0,0,0,
		495,493,1,0,0,0,495,496,1,0,0,0,496,497,1,0,0,0,497,499,5,27,0,0,498,486,
		1,0,0,0,499,502,1,0,0,0,500,498,1,0,0,0,500,501,1,0,0,0,501,83,1,0,0,0,
		502,500,1,0,0,0,503,504,6,42,-1,0,504,538,3,86,43,0,505,538,5,74,0,0,506,
		519,3,88,44,0,507,516,5,28,0,0,508,513,3,84,42,0,509,510,5,2,0,0,510,512,
		3,84,42,0,511,509,1,0,0,0,512,515,1,0,0,0,513,511,1,0,0,0,513,514,1,0,
		0,0,514,517,1,0,0,0,515,513,1,0,0,0,516,508,1,0,0,0,516,517,1,0,0,0,517,
		518,1,0,0,0,518,520,5,29,0,0,519,507,1,0,0,0,519,520,1,0,0,0,520,525,1,
		0,0,0,521,522,5,26,0,0,522,523,3,84,42,0,523,524,5,27,0,0,524,526,1,0,
		0,0,525,521,1,0,0,0,525,526,1,0,0,0,526,538,1,0,0,0,527,528,5,28,0,0,528,
		529,3,84,42,0,529,530,5,29,0,0,530,538,1,0,0,0,531,532,5,6,0,0,532,533,
		3,84,42,0,533,534,5,6,0,0,534,538,1,0,0,0,535,536,5,7,0,0,536,538,3,84,
		42,1,537,503,1,0,0,0,537,505,1,0,0,0,537,506,1,0,0,0,537,527,1,0,0,0,537,
		531,1,0,0,0,537,535,1,0,0,0,538,566,1,0,0,0,539,540,10,7,0,0,540,541,5,
		3,0,0,541,565,3,84,42,8,542,543,10,5,0,0,543,544,3,90,45,0,544,545,3,84,
		42,6,545,565,1,0,0,0,546,547,10,4,0,0,547,548,5,4,0,0,548,549,3,84,42,
		0,549,550,5,5,0,0,550,551,3,84,42,5,551,565,1,0,0,0,552,554,10,6,0,0,553,
		555,5,26,0,0,554,553,1,0,0,0,555,556,1,0,0,0,556,554,1,0,0,0,556,557,1,
		0,0,0,557,559,1,0,0,0,558,560,5,75,0,0,559,558,1,0,0,0,560,561,1,0,0,0,
		561,559,1,0,0,0,561,562,1,0,0,0,562,563,1,0,0,0,563,565,5,27,0,0,564,539,
		1,0,0,0,564,542,1,0,0,0,564,546,1,0,0,0,564,552,1,0,0,0,565,568,1,0,0,
		0,566,564,1,0,0,0,566,567,1,0,0,0,567,85,1,0,0,0,568,566,1,0,0,0,569,570,
		7,0,0,0,570,87,1,0,0,0,571,615,5,80,0,0,572,615,5,74,0,0,573,615,5,33,
		0,0,574,615,5,34,0,0,575,615,5,35,0,0,576,615,5,36,0,0,577,615,5,37,0,
		0,578,615,5,38,0,0,579,615,5,39,0,0,580,615,5,40,0,0,581,615,5,41,0,0,
		582,615,5,42,0,0,583,615,5,43,0,0,584,615,5,44,0,0,585,615,5,45,0,0,586,
		615,5,46,0,0,587,615,5,47,0,0,588,615,5,48,0,0,589,615,5,49,0,0,590,615,
		5,50,0,0,591,615,5,51,0,0,592,615,5,52,0,0,593,615,5,53,0,0,594,615,5,
		54,0,0,595,615,5,55,0,0,596,615,5,56,0,0,597,615,5,57,0,0,598,615,5,58,
		0,0,599,615,5,59,0,0,600,615,5,60,0,0,601,615,5,61,0,0,602,615,5,62,0,
		0,603,615,5,63,0,0,604,615,5,64,0,0,605,615,5,65,0,0,606,615,5,66,0,0,
		607,615,5,67,0,0,608,615,5,68,0,0,609,615,5,69,0,0,610,615,5,70,0,0,611,
		615,5,71,0,0,612,615,5,72,0,0,613,615,5,73,0,0,614,571,1,0,0,0,614,572,
		1,0,0,0,614,573,1,0,0,0,614,574,1,0,0,0,614,575,1,0,0,0,614,576,1,0,0,
		0,614,577,1,0,0,0,614,578,1,0,0,0,614,579,1,0,0,0,614,580,1,0,0,0,614,
		581,1,0,0,0,614,582,1,0,0,0,614,583,1,0,0,0,614,584,1,0,0,0,614,585,1,
		0,0,0,614,586,1,0,0,0,614,587,1,0,0,0,614,588,1,0,0,0,614,589,1,0,0,0,
		614,590,1,0,0,0,614,591,1,0,0,0,614,592,1,0,0,0,614,593,1,0,0,0,614,594,
		1,0,0,0,614,595,1,0,0,0,614,596,1,0,0,0,614,597,1,0,0,0,614,598,1,0,0,
		0,614,599,1,0,0,0,614,600,1,0,0,0,614,601,1,0,0,0,614,602,1,0,0,0,614,
		603,1,0,0,0,614,604,1,0,0,0,614,605,1,0,0,0,614,606,1,0,0,0,614,607,1,
		0,0,0,614,608,1,0,0,0,614,609,1,0,0,0,614,610,1,0,0,0,614,611,1,0,0,0,
		614,612,1,0,0,0,614,613,1,0,0,0,615,89,1,0,0,0,616,617,7,1,0,0,617,91,
		1,0,0,0,56,93,96,99,104,117,127,137,152,157,159,168,173,175,180,187,193,
		202,207,220,230,254,315,327,345,354,359,368,375,384,387,391,394,401,405,
		407,428,433,442,453,461,468,476,484,490,495,500,513,516,519,525,537,556,
		561,564,566,614
	};

	public static readonly ATN _ATN =
		new ATNDeserializer().Deserialize(_serializedATN);


}
} // namespace org.apache.plc4net.tools.codegen.grammar