• Home
• sk.uniq.protobuf
• protobuf-parser
• 0.2.0
• source code
• ProtoParser.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

sk.uniq.protobuf.grammar.ProtoParser Maven / Gradle / Ivy

// Generated from sk/uniq/protobuf/grammar/Proto.g4 by ANTLR 4.5.3
package sk.uniq.protobuf.grammar;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class ProtoParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.5.3", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		SYNTAX_LITERAL=1, PACKAGE_LITERAL=2, IMPORT_LITERAL=3, OPTION_LITERAL=4, 
		ENUM_LITERAL=5, MESSAGE_LITERAL=6, ONEOF_LITERAL=7, MAP_LITERAL=8, EXTENSIONS_TO_LITERAL=9, 
		EXTENSIONS_MAX_LITERAL=10, REPEATED_LITERAL=11, RESERVED_LITERAL=12, SERVICE_LITERAL=13, 
		RETURNS_LITERAL=14, RPC_LITERAL=15, STREAM_LITERAL=16, PUBLIC_LITERAL=17, 
		WEAK_LITERAL=18, BLOCK_OPEN=19, BLOCK_CLOSE=20, PAREN_OPEN=21, PAREN_CLOSE=22, 
		BRACKET_OPEN=23, BRACKET_CLOSE=24, MAP_OPEN=25, MAP_CLOSE=26, ASSIGN=27, 
		COLON=28, COMMA=29, DOT=30, PLUS=31, MINUS=32, QUOTE=33, ITEM_TERMINATOR=34, 
		DOUBLE_TYPE_LITERAL=35, FLOAT_TYPE_LITERAL=36, INT32_TYPE_LITERAL=37, 
		INT64_TYPE_LITERAL=38, UINT32_TYPE_LITERAL=39, UINT64_TYPE_LITERAL=40, 
		SINT32_TYPE_LITERAL=41, SINT64_TYPE_LITERAL=42, FIXED32_TYPE_LITERAL=43, 
		FIXED64_TYPE_LITERAL=44, SFIXED32_TYPE_LITERAL=45, SFIXED64_TYPE_LITERAL=46, 
		BOOLEAN_TYPE_LITERAL=47, STRING_TYPE_LITERAL=48, BYTES_TYPE_LITERAL=49, 
		STRING_LITERAL=50, BOOLEAN_LITERAL=51, FLOAT_LITERAL=52, INTEGER_LITERAL=53, 
		IDENTIFIER=54, LINE_COMMENT=55, WHITESPACE=56, NEWLINE=57, ERR_CHAR=58;
	public static final int
		RULE_proto = 0, RULE_topLevelDef = 1, RULE_service = 2, RULE_rpc = 3, 
		RULE_message = 4, RULE_messageBody = 5, RULE_enumPB = 6, RULE_enumBody = 7, 
		RULE_enumField = 8, RULE_enumValueOption = 9, RULE_reserved = 10, RULE_fieldNames = 11, 
		RULE_reservedFieldName = 12, RULE_ranges = 13, RULE_range = 14, RULE_mapField = 15, 
		RULE_oneof = 16, RULE_oneofField = 17, RULE_field = 18, RULE_fieldOptions = 19, 
		RULE_fieldOption = 20, RULE_type = 21, RULE_fieldNumber = 22, RULE_option = 23, 
		RULE_optionName = 24, RULE_packagePB = 25, RULE_importPB = 26, RULE_syntax = 27, 
		RULE_constant = 28, RULE_mapKeyType = 29, RULE_protoType = 30, RULE_fullIdentifier = 31, 
		RULE_messageName = 32, RULE_enumName = 33, RULE_fieldName = 34, RULE_oneofName = 35, 
		RULE_mapName = 36, RULE_serviceName = 37, RULE_rpcName = 38, RULE_messageOrEnumType = 39, 
		RULE_messageType = 40, RULE_enumType = 41, RULE_emptyStatement = 42;
	public static final String[] ruleNames = {
		"proto", "topLevelDef", "service", "rpc", "message", "messageBody", "enumPB", 
		"enumBody", "enumField", "enumValueOption", "reserved", "fieldNames", 
		"reservedFieldName", "ranges", "range", "mapField", "oneof", "oneofField", 
		"field", "fieldOptions", "fieldOption", "type", "fieldNumber", "option", 
		"optionName", "packagePB", "importPB", "syntax", "constant", "mapKeyType", 
		"protoType", "fullIdentifier", "messageName", "enumName", "fieldName", 
		"oneofName", "mapName", "serviceName", "rpcName", "messageOrEnumType", 
		"messageType", "enumType", "emptyStatement"
	};

	private static final String[] _LITERAL_NAMES = {
		null, "'syntax'", "'package'", "'import'", "'option'", "'enum'", "'message'", 
		"'oneof'", "'map'", "'to'", "'max'", "'repeated'", "'reserved'", "'service'", 
		"'returns'", "'rpc'", "'stream'", "'public'", "'weak'", "'{'", "'}'", 
		"'('", "')'", "'['", "']'", "'<'", "'>'", "'='", "':'", "','", "'.'", 
		"'+'", "'-'", "'\"'", "';'", "'double'", "'float'", "'int32'", "'int64'", 
		"'uint32'", "'uint64'", "'sint32'", "'sint64'", "'fixed32'", "'fixed64'", 
		"'sfixed32'", "'sfixed64'", "'bool'", "'string'", "'bytes'"
	};
	private static final String[] _SYMBOLIC_NAMES = {
		null, "SYNTAX_LITERAL", "PACKAGE_LITERAL", "IMPORT_LITERAL", "OPTION_LITERAL", 
		"ENUM_LITERAL", "MESSAGE_LITERAL", "ONEOF_LITERAL", "MAP_LITERAL", "EXTENSIONS_TO_LITERAL", 
		"EXTENSIONS_MAX_LITERAL", "REPEATED_LITERAL", "RESERVED_LITERAL", "SERVICE_LITERAL", 
		"RETURNS_LITERAL", "RPC_LITERAL", "STREAM_LITERAL", "PUBLIC_LITERAL", 
		"WEAK_LITERAL", "BLOCK_OPEN", "BLOCK_CLOSE", "PAREN_OPEN", "PAREN_CLOSE", 
		"BRACKET_OPEN", "BRACKET_CLOSE", "MAP_OPEN", "MAP_CLOSE", "ASSIGN", "COLON", 
		"COMMA", "DOT", "PLUS", "MINUS", "QUOTE", "ITEM_TERMINATOR", "DOUBLE_TYPE_LITERAL", 
		"FLOAT_TYPE_LITERAL", "INT32_TYPE_LITERAL", "INT64_TYPE_LITERAL", "UINT32_TYPE_LITERAL", 
		"UINT64_TYPE_LITERAL", "SINT32_TYPE_LITERAL", "SINT64_TYPE_LITERAL", "FIXED32_TYPE_LITERAL", 
		"FIXED64_TYPE_LITERAL", "SFIXED32_TYPE_LITERAL", "SFIXED64_TYPE_LITERAL", 
		"BOOLEAN_TYPE_LITERAL", "STRING_TYPE_LITERAL", "BYTES_TYPE_LITERAL", "STRING_LITERAL", 
		"BOOLEAN_LITERAL", "FLOAT_LITERAL", "INTEGER_LITERAL", "IDENTIFIER", "LINE_COMMENT", 
		"WHITESPACE", "NEWLINE", "ERR_CHAR"
	};
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "Proto.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public ProtoParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class ProtoContext extends ParserRuleContext {
		public SyntaxContext syntax() {
			return getRuleContext(SyntaxContext.class,0);
		}
		public TerminalNode EOF() { return getToken(ProtoParser.EOF, 0); }
		public List importPB() {
			return getRuleContexts(ImportPBContext.class);
		}
		public ImportPBContext importPB(int i) {
			return getRuleContext(ImportPBContext.class,i);
		}
		public List packagePB() {
			return getRuleContexts(PackagePBContext.class);
		}
		public PackagePBContext packagePB(int i) {
			return getRuleContext(PackagePBContext.class,i);
		}
		public List option() {
			return getRuleContexts(OptionContext.class);
		}
		public OptionContext option(int i) {
			return getRuleContext(OptionContext.class,i);
		}
		public List topLevelDef() {
			return getRuleContexts(TopLevelDefContext.class);
		}
		public TopLevelDefContext topLevelDef(int i) {
			return getRuleContext(TopLevelDefContext.class,i);
		}
		public List emptyStatement() {
			return getRuleContexts(EmptyStatementContext.class);
		}
		public EmptyStatementContext emptyStatement(int i) {
			return getRuleContext(EmptyStatementContext.class,i);
		}
		public ProtoContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_proto; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterProto(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitProto(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitProto(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ProtoContext proto() throws RecognitionException {
		ProtoContext _localctx = new ProtoContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_proto);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(86);
			syntax();
			setState(94);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE_LITERAL) | (1L << IMPORT_LITERAL) | (1L << OPTION_LITERAL) | (1L << ENUM_LITERAL) | (1L << MESSAGE_LITERAL) | (1L << SERVICE_LITERAL) | (1L << ITEM_TERMINATOR))) != 0)) {
				{
				setState(92);
				switch (_input.LA(1)) {
				case IMPORT_LITERAL:
					{
					setState(87);
					importPB();
					}
					break;
				case PACKAGE_LITERAL:
					{
					setState(88);
					packagePB();
					}
					break;
				case OPTION_LITERAL:
					{
					setState(89);
					option();
					}
					break;
				case ENUM_LITERAL:
				case MESSAGE_LITERAL:
				case SERVICE_LITERAL:
					{
					setState(90);
					topLevelDef();
					}
					break;
				case ITEM_TERMINATOR:
					{
					setState(91);
					emptyStatement();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				setState(96);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(97);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TopLevelDefContext extends ParserRuleContext {
		public MessageContext message() {
			return getRuleContext(MessageContext.class,0);
		}
		public EnumPBContext enumPB() {
			return getRuleContext(EnumPBContext.class,0);
		}
		public ServiceContext service() {
			return getRuleContext(ServiceContext.class,0);
		}
		public TopLevelDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_topLevelDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterTopLevelDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitTopLevelDef(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitTopLevelDef(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TopLevelDefContext topLevelDef() throws RecognitionException {
		TopLevelDefContext _localctx = new TopLevelDefContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_topLevelDef);
		try {
			setState(102);
			switch (_input.LA(1)) {
			case MESSAGE_LITERAL:
				enterOuterAlt(_localctx, 1);
				{
				setState(99);
				message();
				}
				break;
			case ENUM_LITERAL:
				enterOuterAlt(_localctx, 2);
				{
				setState(100);
				enumPB();
				}
				break;
			case SERVICE_LITERAL:
				enterOuterAlt(_localctx, 3);
				{
				setState(101);
				service();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ServiceContext extends ParserRuleContext {
		public TerminalNode SERVICE_LITERAL() { return getToken(ProtoParser.SERVICE_LITERAL, 0); }
		public ServiceNameContext serviceName() {
			return getRuleContext(ServiceNameContext.class,0);
		}
		public TerminalNode BLOCK_OPEN() { return getToken(ProtoParser.BLOCK_OPEN, 0); }
		public TerminalNode BLOCK_CLOSE() { return getToken(ProtoParser.BLOCK_CLOSE, 0); }
		public List option() {
			return getRuleContexts(OptionContext.class);
		}
		public OptionContext option(int i) {
			return getRuleContext(OptionContext.class,i);
		}
		public List rpc() {
			return getRuleContexts(RpcContext.class);
		}
		public RpcContext rpc(int i) {
			return getRuleContext(RpcContext.class,i);
		}
		public List emptyStatement() {
			return getRuleContexts(EmptyStatementContext.class);
		}
		public EmptyStatementContext emptyStatement(int i) {
			return getRuleContext(EmptyStatementContext.class,i);
		}
		public ServiceContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_service; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterService(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitService(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitService(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ServiceContext service() throws RecognitionException {
		ServiceContext _localctx = new ServiceContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_service);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(104);
			match(SERVICE_LITERAL);
			setState(105);
			serviceName();
			setState(106);
			match(BLOCK_OPEN);
			setState(112);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPTION_LITERAL) | (1L << RPC_LITERAL) | (1L << ITEM_TERMINATOR))) != 0)) {
				{
				setState(110);
				switch (_input.LA(1)) {
				case OPTION_LITERAL:
					{
					setState(107);
					option();
					}
					break;
				case RPC_LITERAL:
					{
					setState(108);
					rpc();
					}
					break;
				case ITEM_TERMINATOR:
					{
					setState(109);
					emptyStatement();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				setState(114);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(115);
			match(BLOCK_CLOSE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RpcContext extends ParserRuleContext {
		public Token argStream;
		public MessageTypeContext argType;
		public Token retStream;
		public MessageTypeContext retType;
		public TerminalNode RPC_LITERAL() { return getToken(ProtoParser.RPC_LITERAL, 0); }
		public RpcNameContext rpcName() {
			return getRuleContext(RpcNameContext.class,0);
		}
		public List PAREN_OPEN() { return getTokens(ProtoParser.PAREN_OPEN); }
		public TerminalNode PAREN_OPEN(int i) {
			return getToken(ProtoParser.PAREN_OPEN, i);
		}
		public List PAREN_CLOSE() { return getTokens(ProtoParser.PAREN_CLOSE); }
		public TerminalNode PAREN_CLOSE(int i) {
			return getToken(ProtoParser.PAREN_CLOSE, i);
		}
		public TerminalNode RETURNS_LITERAL() { return getToken(ProtoParser.RETURNS_LITERAL, 0); }
		public List messageType() {
			return getRuleContexts(MessageTypeContext.class);
		}
		public MessageTypeContext messageType(int i) {
			return getRuleContext(MessageTypeContext.class,i);
		}
		public TerminalNode ITEM_TERMINATOR() { return getToken(ProtoParser.ITEM_TERMINATOR, 0); }
		public List STREAM_LITERAL() { return getTokens(ProtoParser.STREAM_LITERAL); }
		public TerminalNode STREAM_LITERAL(int i) {
			return getToken(ProtoParser.STREAM_LITERAL, i);
		}
		public TerminalNode BLOCK_OPEN() { return getToken(ProtoParser.BLOCK_OPEN, 0); }
		public TerminalNode BLOCK_CLOSE() { return getToken(ProtoParser.BLOCK_CLOSE, 0); }
		public List option() {
			return getRuleContexts(OptionContext.class);
		}
		public OptionContext option(int i) {
			return getRuleContext(OptionContext.class,i);
		}
		public List emptyStatement() {
			return getRuleContexts(EmptyStatementContext.class);
		}
		public EmptyStatementContext emptyStatement(int i) {
			return getRuleContext(EmptyStatementContext.class,i);
		}
		public RpcContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rpc; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterRpc(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitRpc(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitRpc(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RpcContext rpc() throws RecognitionException {
		RpcContext _localctx = new RpcContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_rpc);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(117);
			match(RPC_LITERAL);
			setState(118);
			rpcName();
			setState(119);
			match(PAREN_OPEN);
			setState(121);
			_la = _input.LA(1);
			if (_la==STREAM_LITERAL) {
				{
				setState(120);
				((RpcContext)_localctx).argStream = match(STREAM_LITERAL);
				}
			}

			setState(123);
			((RpcContext)_localctx).argType = messageType();
			setState(124);
			match(PAREN_CLOSE);
			setState(125);
			match(RETURNS_LITERAL);
			setState(126);
			match(PAREN_OPEN);
			setState(128);
			_la = _input.LA(1);
			if (_la==STREAM_LITERAL) {
				{
				setState(127);
				((RpcContext)_localctx).retStream = match(STREAM_LITERAL);
				}
			}

			setState(130);
			((RpcContext)_localctx).retType = messageType();
			setState(131);
			match(PAREN_CLOSE);
			setState(142);
			switch (_input.LA(1)) {
			case BLOCK_OPEN:
				{
				{
				setState(132);
				match(BLOCK_OPEN);
				setState(137);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==OPTION_LITERAL || _la==ITEM_TERMINATOR) {
					{
					setState(135);
					switch (_input.LA(1)) {
					case OPTION_LITERAL:
						{
						setState(133);
						option();
						}
						break;
					case ITEM_TERMINATOR:
						{
						setState(134);
						emptyStatement();
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					}
					setState(139);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(140);
				match(BLOCK_CLOSE);
				}
				}
				break;
			case ITEM_TERMINATOR:
				{
				setState(141);
				match(ITEM_TERMINATOR);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MessageContext extends ParserRuleContext {
		public TerminalNode MESSAGE_LITERAL() { return getToken(ProtoParser.MESSAGE_LITERAL, 0); }
		public MessageNameContext messageName() {
			return getRuleContext(MessageNameContext.class,0);
		}
		public MessageBodyContext messageBody() {
			return getRuleContext(MessageBodyContext.class,0);
		}
		public MessageContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_message; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterMessage(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitMessage(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitMessage(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MessageContext message() throws RecognitionException {
		MessageContext _localctx = new MessageContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_message);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(144);
			match(MESSAGE_LITERAL);
			setState(145);
			messageName();
			setState(146);
			messageBody();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MessageBodyContext extends ParserRuleContext {
		public TerminalNode BLOCK_OPEN() { return getToken(ProtoParser.BLOCK_OPEN, 0); }
		public TerminalNode BLOCK_CLOSE() { return getToken(ProtoParser.BLOCK_CLOSE, 0); }
		public List field() {
			return getRuleContexts(FieldContext.class);
		}
		public FieldContext field(int i) {
			return getRuleContext(FieldContext.class,i);
		}
		public List enumPB() {
			return getRuleContexts(EnumPBContext.class);
		}
		public EnumPBContext enumPB(int i) {
			return getRuleContext(EnumPBContext.class,i);
		}
		public List message() {
			return getRuleContexts(MessageContext.class);
		}
		public MessageContext message(int i) {
			return getRuleContext(MessageContext.class,i);
		}
		public List option() {
			return getRuleContexts(OptionContext.class);
		}
		public OptionContext option(int i) {
			return getRuleContext(OptionContext.class,i);
		}
		public List oneof() {
			return getRuleContexts(OneofContext.class);
		}
		public OneofContext oneof(int i) {
			return getRuleContext(OneofContext.class,i);
		}
		public List mapField() {
			return getRuleContexts(MapFieldContext.class);
		}
		public MapFieldContext mapField(int i) {
			return getRuleContext(MapFieldContext.class,i);
		}
		public List reserved() {
			return getRuleContexts(ReservedContext.class);
		}
		public ReservedContext reserved(int i) {
			return getRuleContext(ReservedContext.class,i);
		}
		public List emptyStatement() {
			return getRuleContexts(EmptyStatementContext.class);
		}
		public EmptyStatementContext emptyStatement(int i) {
			return getRuleContext(EmptyStatementContext.class,i);
		}
		public MessageBodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_messageBody; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterMessageBody(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitMessageBody(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitMessageBody(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MessageBodyContext messageBody() throws RecognitionException {
		MessageBodyContext _localctx = new MessageBodyContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_messageBody);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(148);
			match(BLOCK_OPEN);
			setState(159);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPTION_LITERAL) | (1L << ENUM_LITERAL) | (1L << MESSAGE_LITERAL) | (1L << ONEOF_LITERAL) | (1L << MAP_LITERAL) | (1L << REPEATED_LITERAL) | (1L << RESERVED_LITERAL) | (1L << DOT) | (1L << ITEM_TERMINATOR) | (1L << DOUBLE_TYPE_LITERAL) | (1L << FLOAT_TYPE_LITERAL) | (1L << INT32_TYPE_LITERAL) | (1L << INT64_TYPE_LITERAL) | (1L << UINT32_TYPE_LITERAL) | (1L << UINT64_TYPE_LITERAL) | (1L << SINT32_TYPE_LITERAL) | (1L << SINT64_TYPE_LITERAL) | (1L << FIXED32_TYPE_LITERAL) | (1L << FIXED64_TYPE_LITERAL) | (1L << SFIXED32_TYPE_LITERAL) | (1L << SFIXED64_TYPE_LITERAL) | (1L << BOOLEAN_TYPE_LITERAL) | (1L << STRING_TYPE_LITERAL) | (1L << BYTES_TYPE_LITERAL) | (1L << IDENTIFIER))) != 0)) {
				{
				setState(157);
				switch (_input.LA(1)) {
				case REPEATED_LITERAL:
				case DOT:
				case DOUBLE_TYPE_LITERAL:
				case FLOAT_TYPE_LITERAL:
				case INT32_TYPE_LITERAL:
				case INT64_TYPE_LITERAL:
				case UINT32_TYPE_LITERAL:
				case UINT64_TYPE_LITERAL:
				case SINT32_TYPE_LITERAL:
				case SINT64_TYPE_LITERAL:
				case FIXED32_TYPE_LITERAL:
				case FIXED64_TYPE_LITERAL:
				case SFIXED32_TYPE_LITERAL:
				case SFIXED64_TYPE_LITERAL:
				case BOOLEAN_TYPE_LITERAL:
				case STRING_TYPE_LITERAL:
				case BYTES_TYPE_LITERAL:
				case IDENTIFIER:
					{
					setState(149);
					field();
					}
					break;
				case ENUM_LITERAL:
					{
					setState(150);
					enumPB();
					}
					break;
				case MESSAGE_LITERAL:
					{
					setState(151);
					message();
					}
					break;
				case OPTION_LITERAL:
					{
					setState(152);
					option();
					}
					break;
				case ONEOF_LITERAL:
					{
					setState(153);
					oneof();
					}
					break;
				case MAP_LITERAL:
					{
					setState(154);
					mapField();
					}
					break;
				case RESERVED_LITERAL:
					{
					setState(155);
					reserved();
					}
					break;
				case ITEM_TERMINATOR:
					{
					setState(156);
					emptyStatement();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				setState(161);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(162);
			match(BLOCK_CLOSE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EnumPBContext extends ParserRuleContext {
		public TerminalNode ENUM_LITERAL() { return getToken(ProtoParser.ENUM_LITERAL, 0); }
		public EnumNameContext enumName() {
			return getRuleContext(EnumNameContext.class,0);
		}
		public EnumBodyContext enumBody() {
			return getRuleContext(EnumBodyContext.class,0);
		}
		public EnumPBContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumPB; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterEnumPB(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitEnumPB(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitEnumPB(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EnumPBContext enumPB() throws RecognitionException {
		EnumPBContext _localctx = new EnumPBContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_enumPB);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(164);
			match(ENUM_LITERAL);
			setState(165);
			enumName();
			setState(166);
			enumBody();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EnumBodyContext extends ParserRuleContext {
		public TerminalNode BLOCK_OPEN() { return getToken(ProtoParser.BLOCK_OPEN, 0); }
		public TerminalNode BLOCK_CLOSE() { return getToken(ProtoParser.BLOCK_CLOSE, 0); }
		public List option() {
			return getRuleContexts(OptionContext.class);
		}
		public OptionContext option(int i) {
			return getRuleContext(OptionContext.class,i);
		}
		public List enumField() {
			return getRuleContexts(EnumFieldContext.class);
		}
		public EnumFieldContext enumField(int i) {
			return getRuleContext(EnumFieldContext.class,i);
		}
		public List emptyStatement() {
			return getRuleContexts(EmptyStatementContext.class);
		}
		public EmptyStatementContext emptyStatement(int i) {
			return getRuleContext(EmptyStatementContext.class,i);
		}
		public EnumBodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumBody; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterEnumBody(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitEnumBody(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitEnumBody(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EnumBodyContext enumBody() throws RecognitionException {
		EnumBodyContext _localctx = new EnumBodyContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_enumBody);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(168);
			match(BLOCK_OPEN);
			setState(174);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPTION_LITERAL) | (1L << ITEM_TERMINATOR) | (1L << IDENTIFIER))) != 0)) {
				{
				setState(172);
				switch (_input.LA(1)) {
				case OPTION_LITERAL:
					{
					setState(169);
					option();
					}
					break;
				case IDENTIFIER:
					{
					setState(170);
					enumField();
					}
					break;
				case ITEM_TERMINATOR:
					{
					setState(171);
					emptyStatement();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				setState(176);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(177);
			match(BLOCK_CLOSE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EnumFieldContext extends ParserRuleContext {
		public Token name;
		public Token value;
		public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
		public TerminalNode ITEM_TERMINATOR() { return getToken(ProtoParser.ITEM_TERMINATOR, 0); }
		public TerminalNode IDENTIFIER() { return getToken(ProtoParser.IDENTIFIER, 0); }
		public TerminalNode INTEGER_LITERAL() { return getToken(ProtoParser.INTEGER_LITERAL, 0); }
		public TerminalNode BRACKET_OPEN() { return getToken(ProtoParser.BRACKET_OPEN, 0); }
		public List enumValueOption() {
			return getRuleContexts(EnumValueOptionContext.class);
		}
		public EnumValueOptionContext enumValueOption(int i) {
			return getRuleContext(EnumValueOptionContext.class,i);
		}
		public TerminalNode BRACKET_CLOSE() { return getToken(ProtoParser.BRACKET_CLOSE, 0); }
		public List COMMA() { return getTokens(ProtoParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(ProtoParser.COMMA, i);
		}
		public EnumFieldContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumField; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterEnumField(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitEnumField(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitEnumField(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EnumFieldContext enumField() throws RecognitionException {
		EnumFieldContext _localctx = new EnumFieldContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_enumField);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(179);
			((EnumFieldContext)_localctx).name = match(IDENTIFIER);
			setState(180);
			match(ASSIGN);
			setState(181);
			((EnumFieldContext)_localctx).value = match(INTEGER_LITERAL);
			setState(193);
			_la = _input.LA(1);
			if (_la==BRACKET_OPEN) {
				{
				setState(182);
				match(BRACKET_OPEN);
				setState(183);
				enumValueOption();
				setState(188);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(184);
					match(COMMA);
					setState(185);
					enumValueOption();
					}
					}
					setState(190);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(191);
				match(BRACKET_CLOSE);
				}
			}

			setState(195);
			match(ITEM_TERMINATOR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EnumValueOptionContext extends ParserRuleContext {
		public OptionNameContext optionName() {
			return getRuleContext(OptionNameContext.class,0);
		}
		public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
		public ConstantContext constant() {
			return getRuleContext(ConstantContext.class,0);
		}
		public EnumValueOptionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumValueOption; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterEnumValueOption(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitEnumValueOption(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitEnumValueOption(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EnumValueOptionContext enumValueOption() throws RecognitionException {
		EnumValueOptionContext _localctx = new EnumValueOptionContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_enumValueOption);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(197);
			optionName();
			setState(198);
			match(ASSIGN);
			setState(199);
			constant();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ReservedContext extends ParserRuleContext {
		public TerminalNode RESERVED_LITERAL() { return getToken(ProtoParser.RESERVED_LITERAL, 0); }
		public TerminalNode ITEM_TERMINATOR() { return getToken(ProtoParser.ITEM_TERMINATOR, 0); }
		public RangesContext ranges() {
			return getRuleContext(RangesContext.class,0);
		}
		public FieldNamesContext fieldNames() {
			return getRuleContext(FieldNamesContext.class,0);
		}
		public ReservedContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_reserved; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterReserved(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitReserved(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitReserved(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ReservedContext reserved() throws RecognitionException {
		ReservedContext _localctx = new ReservedContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_reserved);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(201);
			match(RESERVED_LITERAL);
			setState(204);
			switch (_input.LA(1)) {
			case INTEGER_LITERAL:
				{
				setState(202);
				ranges();
				}
				break;
			case STRING_LITERAL:
				{
				setState(203);
				fieldNames();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(206);
			match(ITEM_TERMINATOR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FieldNamesContext extends ParserRuleContext {
		public List reservedFieldName() {
			return getRuleContexts(ReservedFieldNameContext.class);
		}
		public ReservedFieldNameContext reservedFieldName(int i) {
			return getRuleContext(ReservedFieldNameContext.class,i);
		}
		public List COMMA() { return getTokens(ProtoParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(ProtoParser.COMMA, i);
		}
		public FieldNamesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fieldNames; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterFieldNames(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitFieldNames(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitFieldNames(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FieldNamesContext fieldNames() throws RecognitionException {
		FieldNamesContext _localctx = new FieldNamesContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_fieldNames);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(208);
			reservedFieldName();
			setState(213);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(209);
				match(COMMA);
				setState(210);
				reservedFieldName();
				}
				}
				setState(215);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ReservedFieldNameContext extends ParserRuleContext {
		public TerminalNode STRING_LITERAL() { return getToken(ProtoParser.STRING_LITERAL, 0); }
		public ReservedFieldNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_reservedFieldName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterReservedFieldName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitReservedFieldName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitReservedFieldName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ReservedFieldNameContext reservedFieldName() throws RecognitionException {
		ReservedFieldNameContext _localctx = new ReservedFieldNameContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_reservedFieldName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(216);
			match(STRING_LITERAL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RangesContext extends ParserRuleContext {
		public List range() {
			return getRuleContexts(RangeContext.class);
		}
		public RangeContext range(int i) {
			return getRuleContext(RangeContext.class,i);
		}
		public List COMMA() { return getTokens(ProtoParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(ProtoParser.COMMA, i);
		}
		public RangesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ranges; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterRanges(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitRanges(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitRanges(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RangesContext ranges() throws RecognitionException {
		RangesContext _localctx = new RangesContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_ranges);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(218);
			range();
			setState(223);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(219);
				match(COMMA);
				setState(220);
				range();
				}
				}
				setState(225);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RangeContext extends ParserRuleContext {
		public List INTEGER_LITERAL() { return getTokens(ProtoParser.INTEGER_LITERAL); }
		public TerminalNode INTEGER_LITERAL(int i) {
			return getToken(ProtoParser.INTEGER_LITERAL, i);
		}
		public TerminalNode EXTENSIONS_TO_LITERAL() { return getToken(ProtoParser.EXTENSIONS_TO_LITERAL, 0); }
		public TerminalNode EXTENSIONS_MAX_LITERAL() { return getToken(ProtoParser.EXTENSIONS_MAX_LITERAL, 0); }
		public RangeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_range; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterRange(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitRange(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitRange(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RangeContext range() throws RecognitionException {
		RangeContext _localctx = new RangeContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_range);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(226);
			match(INTEGER_LITERAL);
			setState(229);
			_la = _input.LA(1);
			if (_la==EXTENSIONS_TO_LITERAL) {
				{
				setState(227);
				match(EXTENSIONS_TO_LITERAL);
				setState(228);
				_la = _input.LA(1);
				if ( !(_la==EXTENSIONS_MAX_LITERAL || _la==INTEGER_LITERAL) ) {
				_errHandler.recoverInline(this);
				} else {
					consume();
				}
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MapFieldContext extends ParserRuleContext {
		public TerminalNode MAP_LITERAL() { return getToken(ProtoParser.MAP_LITERAL, 0); }
		public TerminalNode MAP_OPEN() { return getToken(ProtoParser.MAP_OPEN, 0); }
		public MapKeyTypeContext mapKeyType() {
			return getRuleContext(MapKeyTypeContext.class,0);
		}
		public TerminalNode COMMA() { return getToken(ProtoParser.COMMA, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TerminalNode MAP_CLOSE() { return getToken(ProtoParser.MAP_CLOSE, 0); }
		public MapNameContext mapName() {
			return getRuleContext(MapNameContext.class,0);
		}
		public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
		public FieldNumberContext fieldNumber() {
			return getRuleContext(FieldNumberContext.class,0);
		}
		public TerminalNode ITEM_TERMINATOR() { return getToken(ProtoParser.ITEM_TERMINATOR, 0); }
		public TerminalNode BRACKET_OPEN() { return getToken(ProtoParser.BRACKET_OPEN, 0); }
		public FieldOptionsContext fieldOptions() {
			return getRuleContext(FieldOptionsContext.class,0);
		}
		public TerminalNode BRACKET_CLOSE() { return getToken(ProtoParser.BRACKET_CLOSE, 0); }
		public MapFieldContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_mapField; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterMapField(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitMapField(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitMapField(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MapFieldContext mapField() throws RecognitionException {
		MapFieldContext _localctx = new MapFieldContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_mapField);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(231);
			match(MAP_LITERAL);
			setState(232);
			match(MAP_OPEN);
			setState(233);
			mapKeyType();
			setState(234);
			match(COMMA);
			setState(235);
			type();
			setState(236);
			match(MAP_CLOSE);
			setState(237);
			mapName();
			setState(238);
			match(ASSIGN);
			setState(239);
			fieldNumber();
			setState(244);
			_la = _input.LA(1);
			if (_la==BRACKET_OPEN) {
				{
				setState(240);
				match(BRACKET_OPEN);
				setState(241);
				fieldOptions();
				setState(242);
				match(BRACKET_CLOSE);
				}
			}

			setState(246);
			match(ITEM_TERMINATOR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OneofContext extends ParserRuleContext {
		public TerminalNode ONEOF_LITERAL() { return getToken(ProtoParser.ONEOF_LITERAL, 0); }
		public OneofNameContext oneofName() {
			return getRuleContext(OneofNameContext.class,0);
		}
		public TerminalNode BLOCK_OPEN() { return getToken(ProtoParser.BLOCK_OPEN, 0); }
		public TerminalNode BLOCK_CLOSE() { return getToken(ProtoParser.BLOCK_CLOSE, 0); }
		public List oneofField() {
			return getRuleContexts(OneofFieldContext.class);
		}
		public OneofFieldContext oneofField(int i) {
			return getRuleContext(OneofFieldContext.class,i);
		}
		public List emptyStatement() {
			return getRuleContexts(EmptyStatementContext.class);
		}
		public EmptyStatementContext emptyStatement(int i) {
			return getRuleContext(EmptyStatementContext.class,i);
		}
		public OneofContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_oneof; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterOneof(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitOneof(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitOneof(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OneofContext oneof() throws RecognitionException {
		OneofContext _localctx = new OneofContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_oneof);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(248);
			match(ONEOF_LITERAL);
			setState(249);
			oneofName();
			setState(250);
			match(BLOCK_OPEN);
			setState(255);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << DOT) | (1L << ITEM_TERMINATOR) | (1L << DOUBLE_TYPE_LITERAL) | (1L << FLOAT_TYPE_LITERAL) | (1L << INT32_TYPE_LITERAL) | (1L << INT64_TYPE_LITERAL) | (1L << UINT32_TYPE_LITERAL) | (1L << UINT64_TYPE_LITERAL) | (1L << SINT32_TYPE_LITERAL) | (1L << SINT64_TYPE_LITERAL) | (1L << FIXED32_TYPE_LITERAL) | (1L << FIXED64_TYPE_LITERAL) | (1L << SFIXED32_TYPE_LITERAL) | (1L << SFIXED64_TYPE_LITERAL) | (1L << BOOLEAN_TYPE_LITERAL) | (1L << STRING_TYPE_LITERAL) | (1L << BYTES_TYPE_LITERAL) | (1L << IDENTIFIER))) != 0)) {
				{
				setState(253);
				switch (_input.LA(1)) {
				case DOT:
				case DOUBLE_TYPE_LITERAL:
				case FLOAT_TYPE_LITERAL:
				case INT32_TYPE_LITERAL:
				case INT64_TYPE_LITERAL:
				case UINT32_TYPE_LITERAL:
				case UINT64_TYPE_LITERAL:
				case SINT32_TYPE_LITERAL:
				case SINT64_TYPE_LITERAL:
				case FIXED32_TYPE_LITERAL:
				case FIXED64_TYPE_LITERAL:
				case SFIXED32_TYPE_LITERAL:
				case SFIXED64_TYPE_LITERAL:
				case BOOLEAN_TYPE_LITERAL:
				case STRING_TYPE_LITERAL:
				case BYTES_TYPE_LITERAL:
				case IDENTIFIER:
					{
					setState(251);
					oneofField();
					}
					break;
				case ITEM_TERMINATOR:
					{
					setState(252);
					emptyStatement();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				setState(257);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(258);
			match(BLOCK_CLOSE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OneofFieldContext extends ParserRuleContext {
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public FieldNameContext fieldName() {
			return getRuleContext(FieldNameContext.class,0);
		}
		public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
		public FieldNumberContext fieldNumber() {
			return getRuleContext(FieldNumberContext.class,0);
		}
		public TerminalNode ITEM_TERMINATOR() { return getToken(ProtoParser.ITEM_TERMINATOR, 0); }
		public TerminalNode BRACKET_OPEN() { return getToken(ProtoParser.BRACKET_OPEN, 0); }
		public FieldOptionsContext fieldOptions() {
			return getRuleContext(FieldOptionsContext.class,0);
		}
		public TerminalNode BRACKET_CLOSE() { return getToken(ProtoParser.BRACKET_CLOSE, 0); }
		public OneofFieldContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_oneofField; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterOneofField(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitOneofField(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitOneofField(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OneofFieldContext oneofField() throws RecognitionException {
		OneofFieldContext _localctx = new OneofFieldContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_oneofField);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(260);
			type();
			setState(261);
			fieldName();
			setState(262);
			match(ASSIGN);
			setState(263);
			fieldNumber();
			setState(268);
			_la = _input.LA(1);
			if (_la==BRACKET_OPEN) {
				{
				setState(264);
				match(BRACKET_OPEN);
				setState(265);
				fieldOptions();
				setState(266);
				match(BRACKET_CLOSE);
				}
			}

			setState(270);
			match(ITEM_TERMINATOR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FieldContext extends ParserRuleContext {
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public FieldNameContext fieldName() {
			return getRuleContext(FieldNameContext.class,0);
		}
		public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
		public FieldNumberContext fieldNumber() {
			return getRuleContext(FieldNumberContext.class,0);
		}
		public TerminalNode ITEM_TERMINATOR() { return getToken(ProtoParser.ITEM_TERMINATOR, 0); }
		public TerminalNode REPEATED_LITERAL() { return getToken(ProtoParser.REPEATED_LITERAL, 0); }
		public TerminalNode BRACKET_OPEN() { return getToken(ProtoParser.BRACKET_OPEN, 0); }
		public FieldOptionsContext fieldOptions() {
			return getRuleContext(FieldOptionsContext.class,0);
		}
		public TerminalNode BRACKET_CLOSE() { return getToken(ProtoParser.BRACKET_CLOSE, 0); }
		public FieldContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_field; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterField(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitField(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitField(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FieldContext field() throws RecognitionException {
		FieldContext _localctx = new FieldContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_field);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(273);
			_la = _input.LA(1);
			if (_la==REPEATED_LITERAL) {
				{
				setState(272);
				match(REPEATED_LITERAL);
				}
			}

			setState(275);
			type();
			setState(276);
			fieldName();
			setState(277);
			match(ASSIGN);
			setState(278);
			fieldNumber();
			setState(283);
			_la = _input.LA(1);
			if (_la==BRACKET_OPEN) {
				{
				setState(279);
				match(BRACKET_OPEN);
				setState(280);
				fieldOptions();
				setState(281);
				match(BRACKET_CLOSE);
				}
			}

			setState(285);
			match(ITEM_TERMINATOR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FieldOptionsContext extends ParserRuleContext {
		public List fieldOption() {
			return getRuleContexts(FieldOptionContext.class);
		}
		public FieldOptionContext fieldOption(int i) {
			return getRuleContext(FieldOptionContext.class,i);
		}
		public List COMMA() { return getTokens(ProtoParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(ProtoParser.COMMA, i);
		}
		public FieldOptionsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fieldOptions; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterFieldOptions(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitFieldOptions(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitFieldOptions(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FieldOptionsContext fieldOptions() throws RecognitionException {
		FieldOptionsContext _localctx = new FieldOptionsContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_fieldOptions);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(287);
			fieldOption();
			setState(292);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(288);
				match(COMMA);
				setState(289);
				fieldOption();
				}
				}
				setState(294);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FieldOptionContext extends ParserRuleContext {
		public OptionNameContext optionName() {
			return getRuleContext(OptionNameContext.class,0);
		}
		public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
		public ConstantContext constant() {
			return getRuleContext(ConstantContext.class,0);
		}
		public FieldOptionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fieldOption; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterFieldOption(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitFieldOption(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitFieldOption(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FieldOptionContext fieldOption() throws RecognitionException {
		FieldOptionContext _localctx = new FieldOptionContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_fieldOption);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(295);
			optionName();
			setState(296);
			match(ASSIGN);
			setState(297);
			constant();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TypeContext extends ParserRuleContext {
		public ProtoTypeContext protoType() {
			return getRuleContext(ProtoTypeContext.class,0);
		}
		public MessageOrEnumTypeContext messageOrEnumType() {
			return getRuleContext(MessageOrEnumTypeContext.class,0);
		}
		public TypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_type; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeContext type() throws RecognitionException {
		TypeContext _localctx = new TypeContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_type);
		try {
			setState(301);
			switch (_input.LA(1)) {
			case DOUBLE_TYPE_LITERAL:
			case FLOAT_TYPE_LITERAL:
			case INT32_TYPE_LITERAL:
			case INT64_TYPE_LITERAL:
			case UINT32_TYPE_LITERAL:
			case UINT64_TYPE_LITERAL:
			case SINT32_TYPE_LITERAL:
			case SINT64_TYPE_LITERAL:
			case FIXED32_TYPE_LITERAL:
			case FIXED64_TYPE_LITERAL:
			case SFIXED32_TYPE_LITERAL:
			case SFIXED64_TYPE_LITERAL:
			case BOOLEAN_TYPE_LITERAL:
			case STRING_TYPE_LITERAL:
			case BYTES_TYPE_LITERAL:
				enterOuterAlt(_localctx, 1);
				{
				setState(299);
				protoType();
				}
				break;
			case DOT:
			case IDENTIFIER:
				enterOuterAlt(_localctx, 2);
				{
				setState(300);
				messageOrEnumType();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FieldNumberContext extends ParserRuleContext {
		public TerminalNode INTEGER_LITERAL() { return getToken(ProtoParser.INTEGER_LITERAL, 0); }
		public FieldNumberContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fieldNumber; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterFieldNumber(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitFieldNumber(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitFieldNumber(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FieldNumberContext fieldNumber() throws RecognitionException {
		FieldNumberContext _localctx = new FieldNumberContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_fieldNumber);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(303);
			match(INTEGER_LITERAL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OptionContext extends ParserRuleContext {
		public TerminalNode OPTION_LITERAL() { return getToken(ProtoParser.OPTION_LITERAL, 0); }
		public OptionNameContext optionName() {
			return getRuleContext(OptionNameContext.class,0);
		}
		public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
		public ConstantContext constant() {
			return getRuleContext(ConstantContext.class,0);
		}
		public TerminalNode ITEM_TERMINATOR() { return getToken(ProtoParser.ITEM_TERMINATOR, 0); }
		public OptionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_option; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterOption(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitOption(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitOption(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OptionContext option() throws RecognitionException {
		OptionContext _localctx = new OptionContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_option);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(305);
			match(OPTION_LITERAL);
			setState(306);
			optionName();
			setState(307);
			match(ASSIGN);
			setState(308);
			constant();
			setState(309);
			match(ITEM_TERMINATOR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OptionNameContext extends ParserRuleContext {
		public List IDENTIFIER() { return getTokens(ProtoParser.IDENTIFIER); }
		public TerminalNode IDENTIFIER(int i) {
			return getToken(ProtoParser.IDENTIFIER, i);
		}
		public TerminalNode PAREN_OPEN() { return getToken(ProtoParser.PAREN_OPEN, 0); }
		public FullIdentifierContext fullIdentifier() {
			return getRuleContext(FullIdentifierContext.class,0);
		}
		public TerminalNode PAREN_CLOSE() { return getToken(ProtoParser.PAREN_CLOSE, 0); }
		public List DOT() { return getTokens(ProtoParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(ProtoParser.DOT, i);
		}
		public OptionNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_optionName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterOptionName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitOptionName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitOptionName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OptionNameContext optionName() throws RecognitionException {
		OptionNameContext _localctx = new OptionNameContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_optionName);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(316);
			switch (_input.LA(1)) {
			case IDENTIFIER:
				{
				setState(311);
				match(IDENTIFIER);
				}
				break;
			case PAREN_OPEN:
				{
				setState(312);
				match(PAREN_OPEN);
				setState(313);
				fullIdentifier();
				setState(314);
				match(PAREN_CLOSE);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(322);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==DOT) {
				{
				{
				setState(318);
				match(DOT);
				setState(319);
				match(IDENTIFIER);
				}
				}
				setState(324);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PackagePBContext extends ParserRuleContext {
		public TerminalNode PACKAGE_LITERAL() { return getToken(ProtoParser.PACKAGE_LITERAL, 0); }
		public FullIdentifierContext fullIdentifier() {
			return getRuleContext(FullIdentifierContext.class,0);
		}
		public TerminalNode ITEM_TERMINATOR() { return getToken(ProtoParser.ITEM_TERMINATOR, 0); }
		public PackagePBContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_packagePB; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterPackagePB(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitPackagePB(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitPackagePB(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PackagePBContext packagePB() throws RecognitionException {
		PackagePBContext _localctx = new PackagePBContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_packagePB);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(325);
			match(PACKAGE_LITERAL);
			setState(326);
			fullIdentifier();
			setState(327);
			match(ITEM_TERMINATOR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ImportPBContext extends ParserRuleContext {
		public Token protoFile;
		public TerminalNode IMPORT_LITERAL() { return getToken(ProtoParser.IMPORT_LITERAL, 0); }
		public TerminalNode ITEM_TERMINATOR() { return getToken(ProtoParser.ITEM_TERMINATOR, 0); }
		public TerminalNode STRING_LITERAL() { return getToken(ProtoParser.STRING_LITERAL, 0); }
		public TerminalNode WEAK_LITERAL() { return getToken(ProtoParser.WEAK_LITERAL, 0); }
		public TerminalNode PUBLIC_LITERAL() { return getToken(ProtoParser.PUBLIC_LITERAL, 0); }
		public ImportPBContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_importPB; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterImportPB(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitImportPB(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitImportPB(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ImportPBContext importPB() throws RecognitionException {
		ImportPBContext _localctx = new ImportPBContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_importPB);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(329);
			match(IMPORT_LITERAL);
			setState(331);
			_la = _input.LA(1);
			if (_la==PUBLIC_LITERAL || _la==WEAK_LITERAL) {
				{
				setState(330);
				_la = _input.LA(1);
				if ( !(_la==PUBLIC_LITERAL || _la==WEAK_LITERAL) ) {
				_errHandler.recoverInline(this);
				} else {
					consume();
				}
				}
			}

			setState(333);
			((ImportPBContext)_localctx).protoFile = match(STRING_LITERAL);
			setState(334);
			match(ITEM_TERMINATOR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SyntaxContext extends ParserRuleContext {
		public Token version;
		public TerminalNode SYNTAX_LITERAL() { return getToken(ProtoParser.SYNTAX_LITERAL, 0); }
		public TerminalNode ASSIGN() { return getToken(ProtoParser.ASSIGN, 0); }
		public TerminalNode ITEM_TERMINATOR() { return getToken(ProtoParser.ITEM_TERMINATOR, 0); }
		public TerminalNode STRING_LITERAL() { return getToken(ProtoParser.STRING_LITERAL, 0); }
		public SyntaxContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_syntax; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterSyntax(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitSyntax(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitSyntax(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SyntaxContext syntax() throws RecognitionException {
		SyntaxContext _localctx = new SyntaxContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_syntax);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(336);
			match(SYNTAX_LITERAL);
			setState(337);
			match(ASSIGN);
			setState(338);
			((SyntaxContext)_localctx).version = match(STRING_LITERAL);
			setState(339);
			match(ITEM_TERMINATOR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConstantContext extends ParserRuleContext {
		public FullIdentifierContext fullIdentifier() {
			return getRuleContext(FullIdentifierContext.class,0);
		}
		public TerminalNode INTEGER_LITERAL() { return getToken(ProtoParser.INTEGER_LITERAL, 0); }
		public TerminalNode PLUS() { return getToken(ProtoParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(ProtoParser.MINUS, 0); }
		public TerminalNode FLOAT_LITERAL() { return getToken(ProtoParser.FLOAT_LITERAL, 0); }
		public TerminalNode STRING_LITERAL() { return getToken(ProtoParser.STRING_LITERAL, 0); }
		public TerminalNode BOOLEAN_LITERAL() { return getToken(ProtoParser.BOOLEAN_LITERAL, 0); }
		public ConstantContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_constant; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterConstant(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitConstant(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitConstant(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConstantContext constant() throws RecognitionException {
		ConstantContext _localctx = new ConstantContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_constant);
		int _la;
		try {
			setState(351);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(341);
				fullIdentifier();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(343);
				_la = _input.LA(1);
				if (_la==PLUS || _la==MINUS) {
					{
					setState(342);
					_la = _input.LA(1);
					if ( !(_la==PLUS || _la==MINUS) ) {
					_errHandler.recoverInline(this);
					} else {
						consume();
					}
					}
				}

				setState(345);
				match(INTEGER_LITERAL);
				}
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				{
				setState(347);
				_la = _input.LA(1);
				if (_la==PLUS || _la==MINUS) {
					{
					setState(346);
					_la = _input.LA(1);
					if ( !(_la==PLUS || _la==MINUS) ) {
					_errHandler.recoverInline(this);
					} else {
						consume();
					}
					}
				}

				setState(349);
				match(FLOAT_LITERAL);
				}
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(350);
				_la = _input.LA(1);
				if ( !(_la==STRING_LITERAL || _la==BOOLEAN_LITERAL) ) {
				_errHandler.recoverInline(this);
				} else {
					consume();
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MapKeyTypeContext extends ParserRuleContext {
		public TerminalNode INT32_TYPE_LITERAL() { return getToken(ProtoParser.INT32_TYPE_LITERAL, 0); }
		public TerminalNode INT64_TYPE_LITERAL() { return getToken(ProtoParser.INT64_TYPE_LITERAL, 0); }
		public TerminalNode UINT32_TYPE_LITERAL() { return getToken(ProtoParser.UINT32_TYPE_LITERAL, 0); }
		public TerminalNode UINT64_TYPE_LITERAL() { return getToken(ProtoParser.UINT64_TYPE_LITERAL, 0); }
		public TerminalNode SINT32_TYPE_LITERAL() { return getToken(ProtoParser.SINT32_TYPE_LITERAL, 0); }
		public TerminalNode SINT64_TYPE_LITERAL() { return getToken(ProtoParser.SINT64_TYPE_LITERAL, 0); }
		public TerminalNode FIXED32_TYPE_LITERAL() { return getToken(ProtoParser.FIXED32_TYPE_LITERAL, 0); }
		public TerminalNode FIXED64_TYPE_LITERAL() { return getToken(ProtoParser.FIXED64_TYPE_LITERAL, 0); }
		public TerminalNode SFIXED32_TYPE_LITERAL() { return getToken(ProtoParser.SFIXED32_TYPE_LITERAL, 0); }
		public TerminalNode SFIXED64_TYPE_LITERAL() { return getToken(ProtoParser.SFIXED64_TYPE_LITERAL, 0); }
		public TerminalNode BOOLEAN_TYPE_LITERAL() { return getToken(ProtoParser.BOOLEAN_TYPE_LITERAL, 0); }
		public TerminalNode STRING_TYPE_LITERAL() { return getToken(ProtoParser.STRING_TYPE_LITERAL, 0); }
		public MapKeyTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_mapKeyType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterMapKeyType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitMapKeyType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitMapKeyType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MapKeyTypeContext mapKeyType() throws RecognitionException {
		MapKeyTypeContext _localctx = new MapKeyTypeContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_mapKeyType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(353);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << INT32_TYPE_LITERAL) | (1L << INT64_TYPE_LITERAL) | (1L << UINT32_TYPE_LITERAL) | (1L << UINT64_TYPE_LITERAL) | (1L << SINT32_TYPE_LITERAL) | (1L << SINT64_TYPE_LITERAL) | (1L << FIXED32_TYPE_LITERAL) | (1L << FIXED64_TYPE_LITERAL) | (1L << SFIXED32_TYPE_LITERAL) | (1L << SFIXED64_TYPE_LITERAL) | (1L << BOOLEAN_TYPE_LITERAL) | (1L << STRING_TYPE_LITERAL))) != 0)) ) {
			_errHandler.recoverInline(this);
			} else {
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ProtoTypeContext extends ParserRuleContext {
		public TerminalNode DOUBLE_TYPE_LITERAL() { return getToken(ProtoParser.DOUBLE_TYPE_LITERAL, 0); }
		public TerminalNode FLOAT_TYPE_LITERAL() { return getToken(ProtoParser.FLOAT_TYPE_LITERAL, 0); }
		public TerminalNode INT32_TYPE_LITERAL() { return getToken(ProtoParser.INT32_TYPE_LITERAL, 0); }
		public TerminalNode INT64_TYPE_LITERAL() { return getToken(ProtoParser.INT64_TYPE_LITERAL, 0); }
		public TerminalNode UINT32_TYPE_LITERAL() { return getToken(ProtoParser.UINT32_TYPE_LITERAL, 0); }
		public TerminalNode UINT64_TYPE_LITERAL() { return getToken(ProtoParser.UINT64_TYPE_LITERAL, 0); }
		public TerminalNode SINT32_TYPE_LITERAL() { return getToken(ProtoParser.SINT32_TYPE_LITERAL, 0); }
		public TerminalNode SINT64_TYPE_LITERAL() { return getToken(ProtoParser.SINT64_TYPE_LITERAL, 0); }
		public TerminalNode FIXED32_TYPE_LITERAL() { return getToken(ProtoParser.FIXED32_TYPE_LITERAL, 0); }
		public TerminalNode FIXED64_TYPE_LITERAL() { return getToken(ProtoParser.FIXED64_TYPE_LITERAL, 0); }
		public TerminalNode SFIXED32_TYPE_LITERAL() { return getToken(ProtoParser.SFIXED32_TYPE_LITERAL, 0); }
		public TerminalNode SFIXED64_TYPE_LITERAL() { return getToken(ProtoParser.SFIXED64_TYPE_LITERAL, 0); }
		public TerminalNode BOOLEAN_TYPE_LITERAL() { return getToken(ProtoParser.BOOLEAN_TYPE_LITERAL, 0); }
		public TerminalNode STRING_TYPE_LITERAL() { return getToken(ProtoParser.STRING_TYPE_LITERAL, 0); }
		public TerminalNode BYTES_TYPE_LITERAL() { return getToken(ProtoParser.BYTES_TYPE_LITERAL, 0); }
		public ProtoTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_protoType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterProtoType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitProtoType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitProtoType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ProtoTypeContext protoType() throws RecognitionException {
		ProtoTypeContext _localctx = new ProtoTypeContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_protoType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(355);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << DOUBLE_TYPE_LITERAL) | (1L << FLOAT_TYPE_LITERAL) | (1L << INT32_TYPE_LITERAL) | (1L << INT64_TYPE_LITERAL) | (1L << UINT32_TYPE_LITERAL) | (1L << UINT64_TYPE_LITERAL) | (1L << SINT32_TYPE_LITERAL) | (1L << SINT64_TYPE_LITERAL) | (1L << FIXED32_TYPE_LITERAL) | (1L << FIXED64_TYPE_LITERAL) | (1L << SFIXED32_TYPE_LITERAL) | (1L << SFIXED64_TYPE_LITERAL) | (1L << BOOLEAN_TYPE_LITERAL) | (1L << STRING_TYPE_LITERAL) | (1L << BYTES_TYPE_LITERAL))) != 0)) ) {
			_errHandler.recoverInline(this);
			} else {
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FullIdentifierContext extends ParserRuleContext {
		public List IDENTIFIER() { return getTokens(ProtoParser.IDENTIFIER); }
		public TerminalNode IDENTIFIER(int i) {
			return getToken(ProtoParser.IDENTIFIER, i);
		}
		public List DOT() { return getTokens(ProtoParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(ProtoParser.DOT, i);
		}
		public FullIdentifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fullIdentifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterFullIdentifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitFullIdentifier(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitFullIdentifier(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FullIdentifierContext fullIdentifier() throws RecognitionException {
		FullIdentifierContext _localctx = new FullIdentifierContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_fullIdentifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(357);
			match(IDENTIFIER);
			setState(362);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==DOT) {
				{
				{
				setState(358);
				match(DOT);
				setState(359);
				match(IDENTIFIER);
				}
				}
				setState(364);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MessageNameContext extends ParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(ProtoParser.IDENTIFIER, 0); }
		public MessageNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_messageName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterMessageName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitMessageName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitMessageName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MessageNameContext messageName() throws RecognitionException {
		MessageNameContext _localctx = new MessageNameContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_messageName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(365);
			match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EnumNameContext extends ParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(ProtoParser.IDENTIFIER, 0); }
		public EnumNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterEnumName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitEnumName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitEnumName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EnumNameContext enumName() throws RecognitionException {
		EnumNameContext _localctx = new EnumNameContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_enumName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(367);
			match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FieldNameContext extends ParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(ProtoParser.IDENTIFIER, 0); }
		public FieldNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fieldName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterFieldName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitFieldName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitFieldName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FieldNameContext fieldName() throws RecognitionException {
		FieldNameContext _localctx = new FieldNameContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_fieldName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(369);
			match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OneofNameContext extends ParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(ProtoParser.IDENTIFIER, 0); }
		public OneofNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_oneofName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterOneofName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitOneofName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitOneofName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OneofNameContext oneofName() throws RecognitionException {
		OneofNameContext _localctx = new OneofNameContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_oneofName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(371);
			match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MapNameContext extends ParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(ProtoParser.IDENTIFIER, 0); }
		public MapNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_mapName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterMapName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitMapName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitMapName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MapNameContext mapName() throws RecognitionException {
		MapNameContext _localctx = new MapNameContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_mapName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(373);
			match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ServiceNameContext extends ParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(ProtoParser.IDENTIFIER, 0); }
		public ServiceNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_serviceName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterServiceName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitServiceName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitServiceName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ServiceNameContext serviceName() throws RecognitionException {
		ServiceNameContext _localctx = new ServiceNameContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_serviceName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(375);
			match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RpcNameContext extends ParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(ProtoParser.IDENTIFIER, 0); }
		public RpcNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rpcName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterRpcName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitRpcName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitRpcName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RpcNameContext rpcName() throws RecognitionException {
		RpcNameContext _localctx = new RpcNameContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_rpcName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(377);
			match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MessageOrEnumTypeContext extends ParserRuleContext {
		public List IDENTIFIER() { return getTokens(ProtoParser.IDENTIFIER); }
		public TerminalNode IDENTIFIER(int i) {
			return getToken(ProtoParser.IDENTIFIER, i);
		}
		public List DOT() { return getTokens(ProtoParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(ProtoParser.DOT, i);
		}
		public MessageOrEnumTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_messageOrEnumType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterMessageOrEnumType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitMessageOrEnumType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitMessageOrEnumType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MessageOrEnumTypeContext messageOrEnumType() throws RecognitionException {
		MessageOrEnumTypeContext _localctx = new MessageOrEnumTypeContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_messageOrEnumType);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(380);
			_la = _input.LA(1);
			if (_la==DOT) {
				{
				setState(379);
				match(DOT);
				}
			}

			setState(386);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(382);
					match(IDENTIFIER);
					setState(383);
					match(DOT);
					}
					} 
				}
				setState(388);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
			}
			setState(389);
			match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MessageTypeContext extends ParserRuleContext {
		public MessageNameContext messageName() {
			return getRuleContext(MessageNameContext.class,0);
		}
		public List DOT() { return getTokens(ProtoParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(ProtoParser.DOT, i);
		}
		public List IDENTIFIER() { return getTokens(ProtoParser.IDENTIFIER); }
		public TerminalNode IDENTIFIER(int i) {
			return getToken(ProtoParser.IDENTIFIER, i);
		}
		public MessageTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_messageType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterMessageType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitMessageType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitMessageType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MessageTypeContext messageType() throws RecognitionException {
		MessageTypeContext _localctx = new MessageTypeContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_messageType);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(392);
			_la = _input.LA(1);
			if (_la==DOT) {
				{
				setState(391);
				match(DOT);
				}
			}

			setState(398);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,38,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(394);
					match(IDENTIFIER);
					setState(395);
					match(DOT);
					}
					} 
				}
				setState(400);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,38,_ctx);
			}
			setState(401);
			messageName();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EnumTypeContext extends ParserRuleContext {
		public EnumNameContext enumName() {
			return getRuleContext(EnumNameContext.class,0);
		}
		public List DOT() { return getTokens(ProtoParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(ProtoParser.DOT, i);
		}
		public List IDENTIFIER() { return getTokens(ProtoParser.IDENTIFIER); }
		public TerminalNode IDENTIFIER(int i) {
			return getToken(ProtoParser.IDENTIFIER, i);
		}
		public EnumTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterEnumType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitEnumType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitEnumType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EnumTypeContext enumType() throws RecognitionException {
		EnumTypeContext _localctx = new EnumTypeContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_enumType);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(404);
			_la = _input.LA(1);
			if (_la==DOT) {
				{
				setState(403);
				match(DOT);
				}
			}

			setState(410);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,40,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(406);
					match(IDENTIFIER);
					setState(407);
					match(DOT);
					}
					} 
				}
				setState(412);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,40,_ctx);
			}
			setState(413);
			enumName();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EmptyStatementContext extends ParserRuleContext {
		public TerminalNode ITEM_TERMINATOR() { return getToken(ProtoParser.ITEM_TERMINATOR, 0); }
		public EmptyStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_emptyStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).enterEmptyStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProtoListener ) ((ProtoListener)listener).exitEmptyStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof ProtoVisitor ) return ((ProtoVisitor)visitor).visitEmptyStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EmptyStatementContext emptyStatement() throws RecognitionException {
		EmptyStatementContext _localctx = new EmptyStatementContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_emptyStatement);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(415);
			match(ITEM_TERMINATOR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3<\u01a4\4\2\t\2\4"+
		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
		",\t,\3\2\3\2\3\2\3\2\3\2\3\2\7\2_\n\2\f\2\16\2b\13\2\3\2\3\2\3\3\3\3\3"+
		"\3\5\3i\n\3\3\4\3\4\3\4\3\4\3\4\3\4\7\4q\n\4\f\4\16\4t\13\4\3\4\3\4\3"+
		"\5\3\5\3\5\3\5\5\5|\n\5\3\5\3\5\3\5\3\5\3\5\5\5\u0083\n\5\3\5\3\5\3\5"+
		"\3\5\3\5\7\5\u008a\n\5\f\5\16\5\u008d\13\5\3\5\3\5\5\5\u0091\n\5\3\6\3"+
		"\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\7\7\u00a0\n\7\f\7\16\7"+
		"\u00a3\13\7\3\7\3\7\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\7\t\u00af\n\t\f\t"+
		"\16\t\u00b2\13\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u00bd\n\n\f\n"+
		"\16\n\u00c0\13\n\3\n\3\n\5\n\u00c4\n\n\3\n\3\n\3\13\3\13\3\13\3\13\3\f"+
		"\3\f\3\f\5\f\u00cf\n\f\3\f\3\f\3\r\3\r\3\r\7\r\u00d6\n\r\f\r\16\r\u00d9"+
		"\13\r\3\16\3\16\3\17\3\17\3\17\7\17\u00e0\n\17\f\17\16\17\u00e3\13\17"+
		"\3\20\3\20\3\20\5\20\u00e8\n\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21"+
		"\3\21\3\21\3\21\3\21\3\21\5\21\u00f7\n\21\3\21\3\21\3\22\3\22\3\22\3\22"+
		"\3\22\7\22\u0100\n\22\f\22\16\22\u0103\13\22\3\22\3\22\3\23\3\23\3\23"+
		"\3\23\3\23\3\23\3\23\3\23\5\23\u010f\n\23\3\23\3\23\3\24\5\24\u0114\n"+
		"\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\5\24\u011e\n\24\3\24\3\24"+
		"\3\25\3\25\3\25\7\25\u0125\n\25\f\25\16\25\u0128\13\25\3\26\3\26\3\26"+
		"\3\26\3\27\3\27\5\27\u0130\n\27\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31"+
		"\3\32\3\32\3\32\3\32\3\32\5\32\u013f\n\32\3\32\3\32\7\32\u0143\n\32\f"+
		"\32\16\32\u0146\13\32\3\33\3\33\3\33\3\33\3\34\3\34\5\34\u014e\n\34\3"+
		"\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\36\3\36\5\36\u015a\n\36\3\36"+
		"\3\36\5\36\u015e\n\36\3\36\3\36\5\36\u0162\n\36\3\37\3\37\3 \3 \3!\3!"+
		"\3!\7!\u016b\n!\f!\16!\u016e\13!\3\"\3\"\3#\3#\3$\3$\3%\3%\3&\3&\3\'\3"+
		"\'\3(\3(\3)\5)\u017f\n)\3)\3)\7)\u0183\n)\f)\16)\u0186\13)\3)\3)\3*\5"+
		"*\u018b\n*\3*\3*\7*\u018f\n*\f*\16*\u0192\13*\3*\3*\3+\5+\u0197\n+\3+"+
		"\3+\7+\u019b\n+\f+\16+\u019e\13+\3+\3+\3,\3,\3,\2\2-\2\4\6\b\n\f\16\20"+
		"\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTV\2\b\4\2\f\f"+
		"\67\67\3\2\23\24\3\2!\"\3\2\64\65\3\2\'\62\3\2%\63\u01af\2X\3\2\2\2\4"+
		"h\3\2\2\2\6j\3\2\2\2\bw\3\2\2\2\n\u0092\3\2\2\2\f\u0096\3\2\2\2\16\u00a6"+
		"\3\2\2\2\20\u00aa\3\2\2\2\22\u00b5\3\2\2\2\24\u00c7\3\2\2\2\26\u00cb\3"+
		"\2\2\2\30\u00d2\3\2\2\2\32\u00da\3\2\2\2\34\u00dc\3\2\2\2\36\u00e4\3\2"+
		"\2\2 \u00e9\3\2\2\2\"\u00fa\3\2\2\2$\u0106\3\2\2\2&\u0113\3\2\2\2(\u0121"+
		"\3\2\2\2*\u0129\3\2\2\2,\u012f\3\2\2\2.\u0131\3\2\2\2\60\u0133\3\2\2\2"+
		"\62\u013e\3\2\2\2\64\u0147\3\2\2\2\66\u014b\3\2\2\28\u0152\3\2\2\2:\u0161"+
		"\3\2\2\2<\u0163\3\2\2\2>\u0165\3\2\2\2@\u0167\3\2\2\2B\u016f\3\2\2\2D"+
		"\u0171\3\2\2\2F\u0173\3\2\2\2H\u0175\3\2\2\2J\u0177\3\2\2\2L\u0179\3\2"+
		"\2\2N\u017b\3\2\2\2P\u017e\3\2\2\2R\u018a\3\2\2\2T\u0196\3\2\2\2V\u01a1"+
		"\3\2\2\2X`\58\35\2Y_\5\66\34\2Z_\5\64\33\2[_\5\60\31\2\\_\5\4\3\2]_\5"+
		"V,\2^Y\3\2\2\2^Z\3\2\2\2^[\3\2\2\2^\\\3\2\2\2^]\3\2\2\2_b\3\2\2\2`^\3"+
		"\2\2\2`a\3\2\2\2ac\3\2\2\2b`\3\2\2\2cd\7\2\2\3d\3\3\2\2\2ei\5\n\6\2fi"+
		"\5\16\b\2gi\5\6\4\2he\3\2\2\2hf\3\2\2\2hg\3\2\2\2i\5\3\2\2\2jk\7\17\2"+
		"\2kl\5L\'\2lr\7\25\2\2mq\5\60\31\2nq\5\b\5\2oq\5V,\2pm\3\2\2\2pn\3\2\2"+
		"\2po\3\2\2\2qt\3\2\2\2rp\3\2\2\2rs\3\2\2\2su\3\2\2\2tr\3\2\2\2uv\7\26"+
		"\2\2v\7\3\2\2\2wx\7\21\2\2xy\5N(\2y{\7\27\2\2z|\7\22\2\2{z\3\2\2\2{|\3"+
		"\2\2\2|}\3\2\2\2}~\5R*\2~\177\7\30\2\2\177\u0080\7\20\2\2\u0080\u0082"+
		"\7\27\2\2\u0081\u0083\7\22\2\2\u0082\u0081\3\2\2\2\u0082\u0083\3\2\2\2"+
		"\u0083\u0084\3\2\2\2\u0084\u0085\5R*\2\u0085\u0090\7\30\2\2\u0086\u008b"+
		"\7\25\2\2\u0087\u008a\5\60\31\2\u0088\u008a\5V,\2\u0089\u0087\3\2\2\2"+
		"\u0089\u0088\3\2\2\2\u008a\u008d\3\2\2\2\u008b\u0089\3\2\2\2\u008b\u008c"+
		"\3\2\2\2\u008c\u008e\3\2\2\2\u008d\u008b\3\2\2\2\u008e\u0091\7\26\2\2"+
		"\u008f\u0091\7$\2\2\u0090\u0086\3\2\2\2\u0090\u008f\3\2\2\2\u0091\t\3"+
		"\2\2\2\u0092\u0093\7\b\2\2\u0093\u0094\5B\"\2\u0094\u0095\5\f\7\2\u0095"+
		"\13\3\2\2\2\u0096\u00a1\7\25\2\2\u0097\u00a0\5&\24\2\u0098\u00a0\5\16"+
		"\b\2\u0099\u00a0\5\n\6\2\u009a\u00a0\5\60\31\2\u009b\u00a0\5\"\22\2\u009c"+
		"\u00a0\5 \21\2\u009d\u00a0\5\26\f\2\u009e\u00a0\5V,\2\u009f\u0097\3\2"+
		"\2\2\u009f\u0098\3\2\2\2\u009f\u0099\3\2\2\2\u009f\u009a\3\2\2\2\u009f"+
		"\u009b\3\2\2\2\u009f\u009c\3\2\2\2\u009f\u009d\3\2\2\2\u009f\u009e\3\2"+
		"\2\2\u00a0\u00a3\3\2\2\2\u00a1\u009f\3\2\2\2\u00a1\u00a2\3\2\2\2\u00a2"+
		"\u00a4\3\2\2\2\u00a3\u00a1\3\2\2\2\u00a4\u00a5\7\26\2\2\u00a5\r\3\2\2"+
		"\2\u00a6\u00a7\7\7\2\2\u00a7\u00a8\5D#\2\u00a8\u00a9\5\20\t\2\u00a9\17"+
		"\3\2\2\2\u00aa\u00b0\7\25\2\2\u00ab\u00af\5\60\31\2\u00ac\u00af\5\22\n"+
		"\2\u00ad\u00af\5V,\2\u00ae\u00ab\3\2\2\2\u00ae\u00ac\3\2\2\2\u00ae\u00ad"+
		"\3\2\2\2\u00af\u00b2\3\2\2\2\u00b0\u00ae\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b1"+
		"\u00b3\3\2\2\2\u00b2\u00b0\3\2\2\2\u00b3\u00b4\7\26\2\2\u00b4\21\3\2\2"+
		"\2\u00b5\u00b6\78\2\2\u00b6\u00b7\7\35\2\2\u00b7\u00c3\7\67\2\2\u00b8"+
		"\u00b9\7\31\2\2\u00b9\u00be\5\24\13\2\u00ba\u00bb\7\37\2\2\u00bb\u00bd"+
		"\5\24\13\2\u00bc\u00ba\3\2\2\2\u00bd\u00c0\3\2\2\2\u00be\u00bc\3\2\2\2"+
		"\u00be\u00bf\3\2\2\2\u00bf\u00c1\3\2\2\2\u00c0\u00be\3\2\2\2\u00c1\u00c2"+
		"\7\32\2\2\u00c2\u00c4\3\2\2\2\u00c3\u00b8\3\2\2\2\u00c3\u00c4\3\2\2\2"+
		"\u00c4\u00c5\3\2\2\2\u00c5\u00c6\7$\2\2\u00c6\23\3\2\2\2\u00c7\u00c8\5"+
		"\62\32\2\u00c8\u00c9\7\35\2\2\u00c9\u00ca\5:\36\2\u00ca\25\3\2\2\2\u00cb"+
		"\u00ce\7\16\2\2\u00cc\u00cf\5\34\17\2\u00cd\u00cf\5\30\r\2\u00ce\u00cc"+
		"\3\2\2\2\u00ce\u00cd\3\2\2\2\u00cf\u00d0\3\2\2\2\u00d0\u00d1\7$\2\2\u00d1"+
		"\27\3\2\2\2\u00d2\u00d7\5\32\16\2\u00d3\u00d4\7\37\2\2\u00d4\u00d6\5\32"+
		"\16\2\u00d5\u00d3\3\2\2\2\u00d6\u00d9\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d7"+
		"\u00d8\3\2\2\2\u00d8\31\3\2\2\2\u00d9\u00d7\3\2\2\2\u00da\u00db\7\64\2"+
		"\2\u00db\33\3\2\2\2\u00dc\u00e1\5\36\20\2\u00dd\u00de\7\37\2\2\u00de\u00e0"+
		"\5\36\20\2\u00df\u00dd\3\2\2\2\u00e0\u00e3\3\2\2\2\u00e1\u00df\3\2\2\2"+
		"\u00e1\u00e2\3\2\2\2\u00e2\35\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e4\u00e7"+
		"\7\67\2\2\u00e5\u00e6\7\13\2\2\u00e6\u00e8\t\2\2\2\u00e7\u00e5\3\2\2\2"+
		"\u00e7\u00e8\3\2\2\2\u00e8\37\3\2\2\2\u00e9\u00ea\7\n\2\2\u00ea\u00eb"+
		"\7\33\2\2\u00eb\u00ec\5<\37\2\u00ec\u00ed\7\37\2\2\u00ed\u00ee\5,\27\2"+
		"\u00ee\u00ef\7\34\2\2\u00ef\u00f0\5J&\2\u00f0\u00f1\7\35\2\2\u00f1\u00f6"+
		"\5.\30\2\u00f2\u00f3\7\31\2\2\u00f3\u00f4\5(\25\2\u00f4\u00f5\7\32\2\2"+
		"\u00f5\u00f7\3\2\2\2\u00f6\u00f2\3\2\2\2\u00f6\u00f7\3\2\2\2\u00f7\u00f8"+
		"\3\2\2\2\u00f8\u00f9\7$\2\2\u00f9!\3\2\2\2\u00fa\u00fb\7\t\2\2\u00fb\u00fc"+
		"\5H%\2\u00fc\u0101\7\25\2\2\u00fd\u0100\5$\23\2\u00fe\u0100\5V,\2\u00ff"+
		"\u00fd\3\2\2\2\u00ff\u00fe\3\2\2\2\u0100\u0103\3\2\2\2\u0101\u00ff\3\2"+
		"\2\2\u0101\u0102\3\2\2\2\u0102\u0104\3\2\2\2\u0103\u0101\3\2\2\2\u0104"+
		"\u0105\7\26\2\2\u0105#\3\2\2\2\u0106\u0107\5,\27\2\u0107\u0108\5F$\2\u0108"+
		"\u0109\7\35\2\2\u0109\u010e\5.\30\2\u010a\u010b\7\31\2\2\u010b\u010c\5"+
		"(\25\2\u010c\u010d\7\32\2\2\u010d\u010f\3\2\2\2\u010e\u010a\3\2\2\2\u010e"+
		"\u010f\3\2\2\2\u010f\u0110\3\2\2\2\u0110\u0111\7$\2\2\u0111%\3\2\2\2\u0112"+
		"\u0114\7\r\2\2\u0113\u0112\3\2\2\2\u0113\u0114\3\2\2\2\u0114\u0115\3\2"+
		"\2\2\u0115\u0116\5,\27\2\u0116\u0117\5F$\2\u0117\u0118\7\35\2\2\u0118"+
		"\u011d\5.\30\2\u0119\u011a\7\31\2\2\u011a\u011b\5(\25\2\u011b\u011c\7"+
		"\32\2\2\u011c\u011e\3\2\2\2\u011d\u0119\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+
		"\u011f\3\2\2\2\u011f\u0120\7$\2\2\u0120\'\3\2\2\2\u0121\u0126\5*\26\2"+
		"\u0122\u0123\7\37\2\2\u0123\u0125\5*\26\2\u0124\u0122\3\2\2\2\u0125\u0128"+
		"\3\2\2\2\u0126\u0124\3\2\2\2\u0126\u0127\3\2\2\2\u0127)\3\2\2\2\u0128"+
		"\u0126\3\2\2\2\u0129\u012a\5\62\32\2\u012a\u012b\7\35\2\2\u012b\u012c"+
		"\5:\36\2\u012c+\3\2\2\2\u012d\u0130\5> \2\u012e\u0130\5P)\2\u012f\u012d"+
		"\3\2\2\2\u012f\u012e\3\2\2\2\u0130-\3\2\2\2\u0131\u0132\7\67\2\2\u0132"+
		"/\3\2\2\2\u0133\u0134\7\6\2\2\u0134\u0135\5\62\32\2\u0135\u0136\7\35\2"+
		"\2\u0136\u0137\5:\36\2\u0137\u0138\7$\2\2\u0138\61\3\2\2\2\u0139\u013f"+
		"\78\2\2\u013a\u013b\7\27\2\2\u013b\u013c\5@!\2\u013c\u013d\7\30\2\2\u013d"+
		"\u013f\3\2\2\2\u013e\u0139\3\2\2\2\u013e\u013a\3\2\2\2\u013f\u0144\3\2"+
		"\2\2\u0140\u0141\7 \2\2\u0141\u0143\78\2\2\u0142\u0140\3\2\2\2\u0143\u0146"+
		"\3\2\2\2\u0144\u0142\3\2\2\2\u0144\u0145\3\2\2\2\u0145\63\3\2\2\2\u0146"+
		"\u0144\3\2\2\2\u0147\u0148\7\4\2\2\u0148\u0149\5@!\2\u0149\u014a\7$\2"+
		"\2\u014a\65\3\2\2\2\u014b\u014d\7\5\2\2\u014c\u014e\t\3\2\2\u014d\u014c"+
		"\3\2\2\2\u014d\u014e\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0150\7\64\2\2"+
		"\u0150\u0151\7$\2\2\u0151\67\3\2\2\2\u0152\u0153\7\3\2\2\u0153\u0154\7"+
		"\35\2\2\u0154\u0155\7\64\2\2\u0155\u0156\7$\2\2\u01569\3\2\2\2\u0157\u0162"+
		"\5@!\2\u0158\u015a\t\4\2\2\u0159\u0158\3\2\2\2\u0159\u015a\3\2\2\2\u015a"+
		"\u015b\3\2\2\2\u015b\u0162\7\67\2\2\u015c\u015e\t\4\2\2\u015d\u015c\3"+
		"\2\2\2\u015d\u015e\3\2\2\2\u015e\u015f\3\2\2\2\u015f\u0162\7\66\2\2\u0160"+
		"\u0162\t\5\2\2\u0161\u0157\3\2\2\2\u0161\u0159\3\2\2\2\u0161\u015d\3\2"+
		"\2\2\u0161\u0160\3\2\2\2\u0162;\3\2\2\2\u0163\u0164\t\6\2\2\u0164=\3\2"+
		"\2\2\u0165\u0166\t\7\2\2\u0166?\3\2\2\2\u0167\u016c\78\2\2\u0168\u0169"+
		"\7 \2\2\u0169\u016b\78\2\2\u016a\u0168\3\2\2\2\u016b\u016e\3\2\2\2\u016c"+
		"\u016a\3\2\2\2\u016c\u016d\3\2\2\2\u016dA\3\2\2\2\u016e\u016c\3\2\2\2"+
		"\u016f\u0170\78\2\2\u0170C\3\2\2\2\u0171\u0172\78\2\2\u0172E\3\2\2\2\u0173"+
		"\u0174\78\2\2\u0174G\3\2\2\2\u0175\u0176\78\2\2\u0176I\3\2\2\2\u0177\u0178"+
		"\78\2\2\u0178K\3\2\2\2\u0179\u017a\78\2\2\u017aM\3\2\2\2\u017b\u017c\7"+
		"8\2\2\u017cO\3\2\2\2\u017d\u017f\7 \2\2\u017e\u017d\3\2\2\2\u017e\u017f"+
		"\3\2\2\2\u017f\u0184\3\2\2\2\u0180\u0181\78\2\2\u0181\u0183\7 \2\2\u0182"+
		"\u0180\3\2\2\2\u0183\u0186\3\2\2\2\u0184\u0182\3\2\2\2\u0184\u0185\3\2"+
		"\2\2\u0185\u0187\3\2\2\2\u0186\u0184\3\2\2\2\u0187\u0188\78\2\2\u0188"+
		"Q\3\2\2\2\u0189\u018b\7 \2\2\u018a\u0189\3\2\2\2\u018a\u018b\3\2\2\2\u018b"+
		"\u0190\3\2\2\2\u018c\u018d\78\2\2\u018d\u018f\7 \2\2\u018e\u018c\3\2\2"+
		"\2\u018f\u0192\3\2\2\2\u0190\u018e\3\2\2\2\u0190\u0191\3\2\2\2\u0191\u0193"+
		"\3\2\2\2\u0192\u0190\3\2\2\2\u0193\u0194\5B\"\2\u0194S\3\2\2\2\u0195\u0197"+
		"\7 \2\2\u0196\u0195\3\2\2\2\u0196\u0197\3\2\2\2\u0197\u019c\3\2\2\2\u0198"+
		"\u0199\78\2\2\u0199\u019b\7 \2\2\u019a\u0198\3\2\2\2\u019b\u019e\3\2\2"+
		"\2\u019c\u019a\3\2\2\2\u019c\u019d\3\2\2\2\u019d\u019f\3\2\2\2\u019e\u019c"+
		"\3\2\2\2\u019f\u01a0\5D#\2\u01a0U\3\2\2\2\u01a1\u01a2\7$\2\2\u01a2W\3"+
		"\2\2\2+^`hpr{\u0082\u0089\u008b\u0090\u009f\u00a1\u00ae\u00b0\u00be\u00c3"+
		"\u00ce\u00d7\u00e1\u00e7\u00f6\u00ff\u0101\u010e\u0113\u011d\u0126\u012f"+
		"\u013e\u0144\u014d\u0159\u015d\u0161\u016c\u017e\u0184\u018a\u0190\u0196"+
		"\u019c";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}