// Generated from C:\Users\EUGENIO CARVALHO\Desktop\projects\Ivannosys\src\grammar\IvannosysGrammar.g4 by ANTLR 4.2.2
package grammar;

    import java.util.HashMap;
    import java.util.Stack;

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 IvannosysGrammarParser extends Parser {
	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		R_BIT_AND=1, R_BIT_XOR=2, R_BIT_OR=3, R_SHIFT_LEFT=4, R_SHIFT_RIGHT=5, 
		R_AT=6, R_DBL_SLASH=7, R_REFERENCE=8, R_INTERFACE=9, R_RANGE=10, R_STRUCT=11, 
		R_OP_MOD=12, R_VAR=13, R_SHORT_VAR=14, R_GOTO=15, R_FALLTHROUGH=16, R_MAP=17, 
		R_ERROR=18, R_NEW=19, R_DELETE=20, R_TRY=21, R_CATCH=22, R_FINALLY=23, 
		R_DEFAULT=24, R_IMPORTE=25, R_PACKAGE=26, R_TRAP=27, R_INT=28, R_CHAR=29, 
		R_BOOL=30, R_STRING=31, R_TIPO=32, R_FUNCTION=33, R_CONSTANTE=34, R_IN=35, 
		R_SWITCH=36, R_CASE=37, R_FOR=38, R_RETURN=39, R_CONTINUE=40, R_BREAK=41, 
		R_THROW=42, R_ELSE=43, R_IF=44, R_EXCLAMATION=45, R_PT_VIRG=46, R_PAR_E=47, 
		R_PAR_D=48, R_COL_E=49, R_COL_D=50, R_CHA_E=51, R_CHA_D=52, R_EQ=53, R_VIRGULA=54, 
		R_PONTO=55, R_COLON=56, R_END=57, R_AND=58, R_OR=59, R_COMP_EQ=60, R_COMP_DIFF=61, 
		R_COMP_LTE=62, R_COMP_LT=63, R_COMP_GTE=64, R_COMP_GT=65, R_ASSIG_EXTEND=66, 
		R_ASSIG_COPY=67, R_OP_DIV=68, R_OP_ADD=69, R_OP_SUB=70, R_OP_AST=71, R_OP_NEG=72, 
		R_OP_SS=73, R_OP_PP=74, R_UND=75, R_INTERROGATION=76, T_CHAR=77, T_STRING=78, 
		T_BOOL_TRUE=79, T_BOOL_FALSE=80, T_NULL=81, ID=82, T_INTEIRO=83, R_LIT_STRING=84, 
		R_LINE_COMMENT=85, R_WS=86, R_COMMENT=87;
	public static final String[] tokenNames = {
		"<INVALID>", "R_BIT_AND", "'^'", "'|'", "'<<'", "'>>'", "'@'", "'//'", 
		"R_REFERENCE", "'interface'", "'range'", "'struct'", "'%'", "'var'", "':='", 
		"'goto'", "'fallthrough'", "'map'", "'error'", "'new'", "'delete'", "'try'", 
		"'catch'", "'finally'", "'default'", "'import'", "'package'", "'trap'", 
		"'int'", "'char'", "'bool'", "'string'", "'type'", "'func'", "'const'", 
		"'in'", "'switch'", "'case'", "'for'", "'return'", "'continue'", "'break'", 
		"'throw'", "'else'", "'if'", "R_EXCLAMATION", "';'", "'('", "')'", "'{'", 
		"'}'", "'['", "']'", "'='", "','", "'.'", "R_COLON", "R_END", "'&&'", 
		"'||'", "'=='", "'!='", "'<='", "'<'", "'>='", "'>'", "'::'", "R_ASSIG_COPY", 
		"'/'", "'+'", "'-'", "'*'", "R_OP_NEG", "'--'", "'++'", "'_'", "'?'", 
		"T_CHAR", "T_STRING", "'true'", "'false'", "'nil'", "ID", "T_INTEIRO", 
		"R_LIT_STRING", "R_LINE_COMMENT", "R_WS", "R_COMMENT"
	};
	public static final int
		RULE_init = 0, RULE_imports = 1, RULE_import_part = 2, RULE_programPart = 3, 
		RULE_def_type = 4, RULE_def_interface = 5, RULE_func_spec = 6, RULE_dec_var = 7, 
		RULE_dec_var_part = 8, RULE_dec_var_short = 9, RULE_id_list = 10, RULE_def_assign_op = 11, 
		RULE_assign_modify = 12, RULE_index = 13, RULE_arguments = 14, RULE_expression_list_typed = 15, 
		RULE_dec_const = 16, RULE_dec_const_part = 17, RULE_def_function = 18, 
		RULE_return_dec = 19, RULE_receive_type = 20, RULE_def_switch = 21, RULE_def_case = 22, 
		RULE_statement_list = 23, RULE_primitive_value = 24, RULE_def_if = 25, 
		RULE_def_if_block = 26, RULE_def_for = 27, RULE_for_clause = 28, RULE_initialization = 29, 
		RULE_empty_block = 30, RULE_test = 31, RULE_increment = 32, RULE_for_each = 33, 
		RULE_range = 34, RULE_return_stmt = 35, RULE_expression_list = 36, RULE_expression = 37, 
		RULE_unary_expr = 38, RULE_primary_expr = 39, RULE_operand = 40, RULE_literal = 41, 
		RULE_base_stmt = 42, RULE_func_literal = 43, RULE_composite = 44, RULE_literalType = 45, 
		RULE_structType = 46, RULE_fieldDecl = 47, RULE_anon_field = 48, RULE_arrayType = 49, 
		RULE_inc_dec = 50, RULE_literal_value = 51, RULE_element_list = 52, RULE_keyed_element = 53, 
		RULE_expression_seletor = 54, RULE_def_block = 55, RULE_callExpr = 56, 
		RULE_statement = 57, RULE_fallthroughStmt = 58, RULE_label_stmt = 59, 
		RULE_throwStmt = 60, RULE_try_catch = 61, RULE_catch_exception = 62, RULE_finally_try = 63, 
		RULE_flux_control = 64, RULE_newstmt = 65, RULE_delete = 66, RULE_type = 67, 
		RULE_indexedType = 68, RULE_typename = 69, RULE_qualifiedId = 70, RULE_baseType = 71, 
		RULE_mapType = 72, RULE_buildtags = 73, RULE_build_stmt = 74, RULE_buildvalue = 75;
	public static final String[] ruleNames = {
		"init", "imports", "import_part", "programPart", "def_type", "def_interface", 
		"func_spec", "dec_var", "dec_var_part", "dec_var_short", "id_list", "def_assign_op", 
		"assign_modify", "index", "arguments", "expression_list_typed", "dec_const", 
		"dec_const_part", "def_function", "return_dec", "receive_type", "def_switch", 
		"def_case", "statement_list", "primitive_value", "def_if", "def_if_block", 
		"def_for", "for_clause", "initialization", "empty_block", "test", "increment", 
		"for_each", "range", "return_stmt", "expression_list", "expression", "unary_expr", 
		"primary_expr", "operand", "literal", "base_stmt", "func_literal", "composite", 
		"literalType", "structType", "fieldDecl", "anon_field", "arrayType", "inc_dec", 
		"literal_value", "element_list", "keyed_element", "expression_seletor", 
		"def_block", "callExpr", "statement", "fallthroughStmt", "label_stmt", 
		"throwStmt", "try_catch", "catch_exception", "finally_try", "flux_control", 
		"newstmt", "delete", "type", "indexedType", "typename", "qualifiedId", 
		"baseType", "mapType", "buildtags", "build_stmt", "buildvalue"
	};

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

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

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

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

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


	     HashMap<String, String> decfunc = new HashMap<>();    
	     HashMap<String, String> decmet = new HashMap<>();    
	     HashMap<String, String> decvars = new HashMap<>();
	     HashMap<String, String> operandos;
	     HashMap<String, String> boolExpr;
	     String travaOperandos = null;

	public IvannosysGrammarParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class InitContext extends ParserRuleContext {
		public ProgramPartContext programPart(int i) {
			return getRuleContext(ProgramPartContext.class,i);
		}
		public TerminalNode EOF() { return getToken(IvannosysGrammarParser.EOF, 0); }
		public List<ImportsContext> imports() {
			return getRuleContexts(ImportsContext.class);
		}
		public BuildtagsContext buildtags() {
			return getRuleContext(BuildtagsContext.class,0);
		}
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public List<ProgramPartContext> programPart() {
			return getRuleContexts(ProgramPartContext.class);
		}
		public TerminalNode R_PACKAGE() { return getToken(IvannosysGrammarParser.R_PACKAGE, 0); }
		public TerminalNode R_PT_VIRG() { return getToken(IvannosysGrammarParser.R_PT_VIRG, 0); }
		public ImportsContext imports(int i) {
			return getRuleContext(ImportsContext.class,i);
		}
		public InitContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_init; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterInit(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitInit(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitInit(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InitContext init() throws RecognitionException {
		InitContext _localctx = new InitContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_init);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(153);
			_la = _input.LA(1);
			if (_la==R_AT) {
				{
				setState(152); buildtags();
				}
			}

			setState(155); match(R_PACKAGE);
			setState(156); match(ID);
			setState(157); match(R_PT_VIRG);
			setState(161);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==R_IMPORTE) {
				{
				{
				setState(158); imports();
				}
				}
				setState(163);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(165); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(164); programPart();
				}
				}
				setState(167); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << R_VAR) | (1L << R_TIPO) | (1L << R_FUNCTION) | (1L << R_CONSTANTE))) != 0) );
			setState(169); match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ImportsContext extends ParserRuleContext {
		public Import_partContext import_part(int i) {
			return getRuleContext(Import_partContext.class,i);
		}
		public TerminalNode R_IMPORTE() { return getToken(IvannosysGrammarParser.R_IMPORTE, 0); }
		public TerminalNode R_PAR_D() { return getToken(IvannosysGrammarParser.R_PAR_D, 0); }
		public TerminalNode R_PAR_E() { return getToken(IvannosysGrammarParser.R_PAR_E, 0); }
		public List<Import_partContext> import_part() {
			return getRuleContexts(Import_partContext.class);
		}
		public ImportsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_imports; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterImports(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitImports(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitImports(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ImportsContext imports() throws RecognitionException {
		ImportsContext _localctx = new ImportsContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_imports);
		int _la;
		try {
			setState(184);
			switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(171); match(R_IMPORTE);
				setState(172); match(R_PAR_E);
				setState(173); import_part();
				setState(177);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T_STRING || _la==ID) {
					{
					{
					setState(174); import_part();
					}
					}
					setState(179);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(180); match(R_PAR_D);
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(182); match(R_IMPORTE);
				setState(183); import_part();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Import_partContext extends ParserRuleContext {
		public TerminalNode T_STRING() { return getToken(IvannosysGrammarParser.T_STRING, 0); }
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public Import_partContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_import_part; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterImport_part(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitImport_part(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitImport_part(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Import_partContext import_part() throws RecognitionException {
		Import_partContext _localctx = new Import_partContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_import_part);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(187);
			_la = _input.LA(1);
			if (_la==ID) {
				{
				setState(186); match(ID);
				}
			}

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

	public static class ProgramPartContext extends ParserRuleContext {
		public Def_interfaceContext def_interface() {
			return getRuleContext(Def_interfaceContext.class,0);
		}
		public Def_typeContext def_type() {
			return getRuleContext(Def_typeContext.class,0);
		}
		public Def_functionContext def_function() {
			return getRuleContext(Def_functionContext.class,0);
		}
		public Dec_varContext dec_var() {
			return getRuleContext(Dec_varContext.class,0);
		}
		public Dec_constContext dec_const() {
			return getRuleContext(Dec_constContext.class,0);
		}
		public ProgramPartContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_programPart; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterProgramPart(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitProgramPart(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitProgramPart(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ProgramPartContext programPart() throws RecognitionException {
		ProgramPartContext _localctx = new ProgramPartContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_programPart);
		try {
			setState(196);
			switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(191); dec_const();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(192); dec_var();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(193); def_type();
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(194); def_interface();
				}
				break;

			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(195); def_function();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Def_typeContext extends ParserRuleContext {
		public StructTypeContext structType() {
			return getRuleContext(StructTypeContext.class,0);
		}
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TerminalNode R_TIPO() { return getToken(IvannosysGrammarParser.R_TIPO, 0); }
		public Def_typeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_def_type; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDef_type(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDef_type(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDef_type(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Def_typeContext def_type() throws RecognitionException {
		Def_typeContext _localctx = new Def_typeContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_def_type);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(198); match(R_TIPO);
			setState(199); match(ID);
			setState(202);
			switch (_input.LA(1)) {
			case R_STRUCT:
				{
				setState(200); structType();
				}
				break;
			case R_MAP:
			case R_ERROR:
			case R_INT:
			case R_CHAR:
			case R_BOOL:
			case R_STRING:
			case R_CHA_E:
			case R_OP_AST:
			case ID:
				{
				setState(201); type();
				}
				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 Def_interfaceContext extends ParserRuleContext {
		public TerminalNode R_COL_E() { return getToken(IvannosysGrammarParser.R_COL_E, 0); }
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public TerminalNode R_INTERFACE() { return getToken(IvannosysGrammarParser.R_INTERFACE, 0); }
		public TerminalNode R_TIPO() { return getToken(IvannosysGrammarParser.R_TIPO, 0); }
		public Func_specContext func_spec(int i) {
			return getRuleContext(Func_specContext.class,i);
		}
		public List<Func_specContext> func_spec() {
			return getRuleContexts(Func_specContext.class);
		}
		public TerminalNode R_COL_D() { return getToken(IvannosysGrammarParser.R_COL_D, 0); }
		public Def_interfaceContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_def_interface; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDef_interface(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDef_interface(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDef_interface(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Def_interfaceContext def_interface() throws RecognitionException {
		Def_interfaceContext _localctx = new Def_interfaceContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_def_interface);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(204); match(R_TIPO);
			setState(205); match(ID);
			setState(206); match(R_INTERFACE);
			setState(207); match(R_COL_E);
			setState(209); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(208); func_spec();
				}
				}
				setState(211); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==ID );
			setState(213); match(R_COL_D);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Func_specContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public ArgumentsContext arguments() {
			return getRuleContext(ArgumentsContext.class,0);
		}
		public Return_decContext return_dec() {
			return getRuleContext(Return_decContext.class,0);
		}
		public Func_specContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_func_spec; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterFunc_spec(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitFunc_spec(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitFunc_spec(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Func_specContext func_spec() throws RecognitionException {
		Func_specContext _localctx = new Func_specContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_func_spec);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(215); match(ID);
			setState(216); arguments();
			setState(217); return_dec();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Dec_varContext extends ParserRuleContext {
		public TerminalNode R_PAR_D() { return getToken(IvannosysGrammarParser.R_PAR_D, 0); }
		public TerminalNode R_PAR_E() { return getToken(IvannosysGrammarParser.R_PAR_E, 0); }
		public Dec_var_partContext dec_var_part(int i) {
			return getRuleContext(Dec_var_partContext.class,i);
		}
		public List<Dec_var_partContext> dec_var_part() {
			return getRuleContexts(Dec_var_partContext.class);
		}
		public TerminalNode R_VAR() { return getToken(IvannosysGrammarParser.R_VAR, 0); }
		public Dec_varContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dec_var; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDec_var(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDec_var(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDec_var(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Dec_varContext dec_var() throws RecognitionException {
		Dec_varContext _localctx = new Dec_varContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_dec_var);
		int _la;
		try {
			setState(230);
			switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(219); match(R_VAR);
				setState(220); match(R_PAR_E);
				setState(222); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(221); dec_var_part();
					}
					}
					setState(224); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==ID );
				setState(226); match(R_PAR_D);
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(228); match(R_VAR);
				setState(229); dec_var_part();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Dec_var_partContext extends ParserRuleContext {
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public Id_listContext id_list() {
			return getRuleContext(Id_listContext.class,0);
		}
		public Expression_listContext expression_list() {
			return getRuleContext(Expression_listContext.class,0);
		}
		public TerminalNode R_EQ() { return getToken(IvannosysGrammarParser.R_EQ, 0); }
		public Dec_var_partContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dec_var_part; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDec_var_part(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDec_var_part(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDec_var_part(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Dec_var_partContext dec_var_part() throws RecognitionException {
		Dec_var_partContext _localctx = new Dec_var_partContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_dec_var_part);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(232); id_list();
			setState(240);
			switch (_input.LA(1)) {
			case R_MAP:
			case R_ERROR:
			case R_INT:
			case R_CHAR:
			case R_BOOL:
			case R_STRING:
			case R_CHA_E:
			case R_OP_AST:
			case ID:
				{
				setState(233); type();
				setState(236);
				_la = _input.LA(1);
				if (_la==R_EQ) {
					{
					setState(234); match(R_EQ);
					setState(235); expression_list();
					}
				}

				}
				break;
			case R_EQ:
				{
				setState(238); match(R_EQ);
				setState(239); expression_list();
				}
				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 Dec_var_shortContext extends ParserRuleContext {
		public TerminalNode R_SHORT_VAR() { return getToken(IvannosysGrammarParser.R_SHORT_VAR, 0); }
		public Id_listContext id_list() {
			return getRuleContext(Id_listContext.class,0);
		}
		public Expression_listContext expression_list() {
			return getRuleContext(Expression_listContext.class,0);
		}
		public Dec_var_shortContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dec_var_short; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDec_var_short(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDec_var_short(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDec_var_short(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Dec_var_shortContext dec_var_short() throws RecognitionException {
		Dec_var_shortContext _localctx = new Dec_var_shortContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_dec_var_short);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(242); id_list();
			setState(243); match(R_SHORT_VAR);
			setState(244); expression_list();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Id_listContext extends ParserRuleContext {
		public List<TerminalNode> R_VIRGULA() { return getTokens(IvannosysGrammarParser.R_VIRGULA); }
		public List<TerminalNode> ID() { return getTokens(IvannosysGrammarParser.ID); }
		public TerminalNode R_VIRGULA(int i) {
			return getToken(IvannosysGrammarParser.R_VIRGULA, i);
		}
		public TerminalNode ID(int i) {
			return getToken(IvannosysGrammarParser.ID, i);
		}
		public Id_listContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_id_list; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterId_list(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitId_list(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitId_list(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Id_listContext id_list() throws RecognitionException {
		Id_listContext _localctx = new Id_listContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_id_list);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(246); match(ID);
			setState(251);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==R_VIRGULA) {
				{
				{
				setState(247); match(R_VIRGULA);
				setState(248); match(ID);
				}
				}
				setState(253);
				_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 Def_assign_opContext extends ParserRuleContext {
		public Assign_modifyContext assign_modify() {
			return getRuleContext(Assign_modifyContext.class,0);
		}
		public List<Expression_listContext> expression_list() {
			return getRuleContexts(Expression_listContext.class);
		}
		public TerminalNode R_EQ() { return getToken(IvannosysGrammarParser.R_EQ, 0); }
		public Expression_listContext expression_list(int i) {
			return getRuleContext(Expression_listContext.class,i);
		}
		public Def_assign_opContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_def_assign_op; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDef_assign_op(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDef_assign_op(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDef_assign_op(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Def_assign_opContext def_assign_op() throws RecognitionException {
		Def_assign_opContext _localctx = new Def_assign_opContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_def_assign_op);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(254); expression_list();
			setState(256);
			_la = _input.LA(1);
			if (((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (R_ASSIG_EXTEND - 66)) | (1L << (R_ASSIG_COPY - 66)) | (1L << (R_OP_DIV - 66)) | (1L << (R_OP_ADD - 66)) | (1L << (R_OP_SUB - 66)) | (1L << (R_OP_AST - 66)))) != 0)) {
				{
				setState(255); assign_modify();
				}
			}

			setState(258); match(R_EQ);
			setState(259); expression_list();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Assign_modifyContext extends ParserRuleContext {
		public TerminalNode R_OP_SUB() { return getToken(IvannosysGrammarParser.R_OP_SUB, 0); }
		public TerminalNode R_ASSIG_COPY() { return getToken(IvannosysGrammarParser.R_ASSIG_COPY, 0); }
		public TerminalNode R_OP_AST() { return getToken(IvannosysGrammarParser.R_OP_AST, 0); }
		public TerminalNode R_OP_DIV() { return getToken(IvannosysGrammarParser.R_OP_DIV, 0); }
		public TerminalNode R_OP_ADD() { return getToken(IvannosysGrammarParser.R_OP_ADD, 0); }
		public TerminalNode R_ASSIG_EXTEND() { return getToken(IvannosysGrammarParser.R_ASSIG_EXTEND, 0); }
		public Assign_modifyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_assign_modify; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterAssign_modify(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitAssign_modify(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitAssign_modify(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Assign_modifyContext assign_modify() throws RecognitionException {
		Assign_modifyContext _localctx = new Assign_modifyContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_assign_modify);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(261);
			_la = _input.LA(1);
			if ( !(((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (R_ASSIG_EXTEND - 66)) | (1L << (R_ASSIG_COPY - 66)) | (1L << (R_OP_DIV - 66)) | (1L << (R_OP_ADD - 66)) | (1L << (R_OP_SUB - 66)) | (1L << (R_OP_AST - 66)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IndexContext extends ParserRuleContext {
		public TerminalNode R_CHA_D() { return getToken(IvannosysGrammarParser.R_CHA_D, 0); }
		public TerminalNode R_CHA_E() { return getToken(IvannosysGrammarParser.R_CHA_E, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public IndexContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_index; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterIndex(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitIndex(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitIndex(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IndexContext index() throws RecognitionException {
		IndexContext _localctx = new IndexContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_index);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(263); match(R_CHA_E);
			setState(264); expression(0);
			setState(265); match(R_CHA_D);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArgumentsContext extends ParserRuleContext {
		public List<TerminalNode> R_VIRGULA() { return getTokens(IvannosysGrammarParser.R_VIRGULA); }
		public TerminalNode R_PAR_D() { return getToken(IvannosysGrammarParser.R_PAR_D, 0); }
		public TerminalNode R_PAR_E() { return getToken(IvannosysGrammarParser.R_PAR_E, 0); }
		public TerminalNode R_VIRGULA(int i) {
			return getToken(IvannosysGrammarParser.R_VIRGULA, i);
		}
		public Expression_list_typedContext expression_list_typed(int i) {
			return getRuleContext(Expression_list_typedContext.class,i);
		}
		public Expression_listContext expression_list() {
			return getRuleContext(Expression_listContext.class,0);
		}
		public List<Expression_list_typedContext> expression_list_typed() {
			return getRuleContexts(Expression_list_typedContext.class);
		}
		public ArgumentsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arguments; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterArguments(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitArguments(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitArguments(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ArgumentsContext arguments() throws RecognitionException {
		ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_arguments);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(267); match(R_PAR_E);
			setState(277);
			switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
			case 1:
				{
				setState(268); expression_list();
				}
				break;

			case 2:
				{
				setState(269); expression_list_typed();
				setState(274);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==R_VIRGULA) {
					{
					{
					setState(270); match(R_VIRGULA);
					setState(271); expression_list_typed();
					}
					}
					setState(276);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			}
			setState(279); match(R_PAR_D);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expression_list_typedContext extends ParserRuleContext {
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public Id_listContext id_list() {
			return getRuleContext(Id_listContext.class,0);
		}
		public Expression_list_typedContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression_list_typed; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterExpression_list_typed(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitExpression_list_typed(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitExpression_list_typed(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expression_list_typedContext expression_list_typed() throws RecognitionException {
		Expression_list_typedContext _localctx = new Expression_list_typedContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_expression_list_typed);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(282);
			switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
			case 1:
				{
				setState(281); id_list();
				}
				break;
			}
			setState(284); type();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Dec_constContext extends ParserRuleContext {
		public Dec_const_partContext dec_const_part(int i) {
			return getRuleContext(Dec_const_partContext.class,i);
		}
		public TerminalNode R_PAR_D() { return getToken(IvannosysGrammarParser.R_PAR_D, 0); }
		public TerminalNode R_PAR_E() { return getToken(IvannosysGrammarParser.R_PAR_E, 0); }
		public List<Dec_const_partContext> dec_const_part() {
			return getRuleContexts(Dec_const_partContext.class);
		}
		public TerminalNode R_CONSTANTE() { return getToken(IvannosysGrammarParser.R_CONSTANTE, 0); }
		public Dec_constContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dec_const; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDec_const(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDec_const(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDec_const(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Dec_constContext dec_const() throws RecognitionException {
		Dec_constContext _localctx = new Dec_constContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_dec_const);
		int _la;
		try {
			setState(299);
			switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(286); match(R_CONSTANTE);
				setState(287); dec_const_part();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(288); match(R_CONSTANTE);
				setState(289); match(R_PAR_E);
				setState(290); dec_const_part();
				setState(294);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==ID) {
					{
					{
					setState(291); dec_const_part();
					}
					}
					setState(296);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(297); match(R_PAR_D);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Dec_const_partContext extends ParserRuleContext {
		public Primitive_valueContext primitive_value() {
			return getRuleContext(Primitive_valueContext.class,0);
		}
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TerminalNode R_EQ() { return getToken(IvannosysGrammarParser.R_EQ, 0); }
		public Dec_const_partContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dec_const_part; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDec_const_part(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDec_const_part(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDec_const_part(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Dec_const_partContext dec_const_part() throws RecognitionException {
		Dec_const_partContext _localctx = new Dec_const_partContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_dec_const_part);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(301); match(ID);
			setState(303);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << R_MAP) | (1L << R_ERROR) | (1L << R_INT) | (1L << R_CHAR) | (1L << R_BOOL) | (1L << R_STRING) | (1L << R_CHA_E))) != 0) || _la==R_OP_AST || _la==ID) {
				{
				setState(302); type();
				}
			}

			setState(305); match(R_EQ);
			setState(306); primitive_value();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Def_functionContext extends ParserRuleContext {
		public Token name;
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public Def_blockContext def_block() {
			return getRuleContext(Def_blockContext.class,0);
		}
		public TerminalNode R_FUNCTION() { return getToken(IvannosysGrammarParser.R_FUNCTION, 0); }
		public ArgumentsContext arguments() {
			return getRuleContext(ArgumentsContext.class,0);
		}
		public Return_decContext return_dec() {
			return getRuleContext(Return_decContext.class,0);
		}
		public Receive_typeContext receive_type() {
			return getRuleContext(Receive_typeContext.class,0);
		}
		public Def_functionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_def_function; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDef_function(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDef_function(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDef_function(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Def_functionContext def_function() throws RecognitionException {
		Def_functionContext _localctx = new Def_functionContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_def_function);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(308); match(R_FUNCTION);
			setState(310);
			switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
			case 1:
				{
				setState(309); receive_type();
				}
				break;
			}
			setState(313);
			_la = _input.LA(1);
			if (_la==ID) {
				{
				setState(312); ((Def_functionContext)_localctx).name = match(ID);
				}
			}

			setState(315); arguments();
			setState(317);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << R_MAP) | (1L << R_ERROR) | (1L << R_INT) | (1L << R_CHAR) | (1L << R_BOOL) | (1L << R_STRING) | (1L << R_CHA_E))) != 0) || _la==R_OP_AST || _la==ID) {
				{
				setState(316); return_dec();
				}
			}

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

	public static class Return_decContext extends ParserRuleContext {
		public List<TerminalNode> R_VIRGULA() { return getTokens(IvannosysGrammarParser.R_VIRGULA); }
		public TerminalNode R_VIRGULA(int i) {
			return getToken(IvannosysGrammarParser.R_VIRGULA, i);
		}
		public TypeContext type(int i) {
			return getRuleContext(TypeContext.class,i);
		}
		public List<TypeContext> type() {
			return getRuleContexts(TypeContext.class);
		}
		public Return_decContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_return_dec; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterReturn_dec(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitReturn_dec(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitReturn_dec(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Return_decContext return_dec() throws RecognitionException {
		Return_decContext _localctx = new Return_decContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_return_dec);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(321); type();
			setState(326);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==R_VIRGULA) {
				{
				{
				setState(322); match(R_VIRGULA);
				setState(323); type();
				}
				}
				setState(328);
				_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 Receive_typeContext extends ParserRuleContext {
		public TerminalNode R_OP_AST() { return getToken(IvannosysGrammarParser.R_OP_AST, 0); }
		public TerminalNode R_PAR_D() { return getToken(IvannosysGrammarParser.R_PAR_D, 0); }
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public TerminalNode R_PAR_E() { return getToken(IvannosysGrammarParser.R_PAR_E, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public Receive_typeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_receive_type; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterReceive_type(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitReceive_type(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitReceive_type(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Receive_typeContext receive_type() throws RecognitionException {
		Receive_typeContext _localctx = new Receive_typeContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_receive_type);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(329); match(R_PAR_E);
			setState(330); match(ID);
			setState(332);
			switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
			case 1:
				{
				setState(331); match(R_OP_AST);
				}
				break;
			}
			setState(334); type();
			setState(335); match(R_PAR_D);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Def_switchContext extends ParserRuleContext {
		public TerminalNode R_COL_E() { return getToken(IvannosysGrammarParser.R_COL_E, 0); }
		public TerminalNode R_SWITCH() { return getToken(IvannosysGrammarParser.R_SWITCH, 0); }
		public Def_caseContext def_case(int i) {
			return getRuleContext(Def_caseContext.class,i);
		}
		public List<Def_caseContext> def_case() {
			return getRuleContexts(Def_caseContext.class);
		}
		public TestContext test() {
			return getRuleContext(TestContext.class,0);
		}
		public TerminalNode R_COL_D() { return getToken(IvannosysGrammarParser.R_COL_D, 0); }
		public Def_switchContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_def_switch; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDef_switch(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDef_switch(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDef_switch(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Def_switchContext def_switch() throws RecognitionException {
		Def_switchContext _localctx = new Def_switchContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_def_switch);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(337); match(R_SWITCH);
			setState(338); test();
			setState(339); match(R_COL_E);
			setState(341); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(340); def_case();
				}
				}
				setState(343); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==R_DEFAULT || _la==R_CASE );
			setState(345); match(R_COL_D);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Def_caseContext extends ParserRuleContext {
		public TerminalNode R_CASE() { return getToken(IvannosysGrammarParser.R_CASE, 0); }
		public TerminalNode R_COLON() { return getToken(IvannosysGrammarParser.R_COLON, 0); }
		public TerminalNode R_BREAK() { return getToken(IvannosysGrammarParser.R_BREAK, 0); }
		public Expression_listContext expression_list() {
			return getRuleContext(Expression_listContext.class,0);
		}
		public Statement_listContext statement_list() {
			return getRuleContext(Statement_listContext.class,0);
		}
		public TerminalNode R_DEFAULT() { return getToken(IvannosysGrammarParser.R_DEFAULT, 0); }
		public Def_caseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_def_case; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDef_case(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDef_case(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDef_case(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Def_caseContext def_case() throws RecognitionException {
		Def_caseContext _localctx = new Def_caseContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_def_case);
		int _la;
		try {
			setState(357);
			switch (_input.LA(1)) {
			case R_CASE:
				enterOuterAlt(_localctx, 1);
				{
				setState(347); match(R_CASE);
				setState(348); expression_list();
				setState(349); match(R_COLON);
				setState(350); statement_list();
				setState(352);
				_la = _input.LA(1);
				if (_la==R_BREAK) {
					{
					setState(351); match(R_BREAK);
					}
				}

				}
				break;
			case R_DEFAULT:
				enterOuterAlt(_localctx, 2);
				{
				setState(354); match(R_DEFAULT);
				setState(355); match(R_COLON);
				setState(356); statement_list();
				}
				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 Statement_listContext extends ParserRuleContext {
		public List<StatementContext> statement() {
			return getRuleContexts(StatementContext.class);
		}
		public StatementContext statement(int i) {
			return getRuleContext(StatementContext.class,i);
		}
		public Statement_listContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_statement_list; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterStatement_list(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitStatement_list(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitStatement_list(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Statement_listContext statement_list() throws RecognitionException {
		Statement_listContext _localctx = new Statement_listContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_statement_list);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(360); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(359); statement();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(362); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
			} while ( _alt!=2 && _alt!=ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Primitive_valueContext extends ParserRuleContext {
		public TerminalNode T_BOOL_FALSE() { return getToken(IvannosysGrammarParser.T_BOOL_FALSE, 0); }
		public TerminalNode T_INTEIRO() { return getToken(IvannosysGrammarParser.T_INTEIRO, 0); }
		public TerminalNode T_CHAR() { return getToken(IvannosysGrammarParser.T_CHAR, 0); }
		public TerminalNode T_BOOL_TRUE() { return getToken(IvannosysGrammarParser.T_BOOL_TRUE, 0); }
		public Primitive_valueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_primitive_value; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterPrimitive_value(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitPrimitive_value(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitPrimitive_value(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Primitive_valueContext primitive_value() throws RecognitionException {
		Primitive_valueContext _localctx = new Primitive_valueContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_primitive_value);
		int _la;
		try {
			setState(367);
			switch (_input.LA(1)) {
			case T_INTEIRO:
				enterOuterAlt(_localctx, 1);
				{
				setState(364); match(T_INTEIRO);
				}
				break;
			case T_BOOL_TRUE:
			case T_BOOL_FALSE:
				enterOuterAlt(_localctx, 2);
				{
				setState(365);
				_la = _input.LA(1);
				if ( !(_la==T_BOOL_TRUE || _la==T_BOOL_FALSE) ) {
				_errHandler.recoverInline(this);
				}
				consume();
				}
				break;
			case T_CHAR:
				enterOuterAlt(_localctx, 3);
				{
				setState(366); match(T_CHAR);
				}
				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 Def_ifContext extends ParserRuleContext {
		public int ltipo;
		public List<TerminalNode> R_ELSE() { return getTokens(IvannosysGrammarParser.R_ELSE); }
		public Def_blockContext def_block() {
			return getRuleContext(Def_blockContext.class,0);
		}
		public TerminalNode R_ELSE(int i) {
			return getToken(IvannosysGrammarParser.R_ELSE, i);
		}
		public List<Def_if_blockContext> def_if_block() {
			return getRuleContexts(Def_if_blockContext.class);
		}
		public Def_if_blockContext def_if_block(int i) {
			return getRuleContext(Def_if_blockContext.class,i);
		}
		public Def_ifContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_def_if; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDef_if(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDef_if(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDef_if(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Def_ifContext def_if() throws RecognitionException {
		Def_ifContext _localctx = new Def_ifContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_def_if);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(369); def_if_block();
			setState(374);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
			while ( _alt!=2 && _alt!=ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(370); match(R_ELSE);
					setState(371); def_if_block();
					}
					} 
				}
				setState(376);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
			}
			setState(379);
			_la = _input.LA(1);
			if (_la==R_ELSE) {
				{
				setState(377); match(R_ELSE);
				setState(378); def_block();
				}
			}

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

	public static class Def_if_blockContext extends ParserRuleContext {
		public Def_blockContext def_block() {
			return getRuleContext(Def_blockContext.class,0);
		}
		public TestContext test() {
			return getRuleContext(TestContext.class,0);
		}
		public TerminalNode R_IF() { return getToken(IvannosysGrammarParser.R_IF, 0); }
		public Def_if_blockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_def_if_block; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDef_if_block(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDef_if_block(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDef_if_block(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Def_if_blockContext def_if_block() throws RecognitionException {
		Def_if_blockContext _localctx = new Def_if_blockContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_def_if_block);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(381); match(R_IF);
			setState(382); test();
			setState(383); def_block();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Def_forContext extends ParserRuleContext {
		public TerminalNode R_FOR() { return getToken(IvannosysGrammarParser.R_FOR, 0); }
		public For_clauseContext for_clause() {
			return getRuleContext(For_clauseContext.class,0);
		}
		public TestContext test() {
			return getRuleContext(TestContext.class,0);
		}
		public Def_blockContext def_block() {
			return getRuleContext(Def_blockContext.class,0);
		}
		public For_eachContext for_each() {
			return getRuleContext(For_eachContext.class,0);
		}
		public Def_forContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_def_for; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDef_for(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDef_for(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDef_for(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Def_forContext def_for() throws RecognitionException {
		Def_forContext _localctx = new Def_forContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_def_for);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(385); match(R_FOR);
			setState(389);
			switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
			case 1:
				{
				setState(386); for_clause();
				}
				break;

			case 2:
				{
				setState(387); for_each();
				}
				break;

			case 3:
				{
				setState(388); test();
				}
				break;
			}
			setState(391); def_block();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class For_clauseContext extends ParserRuleContext {
		public TestContext test() {
			return getRuleContext(TestContext.class,0);
		}
		public IncrementContext increment() {
			return getRuleContext(IncrementContext.class,0);
		}
		public List<TerminalNode> R_PT_VIRG() { return getTokens(IvannosysGrammarParser.R_PT_VIRG); }
		public InitializationContext initialization() {
			return getRuleContext(InitializationContext.class,0);
		}
		public TerminalNode R_PT_VIRG(int i) {
			return getToken(IvannosysGrammarParser.R_PT_VIRG, i);
		}
		public For_clauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_for_clause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterFor_clause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitFor_clause(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitFor_clause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final For_clauseContext for_clause() throws RecognitionException {
		For_clauseContext _localctx = new For_clauseContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_for_clause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(396);
			switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
			case 1:
				{
				setState(393); initialization();
				setState(394); match(R_PT_VIRG);
				}
				break;
			}
			setState(398); test();
			setState(401);
			_la = _input.LA(1);
			if (_la==R_PT_VIRG) {
				{
				setState(399); match(R_PT_VIRG);
				setState(400); increment();
				}
			}

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

	public static class InitializationContext extends ParserRuleContext {
		public Base_stmtContext base_stmt() {
			return getRuleContext(Base_stmtContext.class,0);
		}
		public InitializationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_initialization; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterInitialization(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitInitialization(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitInitialization(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InitializationContext initialization() throws RecognitionException {
		InitializationContext _localctx = new InitializationContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_initialization);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(403); base_stmt();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Empty_blockContext extends ParserRuleContext {
		public TerminalNode R_COL_E() { return getToken(IvannosysGrammarParser.R_COL_E, 0); }
		public TerminalNode R_COL_D() { return getToken(IvannosysGrammarParser.R_COL_D, 0); }
		public Empty_blockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_empty_block; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterEmpty_block(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitEmpty_block(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitEmpty_block(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Empty_blockContext empty_block() throws RecognitionException {
		Empty_blockContext _localctx = new Empty_blockContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_empty_block);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(405); match(R_COL_E);
			setState(406); match(R_COL_D);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TestContext extends ParserRuleContext {
		public Base_stmtContext base_stmt() {
			return getRuleContext(Base_stmtContext.class,0);
		}
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode R_PT_VIRG() { return getToken(IvannosysGrammarParser.R_PT_VIRG, 0); }
		public TestContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_test; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterTest(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitTest(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitTest(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TestContext test() throws RecognitionException {
		TestContext _localctx = new TestContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_test);
		try {
			setState(414);
			switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(408); expression(0);
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(409); base_stmt();
				setState(412);
				switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
				case 1:
					{
					setState(410); match(R_PT_VIRG);
					setState(411); expression(0);
					}
					break;
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IncrementContext extends ParserRuleContext {
		public Base_stmtContext base_stmt() {
			return getRuleContext(Base_stmtContext.class,0);
		}
		public IncrementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_increment; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterIncrement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitIncrement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitIncrement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IncrementContext increment() throws RecognitionException {
		IncrementContext _localctx = new IncrementContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_increment);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(416); base_stmt();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class For_eachContext extends ParserRuleContext {
		public List<Primary_exprContext> primary_expr() {
			return getRuleContexts(Primary_exprContext.class);
		}
		public TerminalNode R_VIRGULA() { return getToken(IvannosysGrammarParser.R_VIRGULA, 0); }
		public TerminalNode R_SHORT_VAR() { return getToken(IvannosysGrammarParser.R_SHORT_VAR, 0); }
		public RangeContext range() {
			return getRuleContext(RangeContext.class,0);
		}
		public Primary_exprContext primary_expr(int i) {
			return getRuleContext(Primary_exprContext.class,i);
		}
		public TerminalNode R_RANGE() { return getToken(IvannosysGrammarParser.R_RANGE, 0); }
		public TerminalNode R_EQ() { return getToken(IvannosysGrammarParser.R_EQ, 0); }
		public For_eachContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_for_each; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterFor_each(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitFor_each(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitFor_each(this);
			else return visitor.visitChildren(this);
		}
	}

	public final For_eachContext for_each() throws RecognitionException {
		For_eachContext _localctx = new For_eachContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_for_each);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(418); primary_expr(0);
			setState(419); match(R_VIRGULA);
			setState(420); primary_expr(0);
			setState(421);
			_la = _input.LA(1);
			if ( !(_la==R_SHORT_VAR || _la==R_EQ) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			setState(422); match(R_RANGE);
			setState(423); range();
			}
		}
		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 ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,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 IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterRange(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitRange(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitRange(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RangeContext range() throws RecognitionException {
		RangeContext _localctx = new RangeContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_range);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(425); expression(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Return_stmtContext extends ParserRuleContext {
		public TerminalNode R_RETURN() { return getToken(IvannosysGrammarParser.R_RETURN, 0); }
		public Expression_listContext expression_list() {
			return getRuleContext(Expression_listContext.class,0);
		}
		public Return_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_return_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterReturn_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitReturn_stmt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitReturn_stmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Return_stmtContext return_stmt() throws RecognitionException {
		Return_stmtContext _localctx = new Return_stmtContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_return_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(427); match(R_RETURN);
			setState(429);
			switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
			case 1:
				{
				setState(428); expression_list();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expression_listContext extends ParserRuleContext {
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public List<TerminalNode> R_VIRGULA() { return getTokens(IvannosysGrammarParser.R_VIRGULA); }
		public TerminalNode R_VIRGULA(int i) {
			return getToken(IvannosysGrammarParser.R_VIRGULA, i);
		}
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public Expression_listContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression_list; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterExpression_list(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitExpression_list(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitExpression_list(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expression_listContext expression_list() throws RecognitionException {
		Expression_listContext _localctx = new Expression_listContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_expression_list);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(431); expression(0);
			setState(436);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,39,_ctx);
			while ( _alt!=2 && _alt!=ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(432); match(R_VIRGULA);
					setState(433); expression(0);
					}
					} 
				}
				setState(438);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,39,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExpressionContext extends ParserRuleContext {
		public Token op;
		public TerminalNode R_COMP_LTE() { return getToken(IvannosysGrammarParser.R_COMP_LTE, 0); }
		public TerminalNode R_END() { return getToken(IvannosysGrammarParser.R_END, 0); }
		public TerminalNode R_OP_SUB() { return getToken(IvannosysGrammarParser.R_OP_SUB, 0); }
		public TerminalNode R_BIT_OR() { return getToken(IvannosysGrammarParser.R_BIT_OR, 0); }
		public TerminalNode R_OP_AST() { return getToken(IvannosysGrammarParser.R_OP_AST, 0); }
		public TerminalNode R_AND() { return getToken(IvannosysGrammarParser.R_AND, 0); }
		public TerminalNode R_PAR_D() { return getToken(IvannosysGrammarParser.R_PAR_D, 0); }
		public TerminalNode R_SHIFT_RIGHT() { return getToken(IvannosysGrammarParser.R_SHIFT_RIGHT, 0); }
		public TerminalNode R_COMP_EQ() { return getToken(IvannosysGrammarParser.R_COMP_EQ, 0); }
		public TerminalNode R_BIT_AND() { return getToken(IvannosysGrammarParser.R_BIT_AND, 0); }
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public Unary_exprContext unary_expr() {
			return getRuleContext(Unary_exprContext.class,0);
		}
		public TerminalNode R_OP_MOD() { return getToken(IvannosysGrammarParser.R_OP_MOD, 0); }
		public TerminalNode R_BIT_XOR() { return getToken(IvannosysGrammarParser.R_BIT_XOR, 0); }
		public TerminalNode R_SHIFT_LEFT() { return getToken(IvannosysGrammarParser.R_SHIFT_LEFT, 0); }
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode R_COMP_GTE() { return getToken(IvannosysGrammarParser.R_COMP_GTE, 0); }
		public TerminalNode R_COMP_DIFF() { return getToken(IvannosysGrammarParser.R_COMP_DIFF, 0); }
		public TerminalNode R_PAR_E() { return getToken(IvannosysGrammarParser.R_PAR_E, 0); }
		public TerminalNode R_OP_DIV() { return getToken(IvannosysGrammarParser.R_OP_DIV, 0); }
		public TerminalNode R_OP_ADD() { return getToken(IvannosysGrammarParser.R_OP_ADD, 0); }
		public TerminalNode R_COMP_GT() { return getToken(IvannosysGrammarParser.R_COMP_GT, 0); }
		public TerminalNode R_OR() { return getToken(IvannosysGrammarParser.R_OR, 0); }
		public TerminalNode R_COMP_LT() { return getToken(IvannosysGrammarParser.R_COMP_LT, 0); }
		public ExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionContext expression() throws RecognitionException {
		return expression(0);
	}

	private ExpressionContext expression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
		ExpressionContext _prevctx = _localctx;
		int _startState = 74;
		enterRecursionRule(_localctx, 74, RULE_expression, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(445);
			switch (_input.LA(1)) {
			case R_PAR_E:
				{
				setState(440); match(R_PAR_E);
				setState(441); expression(0);
				setState(442); match(R_PAR_D);
				}
				break;
			case R_REFERENCE:
			case R_STRUCT:
			case R_ERROR:
			case R_INT:
			case R_CHAR:
			case R_BOOL:
			case R_STRING:
			case R_FUNCTION:
			case R_EXCLAMATION:
			case R_CHA_E:
			case R_OP_SUB:
			case R_OP_AST:
			case T_CHAR:
			case T_BOOL_TRUE:
			case T_BOOL_FALSE:
			case ID:
			case T_INTEIRO:
				{
				setState(444); unary_expr();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			_ctx.stop = _input.LT(-1);
			setState(464);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,42,_ctx);
			while ( _alt!=2 && _alt!=ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(462);
					switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
					case 1:
						{
						_localctx = new ExpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(447);
						if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
						setState(448);
						((ExpressionContext)_localctx).op = _input.LT(1);
						_la = _input.LA(1);
						if ( !(((((_la - 12)) & ~0x3f) == 0 && ((1L << (_la - 12)) & ((1L << (R_OP_MOD - 12)) | (1L << (R_END - 12)) | (1L << (R_OP_DIV - 12)) | (1L << (R_OP_ADD - 12)) | (1L << (R_OP_SUB - 12)) | (1L << (R_OP_AST - 12)))) != 0)) ) {
							((ExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
						}
						consume();
						setState(449); expression(6);
						}
						break;

					case 2:
						{
						_localctx = new ExpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(450);
						if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
						setState(451);
						((ExpressionContext)_localctx).op = _input.LT(1);
						_la = _input.LA(1);
						if ( !(_la==R_SHIFT_LEFT || _la==R_SHIFT_RIGHT) ) {
							((ExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
						}
						consume();
						setState(452); expression(5);
						}
						break;

					case 3:
						{
						_localctx = new ExpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(453);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(454);
						((ExpressionContext)_localctx).op = _input.LT(1);
						_la = _input.LA(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << R_BIT_AND) | (1L << R_BIT_XOR) | (1L << R_BIT_OR))) != 0)) ) {
							((ExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
						}
						consume();
						setState(455); expression(4);
						}
						break;

					case 4:
						{
						_localctx = new ExpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(456);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(457);
						((ExpressionContext)_localctx).op = _input.LT(1);
						_la = _input.LA(1);
						if ( !(((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (R_COMP_EQ - 60)) | (1L << (R_COMP_DIFF - 60)) | (1L << (R_COMP_LTE - 60)) | (1L << (R_COMP_LT - 60)) | (1L << (R_COMP_GTE - 60)) | (1L << (R_COMP_GT - 60)))) != 0)) ) {
							((ExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
						}
						consume();
						setState(458); expression(3);
						}
						break;

					case 5:
						{
						_localctx = new ExpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(459);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(460);
						((ExpressionContext)_localctx).op = _input.LT(1);
						_la = _input.LA(1);
						if ( !(_la==R_AND || _la==R_OR) ) {
							((ExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
						}
						consume();
						setState(461); expression(2);
						}
						break;
					}
					} 
				}
				setState(466);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,42,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public static class Unary_exprContext extends ParserRuleContext {
		public Token op;
		public TerminalNode R_EXCLAMATION() { return getToken(IvannosysGrammarParser.R_EXCLAMATION, 0); }
		public TerminalNode R_OP_SUB() { return getToken(IvannosysGrammarParser.R_OP_SUB, 0); }
		public TerminalNode R_OP_AST() { return getToken(IvannosysGrammarParser.R_OP_AST, 0); }
		public Primary_exprContext primary_expr() {
			return getRuleContext(Primary_exprContext.class,0);
		}
		public TerminalNode R_REFERENCE() { return getToken(IvannosysGrammarParser.R_REFERENCE, 0); }
		public Unary_exprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unary_expr; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterUnary_expr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitUnary_expr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitUnary_expr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Unary_exprContext unary_expr() throws RecognitionException {
		Unary_exprContext _localctx = new Unary_exprContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_unary_expr);
		int _la;
		try {
			setState(470);
			switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(467);
				((Unary_exprContext)_localctx).op = _input.LT(1);
				_la = _input.LA(1);
				if ( !(((((_la - 8)) & ~0x3f) == 0 && ((1L << (_la - 8)) & ((1L << (R_REFERENCE - 8)) | (1L << (R_EXCLAMATION - 8)) | (1L << (R_OP_SUB - 8)) | (1L << (R_OP_AST - 8)))) != 0)) ) {
					((Unary_exprContext)_localctx).op = (Token)_errHandler.recoverInline(this);
				}
				consume();
				setState(468); primary_expr(0);
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(469); primary_expr(0);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Primary_exprContext extends ParserRuleContext {
		public String id;
		public Primary_exprContext pe;
		public Primary_exprContext pee;
		public Primary_exprContext pea;
		public OperandContext operand;
		public Primary_exprContext primary_expr() {
			return getRuleContext(Primary_exprContext.class,0);
		}
		public Expression_seletorContext expression_seletor() {
			return getRuleContext(Expression_seletorContext.class,0);
		}
		public IndexContext index() {
			return getRuleContext(IndexContext.class,0);
		}
		public ArgumentsContext arguments() {
			return getRuleContext(ArgumentsContext.class,0);
		}
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public OperandContext operand() {
			return getRuleContext(OperandContext.class,0);
		}
		public Primary_exprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_primary_expr; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterPrimary_expr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitPrimary_expr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitPrimary_expr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Primary_exprContext primary_expr() throws RecognitionException {
		return primary_expr(0);
	}

	private Primary_exprContext primary_expr(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		Primary_exprContext _localctx = new Primary_exprContext(_ctx, _parentState);
		Primary_exprContext _prevctx = _localctx;
		int _startState = 78;
		enterRecursionRule(_localctx, 78, RULE_primary_expr, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(477);
			switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
			case 1:
				{
				setState(473); ((Primary_exprContext)_localctx).operand = operand();
				((Primary_exprContext)_localctx).id =  ((Primary_exprContext)_localctx).operand.Value;
				}
				break;

			case 2:
				{
				setState(476); literal();
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(493);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,46,_ctx);
			while ( _alt!=2 && _alt!=ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(491);
					switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
					case 1:
						{
						_localctx = new Primary_exprContext(_parentctx, _parentState);
						_localctx.pe = _prevctx;
						pushNewRecursionContext(_localctx, _startState, RULE_primary_expr);
						setState(479);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(480); index();
						((Primary_exprContext)_localctx).id =  ((Primary_exprContext)_localctx).pe.id;
						}
						break;

					case 2:
						{
						_localctx = new Primary_exprContext(_parentctx, _parentState);
						_localctx.pee = _prevctx;
						pushNewRecursionContext(_localctx, _startState, RULE_primary_expr);
						setState(483);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(484); expression_seletor();
						((Primary_exprContext)_localctx).id =  ((Primary_exprContext)_localctx).pee.id;
						}
						break;

					case 3:
						{
						_localctx = new Primary_exprContext(_parentctx, _parentState);
						_localctx.pea = _prevctx;
						pushNewRecursionContext(_localctx, _startState, RULE_primary_expr);
						setState(487);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(488); arguments();
						((Primary_exprContext)_localctx).id =  ((Primary_exprContext)_localctx).pea.id;
						}
						break;
					}
					} 
				}
				setState(495);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,46,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public static class OperandContext extends ParserRuleContext {
		public String Value;
		public Token ID;
		public Primitive_valueContext primitive_value;
		public Primitive_valueContext primitive_value() {
			return getRuleContext(Primitive_valueContext.class,0);
		}
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public OperandContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_operand; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterOperand(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitOperand(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitOperand(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OperandContext operand() throws RecognitionException {
		OperandContext _localctx = new OperandContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_operand);
		try {
			setState(501);
			switch (_input.LA(1)) {
			case ID:
				enterOuterAlt(_localctx, 1);
				{
				setState(496); ((OperandContext)_localctx).ID = match(ID);
				((OperandContext)_localctx).Value = (((OperandContext)_localctx).ID!=null?((OperandContext)_localctx).ID.getText():null);
				}
				break;
			case T_CHAR:
			case T_BOOL_TRUE:
			case T_BOOL_FALSE:
			case T_INTEIRO:
				enterOuterAlt(_localctx, 2);
				{
				setState(498); ((OperandContext)_localctx).primitive_value = primitive_value();
				((OperandContext)_localctx).Value = (((OperandContext)_localctx).primitive_value!=null?_input.getText(((OperandContext)_localctx).primitive_value.start,((OperandContext)_localctx).primitive_value.stop):null);
				}
				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 LiteralContext extends ParserRuleContext {
		public Func_literalContext func_literal() {
			return getRuleContext(Func_literalContext.class,0);
		}
		public CompositeContext composite() {
			return getRuleContext(CompositeContext.class,0);
		}
		public LiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_literal; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LiteralContext literal() throws RecognitionException {
		LiteralContext _localctx = new LiteralContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_literal);
		try {
			setState(505);
			switch (_input.LA(1)) {
			case R_FUNCTION:
				enterOuterAlt(_localctx, 1);
				{
				setState(503); func_literal();
				}
				break;
			case R_STRUCT:
			case R_ERROR:
			case R_INT:
			case R_CHAR:
			case R_BOOL:
			case R_STRING:
			case R_CHA_E:
			case R_OP_AST:
			case ID:
				enterOuterAlt(_localctx, 2);
				{
				setState(504); composite();
				}
				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 Base_stmtContext extends ParserRuleContext {
		public Dec_var_shortContext dec_var_short() {
			return getRuleContext(Dec_var_shortContext.class,0);
		}
		public Inc_decContext inc_dec() {
			return getRuleContext(Inc_decContext.class,0);
		}
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public Def_assign_opContext def_assign_op() {
			return getRuleContext(Def_assign_opContext.class,0);
		}
		public Base_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_base_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterBase_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitBase_stmt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitBase_stmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Base_stmtContext base_stmt() throws RecognitionException {
		Base_stmtContext _localctx = new Base_stmtContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_base_stmt);
		try {
			setState(512);
			switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(508); inc_dec();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(509); def_assign_op();
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(510); dec_var_short();
				}
				break;

			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(511); expression(0);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Func_literalContext extends ParserRuleContext {
		public Def_blockContext def_block() {
			return getRuleContext(Def_blockContext.class,0);
		}
		public TerminalNode R_FUNCTION() { return getToken(IvannosysGrammarParser.R_FUNCTION, 0); }
		public ArgumentsContext arguments() {
			return getRuleContext(ArgumentsContext.class,0);
		}
		public Return_decContext return_dec() {
			return getRuleContext(Return_decContext.class,0);
		}
		public Func_literalContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_func_literal; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterFunc_literal(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitFunc_literal(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitFunc_literal(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Func_literalContext func_literal() throws RecognitionException {
		Func_literalContext _localctx = new Func_literalContext(_ctx, getState());
		enterRule(_localctx, 86, RULE_func_literal);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(514); match(R_FUNCTION);
			setState(515); arguments();
			setState(517);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << R_MAP) | (1L << R_ERROR) | (1L << R_INT) | (1L << R_CHAR) | (1L << R_BOOL) | (1L << R_STRING) | (1L << R_CHA_E))) != 0) || _la==R_OP_AST || _la==ID) {
				{
				setState(516); return_dec();
				}
			}

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

	public static class CompositeContext extends ParserRuleContext {
		public LiteralTypeContext literalType() {
			return getRuleContext(LiteralTypeContext.class,0);
		}
		public Literal_valueContext literal_value() {
			return getRuleContext(Literal_valueContext.class,0);
		}
		public CompositeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_composite; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterComposite(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitComposite(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitComposite(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CompositeContext composite() throws RecognitionException {
		CompositeContext _localctx = new CompositeContext(_ctx, getState());
		enterRule(_localctx, 88, RULE_composite);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(521); literalType();
			setState(522); literal_value();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LiteralTypeContext extends ParserRuleContext {
		public TypenameContext typename() {
			return getRuleContext(TypenameContext.class,0);
		}
		public StructTypeContext structType() {
			return getRuleContext(StructTypeContext.class,0);
		}
		public ArrayTypeContext arrayType() {
			return getRuleContext(ArrayTypeContext.class,0);
		}
		public LiteralTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_literalType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterLiteralType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitLiteralType(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitLiteralType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LiteralTypeContext literalType() throws RecognitionException {
		LiteralTypeContext _localctx = new LiteralTypeContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_literalType);
		try {
			setState(527);
			switch (_input.LA(1)) {
			case R_ERROR:
			case R_INT:
			case R_CHAR:
			case R_BOOL:
			case R_STRING:
			case R_OP_AST:
			case ID:
				enterOuterAlt(_localctx, 1);
				{
				setState(524); typename();
				}
				break;
			case R_STRUCT:
				enterOuterAlt(_localctx, 2);
				{
				setState(525); structType();
				}
				break;
			case R_CHA_E:
				enterOuterAlt(_localctx, 3);
				{
				setState(526); arrayType();
				}
				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 StructTypeContext extends ParserRuleContext {
		public FieldDeclContext fieldDecl(int i) {
			return getRuleContext(FieldDeclContext.class,i);
		}
		public TerminalNode R_COL_E() { return getToken(IvannosysGrammarParser.R_COL_E, 0); }
		public TerminalNode R_STRUCT() { return getToken(IvannosysGrammarParser.R_STRUCT, 0); }
		public List<FieldDeclContext> fieldDecl() {
			return getRuleContexts(FieldDeclContext.class);
		}
		public TerminalNode R_COL_D() { return getToken(IvannosysGrammarParser.R_COL_D, 0); }
		public StructTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_structType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterStructType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitStructType(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitStructType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StructTypeContext structType() throws RecognitionException {
		StructTypeContext _localctx = new StructTypeContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_structType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(529); match(R_STRUCT);
			setState(530); match(R_COL_E);
			setState(532); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(531); fieldDecl();
				}
				}
				setState(534); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << R_ERROR) | (1L << R_INT) | (1L << R_CHAR) | (1L << R_BOOL) | (1L << R_STRING))) != 0) || _la==R_OP_AST || _la==ID );
			setState(536); match(R_COL_D);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FieldDeclContext extends ParserRuleContext {
		public Anon_fieldContext anon_field() {
			return getRuleContext(Anon_fieldContext.class,0);
		}
		public TerminalNode T_STRING() { return getToken(IvannosysGrammarParser.T_STRING, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public Id_listContext id_list() {
			return getRuleContext(Id_listContext.class,0);
		}
		public FieldDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fieldDecl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterFieldDecl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitFieldDecl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitFieldDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FieldDeclContext fieldDecl() throws RecognitionException {
		FieldDeclContext _localctx = new FieldDeclContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_fieldDecl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(542);
			switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) {
			case 1:
				{
				setState(538); id_list();
				setState(539); type();
				}
				break;

			case 2:
				{
				setState(541); anon_field();
				}
				break;
			}
			setState(545);
			_la = _input.LA(1);
			if (_la==T_STRING) {
				{
				setState(544); match(T_STRING);
				}
			}

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

	public static class Anon_fieldContext extends ParserRuleContext {
		public TypenameContext typename() {
			return getRuleContext(TypenameContext.class,0);
		}
		public TerminalNode R_OP_AST() { return getToken(IvannosysGrammarParser.R_OP_AST, 0); }
		public Anon_fieldContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_anon_field; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterAnon_field(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitAnon_field(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitAnon_field(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Anon_fieldContext anon_field() throws RecognitionException {
		Anon_fieldContext _localctx = new Anon_fieldContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_anon_field);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(548);
			switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
			case 1:
				{
				setState(547); match(R_OP_AST);
				}
				break;
			}
			setState(550); typename();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArrayTypeContext extends ParserRuleContext {
		public TypenameContext typename() {
			return getRuleContext(TypenameContext.class,0);
		}
		public TerminalNode R_CHA_D() { return getToken(IvannosysGrammarParser.R_CHA_D, 0); }
		public TerminalNode R_CHA_E() { return getToken(IvannosysGrammarParser.R_CHA_E, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public ArrayTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arrayType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterArrayType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitArrayType(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitArrayType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ArrayTypeContext arrayType() throws RecognitionException {
		ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_arrayType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(552); match(R_CHA_E);
			setState(554);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << R_REFERENCE) | (1L << R_STRUCT) | (1L << R_ERROR) | (1L << R_INT) | (1L << R_CHAR) | (1L << R_BOOL) | (1L << R_STRING) | (1L << R_FUNCTION) | (1L << R_EXCLAMATION) | (1L << R_PAR_E) | (1L << R_CHA_E))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (R_OP_SUB - 70)) | (1L << (R_OP_AST - 70)) | (1L << (T_CHAR - 70)) | (1L << (T_BOOL_TRUE - 70)) | (1L << (T_BOOL_FALSE - 70)) | (1L << (ID - 70)) | (1L << (T_INTEIRO - 70)))) != 0)) {
				{
				setState(553); expression(0);
				}
			}

			setState(556); match(R_CHA_D);
			setState(557); typename();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Inc_decContext extends ParserRuleContext {
		public Token op;
		public TerminalNode R_OP_SS() { return getToken(IvannosysGrammarParser.R_OP_SS, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode R_OP_PP() { return getToken(IvannosysGrammarParser.R_OP_PP, 0); }
		public Inc_decContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_inc_dec; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterInc_dec(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitInc_dec(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitInc_dec(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Inc_decContext inc_dec() throws RecognitionException {
		Inc_decContext _localctx = new Inc_decContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_inc_dec);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(559); expression(0);
			setState(560);
			((Inc_decContext)_localctx).op = _input.LT(1);
			_la = _input.LA(1);
			if ( !(_la==R_OP_SS || _la==R_OP_PP) ) {
				((Inc_decContext)_localctx).op = (Token)_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Literal_valueContext extends ParserRuleContext {
		public TerminalNode R_COL_E() { return getToken(IvannosysGrammarParser.R_COL_E, 0); }
		public TerminalNode R_VIRGULA() { return getToken(IvannosysGrammarParser.R_VIRGULA, 0); }
		public Element_listContext element_list() {
			return getRuleContext(Element_listContext.class,0);
		}
		public Expression_listContext expression_list() {
			return getRuleContext(Expression_listContext.class,0);
		}
		public TerminalNode R_COL_D() { return getToken(IvannosysGrammarParser.R_COL_D, 0); }
		public Literal_valueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_literal_value; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterLiteral_value(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitLiteral_value(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitLiteral_value(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Literal_valueContext literal_value() throws RecognitionException {
		Literal_valueContext _localctx = new Literal_valueContext(_ctx, getState());
		enterRule(_localctx, 102, RULE_literal_value);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(562); match(R_COL_E);
			setState(569);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << R_REFERENCE) | (1L << R_STRUCT) | (1L << R_ERROR) | (1L << R_INT) | (1L << R_CHAR) | (1L << R_BOOL) | (1L << R_STRING) | (1L << R_FUNCTION) | (1L << R_EXCLAMATION) | (1L << R_PAR_E) | (1L << R_CHA_E))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (R_OP_SUB - 70)) | (1L << (R_OP_AST - 70)) | (1L << (T_CHAR - 70)) | (1L << (T_BOOL_TRUE - 70)) | (1L << (T_BOOL_FALSE - 70)) | (1L << (ID - 70)) | (1L << (T_INTEIRO - 70)))) != 0)) {
				{
				setState(565);
				switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
				case 1:
					{
					setState(563); expression_list();
					}
					break;

				case 2:
					{
					setState(564); element_list();
					}
					break;
				}
				setState(567); match(R_VIRGULA);
				}
			}

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

	public static class Element_listContext extends ParserRuleContext {
		public List<Keyed_elementContext> keyed_element() {
			return getRuleContexts(Keyed_elementContext.class);
		}
		public Keyed_elementContext keyed_element(int i) {
			return getRuleContext(Keyed_elementContext.class,i);
		}
		public List<TerminalNode> R_VIRGULA() { return getTokens(IvannosysGrammarParser.R_VIRGULA); }
		public TerminalNode R_VIRGULA(int i) {
			return getToken(IvannosysGrammarParser.R_VIRGULA, i);
		}
		public Element_listContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_element_list; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterElement_list(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitElement_list(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitElement_list(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Element_listContext element_list() throws RecognitionException {
		Element_listContext _localctx = new Element_listContext(_ctx, getState());
		enterRule(_localctx, 104, RULE_element_list);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(573); keyed_element();
			setState(578);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,59,_ctx);
			while ( _alt!=2 && _alt!=ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(574); match(R_VIRGULA);
					setState(575); keyed_element();
					}
					} 
				}
				setState(580);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,59,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Keyed_elementContext extends ParserRuleContext {
		public TerminalNode R_COLON() { return getToken(IvannosysGrammarParser.R_COLON, 0); }
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public Keyed_elementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_keyed_element; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterKeyed_element(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitKeyed_element(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitKeyed_element(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Keyed_elementContext keyed_element() throws RecognitionException {
		Keyed_elementContext _localctx = new Keyed_elementContext(_ctx, getState());
		enterRule(_localctx, 106, RULE_keyed_element);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(581); match(ID);
			setState(582); match(R_COLON);
			setState(583); expression(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expression_seletorContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public TerminalNode R_PONTO() { return getToken(IvannosysGrammarParser.R_PONTO, 0); }
		public Expression_seletorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression_seletor; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterExpression_seletor(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitExpression_seletor(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitExpression_seletor(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expression_seletorContext expression_seletor() throws RecognitionException {
		Expression_seletorContext _localctx = new Expression_seletorContext(_ctx, getState());
		enterRule(_localctx, 108, RULE_expression_seletor);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(585); match(R_PONTO);
			setState(586); match(ID);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Def_blockContext extends ParserRuleContext {
		public HashMap<String, String> retornos = new HashMap<>();;
		public List<StatementContext> statement() {
			return getRuleContexts(StatementContext.class);
		}
		public TerminalNode R_COL_E() { return getToken(IvannosysGrammarParser.R_COL_E, 0); }
		public StatementContext statement(int i) {
			return getRuleContext(StatementContext.class,i);
		}
		public TerminalNode R_COL_D() { return getToken(IvannosysGrammarParser.R_COL_D, 0); }
		public Def_blockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_def_block; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDef_block(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDef_block(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDef_block(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Def_blockContext def_block() throws RecognitionException {
		Def_blockContext _localctx = new Def_blockContext(_ctx, getState());
		enterRule(_localctx, 110, RULE_def_block);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(588); match(R_COL_E);
			setState(592);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << R_REFERENCE) | (1L << R_STRUCT) | (1L << R_VAR) | (1L << R_GOTO) | (1L << R_FALLTHROUGH) | (1L << R_ERROR) | (1L << R_DELETE) | (1L << R_TRY) | (1L << R_INT) | (1L << R_CHAR) | (1L << R_BOOL) | (1L << R_STRING) | (1L << R_FUNCTION) | (1L << R_CONSTANTE) | (1L << R_SWITCH) | (1L << R_FOR) | (1L << R_RETURN) | (1L << R_CONTINUE) | (1L << R_BREAK) | (1L << R_THROW) | (1L << R_IF) | (1L << R_EXCLAMATION) | (1L << R_PAR_E) | (1L << R_CHA_E))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (R_OP_SUB - 70)) | (1L << (R_OP_AST - 70)) | (1L << (T_CHAR - 70)) | (1L << (T_BOOL_TRUE - 70)) | (1L << (T_BOOL_FALSE - 70)) | (1L << (ID - 70)) | (1L << (T_INTEIRO - 70)))) != 0)) {
				{
				{
				setState(589); statement();
				}
				}
				setState(594);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(595); match(R_COL_D);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CallExprContext extends ParserRuleContext {
		public Primary_exprContext primary_expr() {
			return getRuleContext(Primary_exprContext.class,0);
		}
		public ArgumentsContext arguments() {
			return getRuleContext(ArgumentsContext.class,0);
		}
		public CallExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_callExpr; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterCallExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitCallExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitCallExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CallExprContext callExpr() throws RecognitionException {
		CallExprContext _localctx = new CallExprContext(_ctx, getState());
		enterRule(_localctx, 112, RULE_callExpr);
		try {
			setState(601);
			switch (_input.LA(1)) {
			case EOF:
				enterOuterAlt(_localctx, 1);
				{
				}
				break;
			case R_STRUCT:
			case R_ERROR:
			case R_INT:
			case R_CHAR:
			case R_BOOL:
			case R_STRING:
			case R_FUNCTION:
			case R_CHA_E:
			case R_OP_AST:
			case T_CHAR:
			case T_BOOL_TRUE:
			case T_BOOL_FALSE:
			case ID:
			case T_INTEIRO:
				enterOuterAlt(_localctx, 2);
				{
				setState(598); primary_expr(0);
				setState(599); arguments();
				}
				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 StatementContext extends ParserRuleContext {
		public Flux_controlContext flux_control() {
			return getRuleContext(Flux_controlContext.class,0);
		}
		public FallthroughStmtContext fallthroughStmt() {
			return getRuleContext(FallthroughStmtContext.class,0);
		}
		public Def_ifContext def_if() {
			return getRuleContext(Def_ifContext.class,0);
		}
		public Def_switchContext def_switch() {
			return getRuleContext(Def_switchContext.class,0);
		}
		public Dec_varContext dec_var() {
			return getRuleContext(Dec_varContext.class,0);
		}
		public Def_assign_opContext def_assign_op() {
			return getRuleContext(Def_assign_opContext.class,0);
		}
		public Dec_constContext dec_const() {
			return getRuleContext(Dec_constContext.class,0);
		}
		public ThrowStmtContext throwStmt() {
			return getRuleContext(ThrowStmtContext.class,0);
		}
		public Try_catchContext try_catch() {
			return getRuleContext(Try_catchContext.class,0);
		}
		public Def_forContext def_for() {
			return getRuleContext(Def_forContext.class,0);
		}
		public Dec_var_shortContext dec_var_short() {
			return getRuleContext(Dec_var_shortContext.class,0);
		}
		public Primary_exprContext primary_expr() {
			return getRuleContext(Primary_exprContext.class,0);
		}
		public Inc_decContext inc_dec() {
			return getRuleContext(Inc_decContext.class,0);
		}
		public Return_stmtContext return_stmt() {
			return getRuleContext(Return_stmtContext.class,0);
		}
		public DeleteContext delete() {
			return getRuleContext(DeleteContext.class,0);
		}
		public Label_stmtContext label_stmt() {
			return getRuleContext(Label_stmtContext.class,0);
		}
		public StatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_statement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StatementContext statement() throws RecognitionException {
		StatementContext _localctx = new StatementContext(_ctx, getState());
		enterRule(_localctx, 114, RULE_statement);
		try {
			setState(619);
			switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(603); dec_var_short();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(604); dec_var();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(605); def_assign_op();
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(606); dec_const();
				}
				break;

			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(607); inc_dec();
				}
				break;

			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(608); primary_expr(0);
				}
				break;

			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(609); label_stmt();
				}
				break;

			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(610); return_stmt();
				}
				break;

			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(611); delete();
				}
				break;

			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(612); throwStmt();
				}
				break;

			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(613); fallthroughStmt();
				}
				break;

			case 12:
				enterOuterAlt(_localctx, 12);
				{
				setState(614); def_if();
				}
				break;

			case 13:
				enterOuterAlt(_localctx, 13);
				{
				setState(615); def_for();
				}
				break;

			case 14:
				enterOuterAlt(_localctx, 14);
				{
				setState(616); def_switch();
				}
				break;

			case 15:
				enterOuterAlt(_localctx, 15);
				{
				setState(617); flux_control();
				}
				break;

			case 16:
				enterOuterAlt(_localctx, 16);
				{
				setState(618); try_catch();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FallthroughStmtContext extends ParserRuleContext {
		public TerminalNode R_FALLTHROUGH() { return getToken(IvannosysGrammarParser.R_FALLTHROUGH, 0); }
		public FallthroughStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fallthroughStmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterFallthroughStmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitFallthroughStmt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitFallthroughStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FallthroughStmtContext fallthroughStmt() throws RecognitionException {
		FallthroughStmtContext _localctx = new FallthroughStmtContext(_ctx, getState());
		enterRule(_localctx, 116, RULE_fallthroughStmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(621); match(R_FALLTHROUGH);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Label_stmtContext extends ParserRuleContext {
		public StatementContext statement() {
			return getRuleContext(StatementContext.class,0);
		}
		public TerminalNode R_COLON() { return getToken(IvannosysGrammarParser.R_COLON, 0); }
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public Label_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_label_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterLabel_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitLabel_stmt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitLabel_stmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Label_stmtContext label_stmt() throws RecognitionException {
		Label_stmtContext _localctx = new Label_stmtContext(_ctx, getState());
		enterRule(_localctx, 118, RULE_label_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(623); match(ID);
			setState(624); match(R_COLON);
			setState(625); statement();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ThrowStmtContext extends ParserRuleContext {
		public TerminalNode R_THROW() { return getToken(IvannosysGrammarParser.R_THROW, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode R_PT_VIRG() { return getToken(IvannosysGrammarParser.R_PT_VIRG, 0); }
		public ThrowStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_throwStmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterThrowStmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitThrowStmt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitThrowStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ThrowStmtContext throwStmt() throws RecognitionException {
		ThrowStmtContext _localctx = new ThrowStmtContext(_ctx, getState());
		enterRule(_localctx, 120, RULE_throwStmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(627); match(R_THROW);
			setState(628); expression(0);
			setState(629); match(R_PT_VIRG);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Try_catchContext extends ParserRuleContext {
		public Catch_exceptionContext catch_exception() {
			return getRuleContext(Catch_exceptionContext.class,0);
		}
		public Def_blockContext def_block() {
			return getRuleContext(Def_blockContext.class,0);
		}
		public Finally_tryContext finally_try() {
			return getRuleContext(Finally_tryContext.class,0);
		}
		public TerminalNode R_TRY() { return getToken(IvannosysGrammarParser.R_TRY, 0); }
		public Try_catchContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_try_catch; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterTry_catch(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitTry_catch(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitTry_catch(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Try_catchContext try_catch() throws RecognitionException {
		Try_catchContext _localctx = new Try_catchContext(_ctx, getState());
		enterRule(_localctx, 122, RULE_try_catch);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(631); match(R_TRY);
			setState(632); def_block();
			setState(633); catch_exception();
			setState(635);
			_la = _input.LA(1);
			if (_la==R_FINALLY) {
				{
				setState(634); finally_try();
				}
			}

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

	public static class Catch_exceptionContext extends ParserRuleContext {
		public TerminalNode R_CATCH() { return getToken(IvannosysGrammarParser.R_CATCH, 0); }
		public Def_blockContext def_block() {
			return getRuleContext(Def_blockContext.class,0);
		}
		public TerminalNode R_PAR_D() { return getToken(IvannosysGrammarParser.R_PAR_D, 0); }
		public TerminalNode R_PAR_E() { return getToken(IvannosysGrammarParser.R_PAR_E, 0); }
		public Dec_varContext dec_var() {
			return getRuleContext(Dec_varContext.class,0);
		}
		public Catch_exceptionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_catch_exception; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterCatch_exception(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitCatch_exception(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitCatch_exception(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Catch_exceptionContext catch_exception() throws RecognitionException {
		Catch_exceptionContext _localctx = new Catch_exceptionContext(_ctx, getState());
		enterRule(_localctx, 124, RULE_catch_exception);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(637); match(R_CATCH);
			setState(638); match(R_PAR_E);
			setState(639); dec_var();
			setState(640); match(R_PAR_D);
			setState(641); def_block();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Finally_tryContext extends ParserRuleContext {
		public TerminalNode R_FINALLY() { return getToken(IvannosysGrammarParser.R_FINALLY, 0); }
		public Def_blockContext def_block() {
			return getRuleContext(Def_blockContext.class,0);
		}
		public Finally_tryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_finally_try; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterFinally_try(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitFinally_try(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitFinally_try(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Finally_tryContext finally_try() throws RecognitionException {
		Finally_tryContext _localctx = new Finally_tryContext(_ctx, getState());
		enterRule(_localctx, 126, RULE_finally_try);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(643); match(R_FINALLY);
			setState(644); def_block();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Flux_controlContext extends ParserRuleContext {
		public String control;
		public Token R_GOTO;
		public Token R_CONTINUE;
		public Token R_BREAK;
		public TerminalNode R_CONTINUE() { return getToken(IvannosysGrammarParser.R_CONTINUE, 0); }
		public TerminalNode R_GOTO() { return getToken(IvannosysGrammarParser.R_GOTO, 0); }
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public TerminalNode R_BREAK() { return getToken(IvannosysGrammarParser.R_BREAK, 0); }
		public Flux_controlContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_flux_control; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterFlux_control(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitFlux_control(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitFlux_control(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Flux_controlContext flux_control() throws RecognitionException {
		Flux_controlContext _localctx = new Flux_controlContext(_ctx, getState());
		enterRule(_localctx, 128, RULE_flux_control);
		try {
			setState(653);
			switch (_input.LA(1)) {
			case R_GOTO:
				enterOuterAlt(_localctx, 1);
				{
				setState(646); ((Flux_controlContext)_localctx).R_GOTO = match(R_GOTO);
				setState(647); match(ID);
				((Flux_controlContext)_localctx).control =  (((Flux_controlContext)_localctx).R_GOTO!=null?((Flux_controlContext)_localctx).R_GOTO.getText():null);
				}
				break;
			case R_CONTINUE:
				enterOuterAlt(_localctx, 2);
				{
				setState(649); ((Flux_controlContext)_localctx).R_CONTINUE = match(R_CONTINUE);
				((Flux_controlContext)_localctx).control =  (((Flux_controlContext)_localctx).R_CONTINUE!=null?((Flux_controlContext)_localctx).R_CONTINUE.getText():null);
				}
				break;
			case R_BREAK:
				enterOuterAlt(_localctx, 3);
				{
				setState(651); ((Flux_controlContext)_localctx).R_BREAK = match(R_BREAK);
				((Flux_controlContext)_localctx).control =  (((Flux_controlContext)_localctx).R_BREAK!=null?((Flux_controlContext)_localctx).R_BREAK.getText():null);
				}
				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 NewstmtContext extends ParserRuleContext {
		public TerminalNode T_INTEIRO() { return getToken(IvannosysGrammarParser.T_INTEIRO, 0); }
		public TerminalNode R_VIRGULA() { return getToken(IvannosysGrammarParser.R_VIRGULA, 0); }
		public TerminalNode R_PAR_D() { return getToken(IvannosysGrammarParser.R_PAR_D, 0); }
		public TerminalNode R_PAR_E() { return getToken(IvannosysGrammarParser.R_PAR_E, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TerminalNode R_NEW() { return getToken(IvannosysGrammarParser.R_NEW, 0); }
		public NewstmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_newstmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterNewstmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitNewstmt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitNewstmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NewstmtContext newstmt() throws RecognitionException {
		NewstmtContext _localctx = new NewstmtContext(_ctx, getState());
		enterRule(_localctx, 130, RULE_newstmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(655); match(R_NEW);
			setState(656); match(R_PAR_E);
			setState(657); type();
			setState(660);
			_la = _input.LA(1);
			if (_la==R_VIRGULA) {
				{
				setState(658); match(R_VIRGULA);
				setState(659); match(T_INTEIRO);
				}
			}

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

	public static class DeleteContext extends ParserRuleContext {
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode R_VIRGULA() { return getToken(IvannosysGrammarParser.R_VIRGULA, 0); }
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public TerminalNode R_DELETE() { return getToken(IvannosysGrammarParser.R_DELETE, 0); }
		public DeleteContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_delete; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterDelete(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitDelete(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitDelete(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DeleteContext delete() throws RecognitionException {
		DeleteContext _localctx = new DeleteContext(_ctx, getState());
		enterRule(_localctx, 132, RULE_delete);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(664); match(R_DELETE);
			setState(665); expression(0);
			setState(668);
			_la = _input.LA(1);
			if (_la==R_VIRGULA) {
				{
				setState(666); match(R_VIRGULA);
				setState(667); expression(0);
				}
			}

			}
		}
		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 String ltype;
		public String keytype;
		public String valuetype;
		public TypenameContext typename;
		public IndexedTypeContext indexedType;
		public TypenameContext typename() {
			return getRuleContext(TypenameContext.class,0);
		}
		public MapTypeContext mapType() {
			return getRuleContext(MapTypeContext.class,0);
		}
		public IndexedTypeContext indexedType() {
			return getRuleContext(IndexedTypeContext.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 IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitType(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeContext type() throws RecognitionException {
		TypeContext _localctx = new TypeContext(_ctx, getState());
		enterRule(_localctx, 134, RULE_type);
		try {
			setState(679);
			switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(670); ((TypeContext)_localctx).typename = typename();
				((TypeContext)_localctx).ltype =  ((TypeContext)_localctx).typename.ltype;
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(673); ((TypeContext)_localctx).indexedType = indexedType();
				((TypeContext)_localctx).ltype =  ((TypeContext)_localctx).indexedType.ltype;
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(676); mapType();
				((TypeContext)_localctx).ltype =  "map";
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IndexedTypeContext extends ParserRuleContext {
		public String ltype;
		public TypenameContext typename;
		public IndexedTypeContext it;
		public TypenameContext typename() {
			return getRuleContext(TypenameContext.class,0);
		}
		public IndexedTypeContext indexedType() {
			return getRuleContext(IndexedTypeContext.class,0);
		}
		public IndexContext index() {
			return getRuleContext(IndexContext.class,0);
		}
		public IndexedTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_indexedType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterIndexedType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitIndexedType(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitIndexedType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IndexedTypeContext indexedType() throws RecognitionException {
		IndexedTypeContext _localctx = new IndexedTypeContext(_ctx, getState());
		enterRule(_localctx, 136, RULE_indexedType);
		try {
			setState(688);
			switch (_input.LA(1)) {
			case R_ERROR:
			case R_INT:
			case R_CHAR:
			case R_BOOL:
			case R_STRING:
			case R_OP_AST:
			case ID:
				enterOuterAlt(_localctx, 1);
				{
				setState(681); ((IndexedTypeContext)_localctx).typename = typename();
				((IndexedTypeContext)_localctx).ltype =  ((IndexedTypeContext)_localctx).typename.ltype;
				}
				break;
			case R_CHA_E:
				enterOuterAlt(_localctx, 2);
				{
				setState(684); index();
				setState(685); ((IndexedTypeContext)_localctx).it = indexedType();
				((IndexedTypeContext)_localctx).ltype =  ((IndexedTypeContext)_localctx).it.ltype;
				}
				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 TypenameContext extends ParserRuleContext {
		public String ltype;
		public Boolean pointer;
		public Token ID;
		public QualifiedIdContext qualifiedId;
		public BaseTypeContext baseType;
		public TypenameContext tn;
		public TypenameContext typename() {
			return getRuleContext(TypenameContext.class,0);
		}
		public TerminalNode R_OP_AST() { return getToken(IvannosysGrammarParser.R_OP_AST, 0); }
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public QualifiedIdContext qualifiedId() {
			return getRuleContext(QualifiedIdContext.class,0);
		}
		public BaseTypeContext baseType() {
			return getRuleContext(BaseTypeContext.class,0);
		}
		public TypenameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typename; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterTypename(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitTypename(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitTypename(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypenameContext typename() throws RecognitionException {
		TypenameContext _localctx = new TypenameContext(_ctx, getState());
		enterRule(_localctx, 138, RULE_typename);
		try {
			setState(702);
			switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(690); ((TypenameContext)_localctx).ID = match(ID);
				((TypenameContext)_localctx).ltype =  (((TypenameContext)_localctx).ID!=null?((TypenameContext)_localctx).ID.getText():null);
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(692); ((TypenameContext)_localctx).qualifiedId = qualifiedId();
				((TypenameContext)_localctx).ltype =  (((TypenameContext)_localctx).qualifiedId!=null?_input.getText(((TypenameContext)_localctx).qualifiedId.start,((TypenameContext)_localctx).qualifiedId.stop):null);
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(695); ((TypenameContext)_localctx).baseType = baseType();
				((TypenameContext)_localctx).ltype =  ((TypenameContext)_localctx).baseType.ltype;
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(698); match(R_OP_AST);
				setState(699); ((TypenameContext)_localctx).tn = typename();
				((TypenameContext)_localctx).ltype =  ((TypenameContext)_localctx).tn.ltype;
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QualifiedIdContext extends ParserRuleContext {
		public List<TerminalNode> ID() { return getTokens(IvannosysGrammarParser.ID); }
		public TerminalNode R_PONTO() { return getToken(IvannosysGrammarParser.R_PONTO, 0); }
		public TerminalNode ID(int i) {
			return getToken(IvannosysGrammarParser.ID, i);
		}
		public QualifiedIdContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_qualifiedId; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterQualifiedId(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitQualifiedId(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitQualifiedId(this);
			else return visitor.visitChildren(this);
		}
	}

	public final QualifiedIdContext qualifiedId() throws RecognitionException {
		QualifiedIdContext _localctx = new QualifiedIdContext(_ctx, getState());
		enterRule(_localctx, 140, RULE_qualifiedId);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(704); match(ID);
			setState(705); match(R_PONTO);
			setState(706); match(ID);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BaseTypeContext extends ParserRuleContext {
		public String ltype;
		public Token R_INT;
		public Token R_BOOL;
		public Token R_CHAR;
		public Token R_STRING;
		public Token R_ERROR;
		public TerminalNode R_BOOL() { return getToken(IvannosysGrammarParser.R_BOOL, 0); }
		public TerminalNode R_CHAR() { return getToken(IvannosysGrammarParser.R_CHAR, 0); }
		public TerminalNode R_ERROR() { return getToken(IvannosysGrammarParser.R_ERROR, 0); }
		public TerminalNode R_STRING() { return getToken(IvannosysGrammarParser.R_STRING, 0); }
		public TerminalNode R_INT() { return getToken(IvannosysGrammarParser.R_INT, 0); }
		public BaseTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_baseType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterBaseType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitBaseType(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitBaseType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BaseTypeContext baseType() throws RecognitionException {
		BaseTypeContext _localctx = new BaseTypeContext(_ctx, getState());
		enterRule(_localctx, 142, RULE_baseType);
		try {
			setState(718);
			switch (_input.LA(1)) {
			case R_INT:
				enterOuterAlt(_localctx, 1);
				{
				setState(708); ((BaseTypeContext)_localctx).R_INT = match(R_INT);
				((BaseTypeContext)_localctx).ltype =  (((BaseTypeContext)_localctx).R_INT!=null?((BaseTypeContext)_localctx).R_INT.getText():null);
				}
				break;
			case R_BOOL:
				enterOuterAlt(_localctx, 2);
				{
				setState(710); ((BaseTypeContext)_localctx).R_BOOL = match(R_BOOL);
				((BaseTypeContext)_localctx).ltype =  (((BaseTypeContext)_localctx).R_BOOL!=null?((BaseTypeContext)_localctx).R_BOOL.getText():null);
				}
				break;
			case R_CHAR:
				enterOuterAlt(_localctx, 3);
				{
				setState(712); ((BaseTypeContext)_localctx).R_CHAR = match(R_CHAR);
				((BaseTypeContext)_localctx).ltype =  (((BaseTypeContext)_localctx).R_CHAR!=null?((BaseTypeContext)_localctx).R_CHAR.getText():null);
				}
				break;
			case R_STRING:
				enterOuterAlt(_localctx, 4);
				{
				setState(714); ((BaseTypeContext)_localctx).R_STRING = match(R_STRING);
				((BaseTypeContext)_localctx).ltype =  (((BaseTypeContext)_localctx).R_STRING!=null?((BaseTypeContext)_localctx).R_STRING.getText():null);
				}
				break;
			case R_ERROR:
				enterOuterAlt(_localctx, 5);
				{
				setState(716); ((BaseTypeContext)_localctx).R_ERROR = match(R_ERROR);
				((BaseTypeContext)_localctx).ltype =  (((BaseTypeContext)_localctx).R_ERROR!=null?((BaseTypeContext)_localctx).R_ERROR.getText():null);
				}
				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 MapTypeContext extends ParserRuleContext {
		public String keytype;
		public String valuetype;
		public TypeContext k;
		public TypeContext v;
		public TerminalNode R_CHA_D() { return getToken(IvannosysGrammarParser.R_CHA_D, 0); }
		public TerminalNode R_MAP() { return getToken(IvannosysGrammarParser.R_MAP, 0); }
		public TypeContext type(int i) {
			return getRuleContext(TypeContext.class,i);
		}
		public List<TypeContext> type() {
			return getRuleContexts(TypeContext.class);
		}
		public TerminalNode R_CHA_E() { return getToken(IvannosysGrammarParser.R_CHA_E, 0); }
		public MapTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_mapType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterMapType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitMapType(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitMapType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MapTypeContext mapType() throws RecognitionException {
		MapTypeContext _localctx = new MapTypeContext(_ctx, getState());
		enterRule(_localctx, 144, RULE_mapType);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(720); match(R_MAP);
			setState(721); match(R_CHA_E);
			setState(722); ((MapTypeContext)_localctx).k = type();
			setState(723); match(R_CHA_D);
			setState(724); ((MapTypeContext)_localctx).v = type();

			                                            ((MapTypeContext)_localctx).keytype = (((MapTypeContext)_localctx).k!=null?_input.getText(((MapTypeContext)_localctx).k.start,((MapTypeContext)_localctx).k.stop):null);
			                                            ((MapTypeContext)_localctx).valuetype = (((MapTypeContext)_localctx).v!=null?_input.getText(((MapTypeContext)_localctx).v.start,((MapTypeContext)_localctx).v.stop):null);
			                                          
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BuildtagsContext extends ParserRuleContext {
		public Build_stmtContext build_stmt(int i) {
			return getRuleContext(Build_stmtContext.class,i);
		}
		public List<Build_stmtContext> build_stmt() {
			return getRuleContexts(Build_stmtContext.class);
		}
		public BuildtagsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_buildtags; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterBuildtags(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitBuildtags(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitBuildtags(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BuildtagsContext buildtags() throws RecognitionException {
		BuildtagsContext _localctx = new BuildtagsContext(_ctx, getState());
		enterRule(_localctx, 146, RULE_buildtags);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(728); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(727); build_stmt();
				}
				}
				setState(730); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==R_AT );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Build_stmtContext extends ParserRuleContext {
		public List<BuildvalueContext> buildvalue() {
			return getRuleContexts(BuildvalueContext.class);
		}
		public List<TerminalNode> R_VIRGULA() { return getTokens(IvannosysGrammarParser.R_VIRGULA); }
		public TerminalNode R_COLON() { return getToken(IvannosysGrammarParser.R_COLON, 0); }
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public TerminalNode R_AT() { return getToken(IvannosysGrammarParser.R_AT, 0); }
		public TerminalNode R_VIRGULA(int i) {
			return getToken(IvannosysGrammarParser.R_VIRGULA, i);
		}
		public BuildvalueContext buildvalue(int i) {
			return getRuleContext(BuildvalueContext.class,i);
		}
		public Build_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_build_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterBuild_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitBuild_stmt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitBuild_stmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Build_stmtContext build_stmt() throws RecognitionException {
		Build_stmtContext _localctx = new Build_stmtContext(_ctx, getState());
		enterRule(_localctx, 148, RULE_build_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(732); match(R_AT);
			setState(733); match(ID);
			setState(734); match(R_COLON);
			setState(735); buildvalue();
			setState(740);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==R_VIRGULA) {
				{
				{
				setState(736); match(R_VIRGULA);
				setState(737); buildvalue();
				}
				}
				setState(742);
				_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 BuildvalueContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(IvannosysGrammarParser.ID, 0); }
		public TerminalNode R_LIT_STRING() { return getToken(IvannosysGrammarParser.R_LIT_STRING, 0); }
		public BuildvalueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_buildvalue; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterBuildvalue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitBuildvalue(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitBuildvalue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BuildvalueContext buildvalue() throws RecognitionException {
		BuildvalueContext _localctx = new BuildvalueContext(_ctx, getState());
		enterRule(_localctx, 150, RULE_buildvalue);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(743);
			_la = _input.LA(1);
			if ( !(_la==ID || _la==R_LIT_STRING) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 37: return expression_sempred((ExpressionContext)_localctx, predIndex);

		case 39: return primary_expr_sempred((Primary_exprContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0: return precpred(_ctx, 5);

		case 1: return precpred(_ctx, 4);

		case 2: return precpred(_ctx, 3);

		case 3: return precpred(_ctx, 2);

		case 4: return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean primary_expr_sempred(Primary_exprContext _localctx, int predIndex) {
		switch (predIndex) {
		case 5: return precpred(_ctx, 3);

		case 6: return precpred(_ctx, 2);

		case 7: return precpred(_ctx, 1);
		}
		return true;
	}

	public static final String _serializedATN =
		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3Y\u02ec\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,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
		"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
		"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\3\2\5\2\u009c\n\2\3\2\3\2\3\2\3\2\7\2\u00a2"+
		"\n\2\f\2\16\2\u00a5\13\2\3\2\6\2\u00a8\n\2\r\2\16\2\u00a9\3\2\3\2\3\3"+
		"\3\3\3\3\3\3\7\3\u00b2\n\3\f\3\16\3\u00b5\13\3\3\3\3\3\3\3\3\3\5\3\u00bb"+
		"\n\3\3\4\5\4\u00be\n\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\5\5\u00c7\n\5\3\6\3"+
		"\6\3\6\3\6\5\6\u00cd\n\6\3\7\3\7\3\7\3\7\3\7\6\7\u00d4\n\7\r\7\16\7\u00d5"+
		"\3\7\3\7\3\b\3\b\3\b\3\b\3\t\3\t\3\t\6\t\u00e1\n\t\r\t\16\t\u00e2\3\t"+
		"\3\t\3\t\3\t\5\t\u00e9\n\t\3\n\3\n\3\n\3\n\5\n\u00ef\n\n\3\n\3\n\5\n\u00f3"+
		"\n\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\7\f\u00fc\n\f\f\f\16\f\u00ff\13\f"+
		"\3\r\3\r\5\r\u0103\n\r\3\r\3\r\3\r\3\16\3\16\3\17\3\17\3\17\3\17\3\20"+
		"\3\20\3\20\3\20\3\20\7\20\u0113\n\20\f\20\16\20\u0116\13\20\5\20\u0118"+
		"\n\20\3\20\3\20\3\21\5\21\u011d\n\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22"+
		"\3\22\7\22\u0127\n\22\f\22\16\22\u012a\13\22\3\22\3\22\5\22\u012e\n\22"+
		"\3\23\3\23\5\23\u0132\n\23\3\23\3\23\3\23\3\24\3\24\5\24\u0139\n\24\3"+
		"\24\5\24\u013c\n\24\3\24\3\24\5\24\u0140\n\24\3\24\3\24\3\25\3\25\3\25"+
		"\7\25\u0147\n\25\f\25\16\25\u014a\13\25\3\26\3\26\3\26\5\26\u014f\n\26"+
		"\3\26\3\26\3\26\3\27\3\27\3\27\3\27\6\27\u0158\n\27\r\27\16\27\u0159\3"+
		"\27\3\27\3\30\3\30\3\30\3\30\3\30\5\30\u0163\n\30\3\30\3\30\3\30\5\30"+
		"\u0168\n\30\3\31\6\31\u016b\n\31\r\31\16\31\u016c\3\32\3\32\3\32\5\32"+
		"\u0172\n\32\3\33\3\33\3\33\7\33\u0177\n\33\f\33\16\33\u017a\13\33\3\33"+
		"\3\33\5\33\u017e\n\33\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35\5\35\u0188"+
		"\n\35\3\35\3\35\3\36\3\36\3\36\5\36\u018f\n\36\3\36\3\36\3\36\5\36\u0194"+
		"\n\36\3\37\3\37\3 \3 \3 \3!\3!\3!\3!\5!\u019f\n!\5!\u01a1\n!\3\"\3\"\3"+
		"#\3#\3#\3#\3#\3#\3#\3$\3$\3%\3%\5%\u01b0\n%\3&\3&\3&\7&\u01b5\n&\f&\16"+
		"&\u01b8\13&\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u01c0\n\'\3\'\3\'\3\'\3\'\3\'"+
		"\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\7\'\u01d1\n\'\f\'\16\'\u01d4"+
		"\13\'\3(\3(\3(\5(\u01d9\n(\3)\3)\3)\3)\3)\5)\u01e0\n)\3)\3)\3)\3)\3)\3"+
		")\3)\3)\3)\3)\3)\3)\7)\u01ee\n)\f)\16)\u01f1\13)\3*\3*\3*\3*\3*\5*\u01f8"+
		"\n*\3+\3+\5+\u01fc\n+\3,\3,\3,\3,\3,\5,\u0203\n,\3-\3-\3-\5-\u0208\n-"+
		"\3-\3-\3.\3.\3.\3/\3/\3/\5/\u0212\n/\3\60\3\60\3\60\6\60\u0217\n\60\r"+
		"\60\16\60\u0218\3\60\3\60\3\61\3\61\3\61\3\61\5\61\u0221\n\61\3\61\5\61"+
		"\u0224\n\61\3\62\5\62\u0227\n\62\3\62\3\62\3\63\3\63\5\63\u022d\n\63\3"+
		"\63\3\63\3\63\3\64\3\64\3\64\3\65\3\65\3\65\5\65\u0238\n\65\3\65\3\65"+
		"\5\65\u023c\n\65\3\65\3\65\3\66\3\66\3\66\7\66\u0243\n\66\f\66\16\66\u0246"+
		"\13\66\3\67\3\67\3\67\3\67\38\38\38\39\39\79\u0251\n9\f9\169\u0254\13"+
		"9\39\39\3:\3:\3:\3:\5:\u025c\n:\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3"+
		";\3;\3;\3;\5;\u026e\n;\3<\3<\3=\3=\3=\3=\3>\3>\3>\3>\3?\3?\3?\3?\5?\u027e"+
		"\n?\3@\3@\3@\3@\3@\3@\3A\3A\3A\3B\3B\3B\3B\3B\3B\3B\5B\u0290\nB\3C\3C"+
		"\3C\3C\3C\5C\u0297\nC\3C\3C\3D\3D\3D\3D\5D\u029f\nD\3E\3E\3E\3E\3E\3E"+
		"\3E\3E\3E\5E\u02aa\nE\3F\3F\3F\3F\3F\3F\3F\5F\u02b3\nF\3G\3G\3G\3G\3G"+
		"\3G\3G\3G\3G\3G\3G\3G\5G\u02c1\nG\3H\3H\3H\3H\3I\3I\3I\3I\3I\3I\3I\3I"+
		"\3I\3I\5I\u02d1\nI\3J\3J\3J\3J\3J\3J\3J\3K\6K\u02db\nK\rK\16K\u02dc\3"+
		"L\3L\3L\3L\3L\3L\7L\u02e5\nL\fL\16L\u02e8\13L\3M\3M\3M\2\4LPN\2\4\6\b"+
		"\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVX"+
		"Z\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090"+
		"\u0092\u0094\u0096\u0098\2\r\3\2DI\3\2QR\4\2\20\20\67\67\5\2\16\16;;F"+
		"I\3\2\6\7\3\2\3\5\3\2>C\3\2<=\5\2\n\n//HI\3\2KL\4\2TTVV\u030b\2\u009b"+
		"\3\2\2\2\4\u00ba\3\2\2\2\6\u00bd\3\2\2\2\b\u00c6\3\2\2\2\n\u00c8\3\2\2"+
		"\2\f\u00ce\3\2\2\2\16\u00d9\3\2\2\2\20\u00e8\3\2\2\2\22\u00ea\3\2\2\2"+
		"\24\u00f4\3\2\2\2\26\u00f8\3\2\2\2\30\u0100\3\2\2\2\32\u0107\3\2\2\2\34"+
		"\u0109\3\2\2\2\36\u010d\3\2\2\2 \u011c\3\2\2\2\"\u012d\3\2\2\2$\u012f"+
		"\3\2\2\2&\u0136\3\2\2\2(\u0143\3\2\2\2*\u014b\3\2\2\2,\u0153\3\2\2\2."+
		"\u0167\3\2\2\2\60\u016a\3\2\2\2\62\u0171\3\2\2\2\64\u0173\3\2\2\2\66\u017f"+
		"\3\2\2\28\u0183\3\2\2\2:\u018e\3\2\2\2<\u0195\3\2\2\2>\u0197\3\2\2\2@"+
		"\u01a0\3\2\2\2B\u01a2\3\2\2\2D\u01a4\3\2\2\2F\u01ab\3\2\2\2H\u01ad\3\2"+
		"\2\2J\u01b1\3\2\2\2L\u01bf\3\2\2\2N\u01d8\3\2\2\2P\u01df\3\2\2\2R\u01f7"+
		"\3\2\2\2T\u01fb\3\2\2\2V\u0202\3\2\2\2X\u0204\3\2\2\2Z\u020b\3\2\2\2\\"+
		"\u0211\3\2\2\2^\u0213\3\2\2\2`\u0220\3\2\2\2b\u0226\3\2\2\2d\u022a\3\2"+
		"\2\2f\u0231\3\2\2\2h\u0234\3\2\2\2j\u023f\3\2\2\2l\u0247\3\2\2\2n\u024b"+
		"\3\2\2\2p\u024e\3\2\2\2r\u025b\3\2\2\2t\u026d\3\2\2\2v\u026f\3\2\2\2x"+
		"\u0271\3\2\2\2z\u0275\3\2\2\2|\u0279\3\2\2\2~\u027f\3\2\2\2\u0080\u0285"+
		"\3\2\2\2\u0082\u028f\3\2\2\2\u0084\u0291\3\2\2\2\u0086\u029a\3\2\2\2\u0088"+
		"\u02a9\3\2\2\2\u008a\u02b2\3\2\2\2\u008c\u02c0\3\2\2\2\u008e\u02c2\3\2"+
		"\2\2\u0090\u02d0\3\2\2\2\u0092\u02d2\3\2\2\2\u0094\u02da\3\2\2\2\u0096"+
		"\u02de\3\2\2\2\u0098\u02e9\3\2\2\2\u009a\u009c\5\u0094K\2\u009b\u009a"+
		"\3\2\2\2\u009b\u009c\3\2\2\2\u009c\u009d\3\2\2\2\u009d\u009e\7\34\2\2"+
		"\u009e\u009f\7T\2\2\u009f\u00a3\7\60\2\2\u00a0\u00a2\5\4\3\2\u00a1\u00a0"+
		"\3\2\2\2\u00a2\u00a5\3\2\2\2\u00a3\u00a1\3\2\2\2\u00a3\u00a4\3\2\2\2\u00a4"+
		"\u00a7\3\2\2\2\u00a5\u00a3\3\2\2\2\u00a6\u00a8\5\b\5\2\u00a7\u00a6\3\2"+
		"\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00a7\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa"+
		"\u00ab\3\2\2\2\u00ab\u00ac\7\2\2\3\u00ac\3\3\2\2\2\u00ad\u00ae\7\33\2"+
		"\2\u00ae\u00af\7\61\2\2\u00af\u00b3\5\6\4\2\u00b0\u00b2\5\6\4\2\u00b1"+
		"\u00b0\3\2\2\2\u00b2\u00b5\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b3\u00b4\3\2"+
		"\2\2\u00b4\u00b6\3\2\2\2\u00b5\u00b3\3\2\2\2\u00b6\u00b7\7\62\2\2\u00b7"+
		"\u00bb\3\2\2\2\u00b8\u00b9\7\33\2\2\u00b9\u00bb\5\6\4\2\u00ba\u00ad\3"+
		"\2\2\2\u00ba\u00b8\3\2\2\2\u00bb\5\3\2\2\2\u00bc\u00be\7T\2\2\u00bd\u00bc"+
		"\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf\u00c0\7P\2\2\u00c0"+
		"\7\3\2\2\2\u00c1\u00c7\5\"\22\2\u00c2\u00c7\5\20\t\2\u00c3\u00c7\5\n\6"+
		"\2\u00c4\u00c7\5\f\7\2\u00c5\u00c7\5&\24\2\u00c6\u00c1\3\2\2\2\u00c6\u00c2"+
		"\3\2\2\2\u00c6\u00c3\3\2\2\2\u00c6\u00c4\3\2\2\2\u00c6\u00c5\3\2\2\2\u00c7"+
		"\t\3\2\2\2\u00c8\u00c9\7\"\2\2\u00c9\u00cc\7T\2\2\u00ca\u00cd\5^\60\2"+
		"\u00cb\u00cd\5\u0088E\2\u00cc\u00ca\3\2\2\2\u00cc\u00cb\3\2\2\2\u00cd"+
		"\13\3\2\2\2\u00ce\u00cf\7\"\2\2\u00cf\u00d0\7T\2\2\u00d0\u00d1\7\13\2"+
		"\2\u00d1\u00d3\7\63\2\2\u00d2\u00d4\5\16\b\2\u00d3\u00d2\3\2\2\2\u00d4"+
		"\u00d5\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d5\u00d6\3\2\2\2\u00d6\u00d7\3\2"+
		"\2\2\u00d7\u00d8\7\64\2\2\u00d8\r\3\2\2\2\u00d9\u00da\7T\2\2\u00da\u00db"+
		"\5\36\20\2\u00db\u00dc\5(\25\2\u00dc\17\3\2\2\2\u00dd\u00de\7\17\2\2\u00de"+
		"\u00e0\7\61\2\2\u00df\u00e1\5\22\n\2\u00e0\u00df\3\2\2\2\u00e1\u00e2\3"+
		"\2\2\2\u00e2\u00e0\3\2\2\2\u00e2\u00e3\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4"+
		"\u00e5\7\62\2\2\u00e5\u00e9\3\2\2\2\u00e6\u00e7\7\17\2\2\u00e7\u00e9\5"+
		"\22\n\2\u00e8\u00dd\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e9\21\3\2\2\2\u00ea"+
		"\u00f2\5\26\f\2\u00eb\u00ee\5\u0088E\2\u00ec\u00ed\7\67\2\2\u00ed\u00ef"+
		"\5J&\2\u00ee\u00ec\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f3\3\2\2\2\u00f0"+
		"\u00f1\7\67\2\2\u00f1\u00f3\5J&\2\u00f2\u00eb\3\2\2\2\u00f2\u00f0\3\2"+
		"\2\2\u00f3\23\3\2\2\2\u00f4\u00f5\5\26\f\2\u00f5\u00f6\7\20\2\2\u00f6"+
		"\u00f7\5J&\2\u00f7\25\3\2\2\2\u00f8\u00fd\7T\2\2\u00f9\u00fa\78\2\2\u00fa"+
		"\u00fc\7T\2\2\u00fb\u00f9\3\2\2\2\u00fc\u00ff\3\2\2\2\u00fd\u00fb\3\2"+
		"\2\2\u00fd\u00fe\3\2\2\2\u00fe\27\3\2\2\2\u00ff\u00fd\3\2\2\2\u0100\u0102"+
		"\5J&\2\u0101\u0103\5\32\16\2\u0102\u0101\3\2\2\2\u0102\u0103\3\2\2\2\u0103"+
		"\u0104\3\2\2\2\u0104\u0105\7\67\2\2\u0105\u0106\5J&\2\u0106\31\3\2\2\2"+
		"\u0107\u0108\t\2\2\2\u0108\33\3\2\2\2\u0109\u010a\7\65\2\2\u010a\u010b"+
		"\5L\'\2\u010b\u010c\7\66\2\2\u010c\35\3\2\2\2\u010d\u0117\7\61\2\2\u010e"+
		"\u0118\5J&\2\u010f\u0114\5 \21\2\u0110\u0111\78\2\2\u0111\u0113\5 \21"+
		"\2\u0112\u0110\3\2\2\2\u0113\u0116\3\2\2\2\u0114\u0112\3\2\2\2\u0114\u0115"+
		"\3\2\2\2\u0115\u0118\3\2\2\2\u0116\u0114\3\2\2\2\u0117\u010e\3\2\2\2\u0117"+
		"\u010f\3\2\2\2\u0117\u0118\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011a\7\62"+
		"\2\2\u011a\37\3\2\2\2\u011b\u011d\5\26\f\2\u011c\u011b\3\2\2\2\u011c\u011d"+
		"\3\2\2\2\u011d\u011e\3\2\2\2\u011e\u011f\5\u0088E\2\u011f!\3\2\2\2\u0120"+
		"\u0121\7$\2\2\u0121\u012e\5$\23\2\u0122\u0123\7$\2\2\u0123\u0124\7\61"+
		"\2\2\u0124\u0128\5$\23\2\u0125\u0127\5$\23\2\u0126\u0125\3\2\2\2\u0127"+
		"\u012a\3\2\2\2\u0128\u0126\3\2\2\2\u0128\u0129\3\2\2\2\u0129\u012b\3\2"+
		"\2\2\u012a\u0128\3\2\2\2\u012b\u012c\7\62\2\2\u012c\u012e\3\2\2\2\u012d"+
		"\u0120\3\2\2\2\u012d\u0122\3\2\2\2\u012e#\3\2\2\2\u012f\u0131\7T\2\2\u0130"+
		"\u0132\5\u0088E\2\u0131\u0130\3\2\2\2\u0131\u0132\3\2\2\2\u0132\u0133"+
		"\3\2\2\2\u0133\u0134\7\67\2\2\u0134\u0135\5\62\32\2\u0135%\3\2\2\2\u0136"+
		"\u0138\7#\2\2\u0137\u0139\5*\26\2\u0138\u0137\3\2\2\2\u0138\u0139\3\2"+
		"\2\2\u0139\u013b\3\2\2\2\u013a\u013c\7T\2\2\u013b\u013a\3\2\2\2\u013b"+
		"\u013c\3\2\2\2\u013c\u013d\3\2\2\2\u013d\u013f\5\36\20\2\u013e\u0140\5"+
		"(\25\2\u013f\u013e\3\2\2\2\u013f\u0140\3\2\2\2\u0140\u0141\3\2\2\2\u0141"+
		"\u0142\5p9\2\u0142\'\3\2\2\2\u0143\u0148\5\u0088E\2\u0144\u0145\78\2\2"+
		"\u0145\u0147\5\u0088E\2\u0146\u0144\3\2\2\2\u0147\u014a\3\2\2\2\u0148"+
		"\u0146\3\2\2\2\u0148\u0149\3\2\2\2\u0149)\3\2\2\2\u014a\u0148\3\2\2\2"+
		"\u014b\u014c\7\61\2\2\u014c\u014e\7T\2\2\u014d\u014f\7I\2\2\u014e\u014d"+
		"\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0151\5\u0088E"+
		"\2\u0151\u0152\7\62\2\2\u0152+\3\2\2\2\u0153\u0154\7&\2\2\u0154\u0155"+
		"\5@!\2\u0155\u0157\7\63\2\2\u0156\u0158\5.\30\2\u0157\u0156\3\2\2\2\u0158"+
		"\u0159\3\2\2\2\u0159\u0157\3\2\2\2\u0159\u015a\3\2\2\2\u015a\u015b\3\2"+
		"\2\2\u015b\u015c\7\64\2\2\u015c-\3\2\2\2\u015d\u015e\7\'\2\2\u015e\u015f"+
		"\5J&\2\u015f\u0160\7:\2\2\u0160\u0162\5\60\31\2\u0161\u0163\7+\2\2\u0162"+
		"\u0161\3\2\2\2\u0162\u0163\3\2\2\2\u0163\u0168\3\2\2\2\u0164\u0165\7\32"+
		"\2\2\u0165\u0166\7:\2\2\u0166\u0168\5\60\31\2\u0167\u015d\3\2\2\2\u0167"+
		"\u0164\3\2\2\2\u0168/\3\2\2\2\u0169\u016b\5t;\2\u016a\u0169\3\2\2\2\u016b"+
		"\u016c\3\2\2\2\u016c\u016a\3\2\2\2\u016c\u016d\3\2\2\2\u016d\61\3\2\2"+
		"\2\u016e\u0172\7U\2\2\u016f\u0172\t\3\2\2\u0170\u0172\7O\2\2\u0171\u016e"+
		"\3\2\2\2\u0171\u016f\3\2\2\2\u0171\u0170\3\2\2\2\u0172\63\3\2\2\2\u0173"+
		"\u0178\5\66\34\2\u0174\u0175\7-\2\2\u0175\u0177\5\66\34\2\u0176\u0174"+
		"\3\2\2\2\u0177\u017a\3\2\2\2\u0178\u0176\3\2\2\2\u0178\u0179\3\2\2\2\u0179"+
		"\u017d\3\2\2\2\u017a\u0178\3\2\2\2\u017b\u017c\7-\2\2\u017c\u017e\5p9"+
		"\2\u017d\u017b\3\2\2\2\u017d\u017e\3\2\2\2\u017e\65\3\2\2\2\u017f\u0180"+
		"\7.\2\2\u0180\u0181\5@!\2\u0181\u0182\5p9\2\u0182\67\3\2\2\2\u0183\u0187"+
		"\7(\2\2\u0184\u0188\5:\36\2\u0185\u0188\5D#\2\u0186\u0188\5@!\2\u0187"+
		"\u0184\3\2\2\2\u0187\u0185\3\2\2\2\u0187\u0186\3\2\2\2\u0188\u0189\3\2"+
		"\2\2\u0189\u018a\5p9\2\u018a9\3\2\2\2\u018b\u018c\5<\37\2\u018c\u018d"+
		"\7\60\2\2\u018d\u018f\3\2\2\2\u018e\u018b\3\2\2\2\u018e\u018f\3\2\2\2"+
		"\u018f\u0190\3\2\2\2\u0190\u0193\5@!\2\u0191\u0192\7\60\2\2\u0192\u0194"+
		"\5B\"\2\u0193\u0191\3\2\2\2\u0193\u0194\3\2\2\2\u0194;\3\2\2\2\u0195\u0196"+
		"\5V,\2\u0196=\3\2\2\2\u0197\u0198\7\63\2\2\u0198\u0199\7\64\2\2\u0199"+
		"?\3\2\2\2\u019a\u01a1\5L\'\2\u019b\u019e\5V,\2\u019c\u019d\7\60\2\2\u019d"+
		"\u019f\5L\'\2\u019e\u019c\3\2\2\2\u019e\u019f\3\2\2\2\u019f\u01a1\3\2"+
		"\2\2\u01a0\u019a\3\2\2\2\u01a0\u019b\3\2\2\2\u01a1A\3\2\2\2\u01a2\u01a3"+
		"\5V,\2\u01a3C\3\2\2\2\u01a4\u01a5\5P)\2\u01a5\u01a6\78\2\2\u01a6\u01a7"+
		"\5P)\2\u01a7\u01a8\t\4\2\2\u01a8\u01a9\7\f\2\2\u01a9\u01aa\5F$\2\u01aa"+
		"E\3\2\2\2\u01ab\u01ac\5L\'\2\u01acG\3\2\2\2\u01ad\u01af\7)\2\2\u01ae\u01b0"+
		"\5J&\2\u01af\u01ae\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0I\3\2\2\2\u01b1\u01b6"+
		"\5L\'\2\u01b2\u01b3\78\2\2\u01b3\u01b5\5L\'\2\u01b4\u01b2\3\2\2\2\u01b5"+
		"\u01b8\3\2\2\2\u01b6\u01b4\3\2\2\2\u01b6\u01b7\3\2\2\2\u01b7K\3\2\2\2"+
		"\u01b8\u01b6\3\2\2\2\u01b9\u01ba\b\'\1\2\u01ba\u01bb\7\61\2\2\u01bb\u01bc"+
		"\5L\'\2\u01bc\u01bd\7\62\2\2\u01bd\u01c0\3\2\2\2\u01be\u01c0\5N(\2\u01bf"+
		"\u01b9\3\2\2\2\u01bf\u01be\3\2\2\2\u01c0\u01d2\3\2\2\2\u01c1\u01c2\f\7"+
		"\2\2\u01c2\u01c3\t\5\2\2\u01c3\u01d1\5L\'\b\u01c4\u01c5\f\6\2\2\u01c5"+
		"\u01c6\t\6\2\2\u01c6\u01d1\5L\'\7\u01c7\u01c8\f\5\2\2\u01c8\u01c9\t\7"+
		"\2\2\u01c9\u01d1\5L\'\6\u01ca\u01cb\f\4\2\2\u01cb\u01cc\t\b\2\2\u01cc"+
		"\u01d1\5L\'\5\u01cd\u01ce\f\3\2\2\u01ce\u01cf\t\t\2\2\u01cf\u01d1\5L\'"+
		"\4\u01d0\u01c1\3\2\2\2\u01d0\u01c4\3\2\2\2\u01d0\u01c7\3\2\2\2\u01d0\u01ca"+
		"\3\2\2\2\u01d0\u01cd\3\2\2\2\u01d1\u01d4\3\2\2\2\u01d2\u01d0\3\2\2\2\u01d2"+
		"\u01d3\3\2\2\2\u01d3M\3\2\2\2\u01d4\u01d2\3\2\2\2\u01d5\u01d6\t\n\2\2"+
		"\u01d6\u01d9\5P)\2\u01d7\u01d9\5P)\2\u01d8\u01d5\3\2\2\2\u01d8\u01d7\3"+
		"\2\2\2\u01d9O\3\2\2\2\u01da\u01db\b)\1\2\u01db\u01dc\5R*\2\u01dc\u01dd"+
		"\b)\1\2\u01dd\u01e0\3\2\2\2\u01de\u01e0\5T+\2\u01df\u01da\3\2\2\2\u01df"+
		"\u01de\3\2\2\2\u01e0\u01ef\3\2\2\2\u01e1\u01e2\f\5\2\2\u01e2\u01e3\5\34"+
		"\17\2\u01e3\u01e4\b)\1\2\u01e4\u01ee\3\2\2\2\u01e5\u01e6\f\4\2\2\u01e6"+
		"\u01e7\5n8\2\u01e7\u01e8\b)\1\2\u01e8\u01ee\3\2\2\2\u01e9\u01ea\f\3\2"+
		"\2\u01ea\u01eb\5\36\20\2\u01eb\u01ec\b)\1\2\u01ec\u01ee\3\2\2\2\u01ed"+
		"\u01e1\3\2\2\2\u01ed\u01e5\3\2\2\2\u01ed\u01e9\3\2\2\2\u01ee\u01f1\3\2"+
		"\2\2\u01ef\u01ed\3\2\2\2\u01ef\u01f0\3\2\2\2\u01f0Q\3\2\2\2\u01f1\u01ef"+
		"\3\2\2\2\u01f2\u01f3\7T\2\2\u01f3\u01f8\b*\1\2\u01f4\u01f5\5\62\32\2\u01f5"+
		"\u01f6\b*\1\2\u01f6\u01f8\3\2\2\2\u01f7\u01f2\3\2\2\2\u01f7\u01f4\3\2"+
		"\2\2\u01f8S\3\2\2\2\u01f9\u01fc\5X-\2\u01fa\u01fc\5Z.\2\u01fb\u01f9\3"+
		"\2\2\2\u01fb\u01fa\3\2\2\2\u01fcU\3\2\2\2\u01fd\u0203\3\2\2\2\u01fe\u0203"+
		"\5f\64\2\u01ff\u0203\5\30\r\2\u0200\u0203\5\24\13\2\u0201\u0203\5L\'\2"+
		"\u0202\u01fd\3\2\2\2\u0202\u01fe\3\2\2\2\u0202\u01ff\3\2\2\2\u0202\u0200"+
		"\3\2\2\2\u0202\u0201\3\2\2\2\u0203W\3\2\2\2\u0204\u0205\7#\2\2\u0205\u0207"+
		"\5\36\20\2\u0206\u0208\5(\25\2\u0207\u0206\3\2\2\2\u0207\u0208\3\2\2\2"+
		"\u0208\u0209\3\2\2\2\u0209\u020a\5p9\2\u020aY\3\2\2\2\u020b\u020c\5\\"+
		"/\2\u020c\u020d\5h\65\2\u020d[\3\2\2\2\u020e\u0212\5\u008cG\2\u020f\u0212"+
		"\5^\60\2\u0210\u0212\5d\63\2\u0211\u020e\3\2\2\2\u0211\u020f\3\2\2\2\u0211"+
		"\u0210\3\2\2\2\u0212]\3\2\2\2\u0213\u0214\7\r\2\2\u0214\u0216\7\63\2\2"+
		"\u0215\u0217\5`\61\2\u0216\u0215\3\2\2\2\u0217\u0218\3\2\2\2\u0218\u0216"+
		"\3\2\2\2\u0218\u0219\3\2\2\2\u0219\u021a\3\2\2\2\u021a\u021b\7\64\2\2"+
		"\u021b_\3\2\2\2\u021c\u021d\5\26\f\2\u021d\u021e\5\u0088E\2\u021e\u0221"+
		"\3\2\2\2\u021f\u0221\5b\62\2\u0220\u021c\3\2\2\2\u0220\u021f\3\2\2\2\u0221"+
		"\u0223\3\2\2\2\u0222\u0224\7P\2\2\u0223\u0222\3\2\2\2\u0223\u0224\3\2"+
		"\2\2\u0224a\3\2\2\2\u0225\u0227\7I\2\2\u0226\u0225\3\2\2\2\u0226\u0227"+
		"\3\2\2\2\u0227\u0228\3\2\2\2\u0228\u0229\5\u008cG\2\u0229c\3\2\2\2\u022a"+
		"\u022c\7\65\2\2\u022b\u022d\5L\'\2\u022c\u022b\3\2\2\2\u022c\u022d\3\2"+
		"\2\2\u022d\u022e\3\2\2\2\u022e\u022f\7\66\2\2\u022f\u0230\5\u008cG\2\u0230"+
		"e\3\2\2\2\u0231\u0232\5L\'\2\u0232\u0233\t\13\2\2\u0233g\3\2\2\2\u0234"+
		"\u023b\7\63\2\2\u0235\u0238\5J&\2\u0236\u0238\5j\66\2\u0237\u0235\3\2"+
		"\2\2\u0237\u0236\3\2\2\2\u0238\u0239\3\2\2\2\u0239\u023a\78\2\2\u023a"+
		"\u023c\3\2\2\2\u023b\u0237\3\2\2\2\u023b\u023c\3\2\2\2\u023c\u023d\3\2"+
		"\2\2\u023d\u023e\7\64\2\2\u023ei\3\2\2\2\u023f\u0244\5l\67\2\u0240\u0241"+
		"\78\2\2\u0241\u0243\5l\67\2\u0242\u0240\3\2\2\2\u0243\u0246\3\2\2\2\u0244"+
		"\u0242\3\2\2\2\u0244\u0245\3\2\2\2\u0245k\3\2\2\2\u0246\u0244\3\2\2\2"+
		"\u0247\u0248\7T\2\2\u0248\u0249\7:\2\2\u0249\u024a\5L\'\2\u024am\3\2\2"+
		"\2\u024b\u024c\79\2\2\u024c\u024d\7T\2\2\u024do\3\2\2\2\u024e\u0252\7"+
		"\63\2\2\u024f\u0251\5t;\2\u0250\u024f\3\2\2\2\u0251\u0254\3\2\2\2\u0252"+
		"\u0250\3\2\2\2\u0252\u0253\3\2\2\2\u0253\u0255\3\2\2\2\u0254\u0252\3\2"+
		"\2\2\u0255\u0256\7\64\2\2\u0256q\3\2\2\2\u0257\u025c\3\2\2\2\u0258\u0259"+
		"\5P)\2\u0259\u025a\5\36\20\2\u025a\u025c\3\2\2\2\u025b\u0257\3\2\2\2\u025b"+
		"\u0258\3\2\2\2\u025cs\3\2\2\2\u025d\u026e\5\24\13\2\u025e\u026e\5\20\t"+
		"\2\u025f\u026e\5\30\r\2\u0260\u026e\5\"\22\2\u0261\u026e\5f\64\2\u0262"+
		"\u026e\5P)\2\u0263\u026e\5x=\2\u0264\u026e\5H%\2\u0265\u026e\5\u0086D"+
		"\2\u0266\u026e\5z>\2\u0267\u026e\5v<\2\u0268\u026e\5\64\33\2\u0269\u026e"+
		"\58\35\2\u026a\u026e\5,\27\2\u026b\u026e\5\u0082B\2\u026c\u026e\5|?\2"+
		"\u026d\u025d\3\2\2\2\u026d\u025e\3\2\2\2\u026d\u025f\3\2\2\2\u026d\u0260"+
		"\3\2\2\2\u026d\u0261\3\2\2\2\u026d\u0262\3\2\2\2\u026d\u0263\3\2\2\2\u026d"+
		"\u0264\3\2\2\2\u026d\u0265\3\2\2\2\u026d\u0266\3\2\2\2\u026d\u0267\3\2"+
		"\2\2\u026d\u0268\3\2\2\2\u026d\u0269\3\2\2\2\u026d\u026a\3\2\2\2\u026d"+
		"\u026b\3\2\2\2\u026d\u026c\3\2\2\2\u026eu\3\2\2\2\u026f\u0270\7\22\2\2"+
		"\u0270w\3\2\2\2\u0271\u0272\7T\2\2\u0272\u0273\7:\2\2\u0273\u0274\5t;"+
		"\2\u0274y\3\2\2\2\u0275\u0276\7,\2\2\u0276\u0277\5L\'\2\u0277\u0278\7"+
		"\60\2\2\u0278{\3\2\2\2\u0279\u027a\7\27\2\2\u027a\u027b\5p9\2\u027b\u027d"+
		"\5~@\2\u027c\u027e\5\u0080A\2\u027d\u027c\3\2\2\2\u027d\u027e\3\2\2\2"+
		"\u027e}\3\2\2\2\u027f\u0280\7\30\2\2\u0280\u0281\7\61\2\2\u0281\u0282"+
		"\5\20\t\2\u0282\u0283\7\62\2\2\u0283\u0284\5p9\2\u0284\177\3\2\2\2\u0285"+
		"\u0286\7\31\2\2\u0286\u0287\5p9\2\u0287\u0081\3\2\2\2\u0288\u0289\7\21"+
		"\2\2\u0289\u028a\7T\2\2\u028a\u0290\bB\1\2\u028b\u028c\7*\2\2\u028c\u0290"+
		"\bB\1\2\u028d\u028e\7+\2\2\u028e\u0290\bB\1\2\u028f\u0288\3\2\2\2\u028f"+
		"\u028b\3\2\2\2\u028f\u028d\3\2\2\2\u0290\u0083\3\2\2\2\u0291\u0292\7\25"+
		"\2\2\u0292\u0293\7\61\2\2\u0293\u0296\5\u0088E\2\u0294\u0295\78\2\2\u0295"+
		"\u0297\7U\2\2\u0296\u0294\3\2\2\2\u0296\u0297\3\2\2\2\u0297\u0298\3\2"+
		"\2\2\u0298\u0299\7\62\2\2\u0299\u0085\3\2\2\2\u029a\u029b\7\26\2\2\u029b"+
		"\u029e\5L\'\2\u029c\u029d\78\2\2\u029d\u029f\5L\'\2\u029e\u029c\3\2\2"+
		"\2\u029e\u029f\3\2\2\2\u029f\u0087\3\2\2\2\u02a0\u02a1\5\u008cG\2\u02a1"+
		"\u02a2\bE\1\2\u02a2\u02aa\3\2\2\2\u02a3\u02a4\5\u008aF\2\u02a4\u02a5\b"+
		"E\1\2\u02a5\u02aa\3\2\2\2\u02a6\u02a7\5\u0092J\2\u02a7\u02a8\bE\1\2\u02a8"+
		"\u02aa\3\2\2\2\u02a9\u02a0\3\2\2\2\u02a9\u02a3\3\2\2\2\u02a9\u02a6\3\2"+
		"\2\2\u02aa\u0089\3\2\2\2\u02ab\u02ac\5\u008cG\2\u02ac\u02ad\bF\1\2\u02ad"+
		"\u02b3\3\2\2\2\u02ae\u02af\5\34\17\2\u02af\u02b0\5\u008aF\2\u02b0\u02b1"+
		"\bF\1\2\u02b1\u02b3\3\2\2\2\u02b2\u02ab\3\2\2\2\u02b2\u02ae\3\2\2\2\u02b3"+
		"\u008b\3\2\2\2\u02b4\u02b5\7T\2\2\u02b5\u02c1\bG\1\2\u02b6\u02b7\5\u008e"+
		"H\2\u02b7\u02b8\bG\1\2\u02b8\u02c1\3\2\2\2\u02b9\u02ba\5\u0090I\2\u02ba"+
		"\u02bb\bG\1\2\u02bb\u02c1\3\2\2\2\u02bc\u02bd\7I\2\2\u02bd\u02be\5\u008c"+
		"G\2\u02be\u02bf\bG\1\2\u02bf\u02c1\3\2\2\2\u02c0\u02b4\3\2\2\2\u02c0\u02b6"+
		"\3\2\2\2\u02c0\u02b9\3\2\2\2\u02c0\u02bc\3\2\2\2\u02c1\u008d\3\2\2\2\u02c2"+
		"\u02c3\7T\2\2\u02c3\u02c4\79\2\2\u02c4\u02c5\7T\2\2\u02c5\u008f\3\2\2"+
		"\2\u02c6\u02c7\7\36\2\2\u02c7\u02d1\bI\1\2\u02c8\u02c9\7 \2\2\u02c9\u02d1"+
		"\bI\1\2\u02ca\u02cb\7\37\2\2\u02cb\u02d1\bI\1\2\u02cc\u02cd\7!\2\2\u02cd"+
		"\u02d1\bI\1\2\u02ce\u02cf\7\24\2\2\u02cf\u02d1\bI\1\2\u02d0\u02c6\3\2"+
		"\2\2\u02d0\u02c8\3\2\2\2\u02d0\u02ca\3\2\2\2\u02d0\u02cc\3\2\2\2\u02d0"+
		"\u02ce\3\2\2\2\u02d1\u0091\3\2\2\2\u02d2\u02d3\7\23\2\2\u02d3\u02d4\7"+
		"\65\2\2\u02d4\u02d5\5\u0088E\2\u02d5\u02d6\7\66\2\2\u02d6\u02d7\5\u0088"+
		"E\2\u02d7\u02d8\bJ\1\2\u02d8\u0093\3\2\2\2\u02d9\u02db\5\u0096L\2\u02da"+
		"\u02d9\3\2\2\2\u02db\u02dc\3\2\2\2\u02dc\u02da\3\2\2\2\u02dc\u02dd\3\2"+
		"\2\2\u02dd\u0095\3\2\2\2\u02de\u02df\7\b\2\2\u02df\u02e0\7T\2\2\u02e0"+
		"\u02e1\7:\2\2\u02e1\u02e6\5\u0098M\2\u02e2\u02e3\78\2\2\u02e3\u02e5\5"+
		"\u0098M\2\u02e4\u02e2\3\2\2\2\u02e5\u02e8\3\2\2\2\u02e6\u02e4\3\2\2\2"+
		"\u02e6\u02e7\3\2\2\2\u02e7\u0097\3\2\2\2\u02e8\u02e6\3\2\2\2\u02e9\u02ea"+
		"\t\f\2\2\u02ea\u0099\3\2\2\2K\u009b\u00a3\u00a9\u00b3\u00ba\u00bd\u00c6"+
		"\u00cc\u00d5\u00e2\u00e8\u00ee\u00f2\u00fd\u0102\u0114\u0117\u011c\u0128"+
		"\u012d\u0131\u0138\u013b\u013f\u0148\u014e\u0159\u0162\u0167\u016c\u0171"+
		"\u0178\u017d\u0187\u018e\u0193\u019e\u01a0\u01af\u01b6\u01bf\u01d0\u01d2"+
		"\u01d8\u01df\u01ed\u01ef\u01f7\u01fb\u0202\u0207\u0211\u0218\u0220\u0223"+
		"\u0226\u022c\u0237\u023b\u0244\u0252\u025b\u026d\u027d\u028f\u0296\u029e"+
		"\u02a9\u02b2\u02c0\u02d0\u02dc\u02e6";
	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);
		}
	}
}