// 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
		BUILD_TARGET=1, R_BIT_AND=2, R_BIT_XOR=3, R_BIT_OR=4, R_SHIFT_LEFT=5, 
		R_SHIFT_RIGHT=6, R_AT=7, R_DBL_SLASH=8, R_REFERENCE=9, R_INTERFACE=10, 
		R_RANGE=11, R_STRUCT=12, R_OP_MOD=13, R_VAR=14, R_SHORT_VAR=15, R_GOTO=16, 
		R_FALLTHROUGH=17, R_MAP=18, R_ERROR=19, R_NEW=20, R_DELETE=21, R_TRY=22, 
		R_CATCH=23, R_FINALLY=24, R_DEFAULT=25, R_IMPORTE=26, R_PACKAGE=27, R_TRAP=28, 
		R_INT=29, R_CHAR=30, R_BOOL=31, R_STRING=32, R_TIPO=33, R_FUNCTION=34, 
		R_CONSTANTE=35, R_IN=36, R_SWITCH=37, R_CASE=38, R_FOR=39, R_RETURN=40, 
		R_CONTINUE=41, R_BREAK=42, R_THROW=43, R_ELSE=44, R_IF=45, R_EXCLAMATION=46, 
		R_PT_VIRG=47, R_PAR_E=48, R_PAR_D=49, R_COL_E=50, R_COL_D=51, R_CHA_E=52, 
		R_CHA_D=53, R_EQ=54, R_VIRGULA=55, R_PONTO=56, R_COLON=57, R_END=58, R_AND=59, 
		R_OR=60, R_COMP_EQ=61, R_COMP_DIFF=62, R_COMP_LTE=63, R_COMP_LT=64, R_COMP_GTE=65, 
		R_COMP_GT=66, R_ASSIG_EXTEND=67, R_ASSIG_COPY=68, R_OP_DIV=69, R_OP_ADD=70, 
		R_OP_SUB=71, R_OP_AST=72, R_OP_NEG=73, R_OP_SS=74, R_OP_PP=75, R_UND=76, 
		R_INTERROGATION=77, T_CHAR=78, T_STRING=79, T_BOOL_TRUE=80, T_BOOL_FALSE=81, 
		T_NULL=82, ID=83, T_INTEIRO=84, R_LINE_COMMENT=85, R_WS=86, R_COMMENT=87;
	public static final String[] tokenNames = {
		"<INVALID>", "'target'", "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_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_test = 30, RULE_increment = 31, RULE_for_each = 32, RULE_range = 33, 
		RULE_return_stmt = 34, RULE_expression_list = 35, RULE_expression = 36, 
		RULE_unary_expr = 37, RULE_primary_expr = 38, RULE_operand = 39, RULE_literal = 40, 
		RULE_base_stmt = 41, RULE_func_literal = 42, RULE_composite = 43, RULE_literalType = 44, 
		RULE_structType = 45, RULE_fieldDecl = 46, RULE_anon_field = 47, RULE_arrayType = 48, 
		RULE_inc_dec = 49, RULE_literal_value = 50, RULE_element_list = 51, RULE_keyed_element = 52, 
		RULE_expression_seletor = 53, RULE_def_block = 54, RULE_callExpr = 55, 
		RULE_statement = 56, RULE_fallthroughStmt = 57, RULE_label_stmt = 58, 
		RULE_throwStmt = 59, RULE_try_catch = 60, RULE_catch_exception = 61, RULE_finally_try = 62, 
		RULE_flux_control = 63, RULE_newstmt = 64, RULE_delete = 65, RULE_type = 66, 
		RULE_indexedType = 67, RULE_typename = 68, RULE_qualifiedId = 69, RULE_baseType = 70, 
		RULE_mapType = 71, RULE_buildtags = 72, RULE_build_stmt = 73, RULE_buildtag = 74;
	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", "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", "buildtag"
	};

	@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(151);
			_la = _input.LA(1);
			if (_la==R_AT) {
				{
				setState(150); buildtags();
				}
			}

			setState(153); match(R_PACKAGE);
			setState(154); match(ID);
			setState(155); match(R_PT_VIRG);
			setState(159);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==R_IMPORTE) {
				{
				{
				setState(156); imports();
				}
				}
				setState(161);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(163); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(162); programPart();
				}
				}
				setState(165); 
				_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(167); 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(182);
			switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(169); match(R_IMPORTE);
				setState(170); match(R_PAR_E);
				setState(171); import_part();
				setState(175);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T_STRING || _la==ID) {
					{
					{
					setState(172); import_part();
					}
					}
					setState(177);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(178); match(R_PAR_D);
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(180); match(R_IMPORTE);
				setState(181); 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(185);
			_la = _input.LA(1);
			if (_la==ID) {
				{
				setState(184); match(ID);
				}
			}

			setState(187); 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(194);
			switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(189); dec_const();
				}
				break;

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

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

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

			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(193); 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(196); match(R_TIPO);
			setState(197); match(ID);
			setState(200);
			switch (_input.LA(1)) {
			case R_STRUCT:
				{
				setState(198); 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(199); 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(202); match(R_TIPO);
			setState(203); match(ID);
			setState(204); match(R_INTERFACE);
			setState(205); match(R_COL_E);
			setState(207); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(206); func_spec();
				}
				}
				setState(209); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==ID );
			setState(211); 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(213); match(ID);
			setState(214); arguments();
			setState(215); 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(228);
			switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(217); match(R_VAR);
				setState(218); match(R_PAR_E);
				setState(220); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(219); dec_var_part();
					}
					}
					setState(222); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==ID );
				setState(224); match(R_PAR_D);
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(226); match(R_VAR);
				setState(227); 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(230); id_list();
			setState(238);
			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(231); type();
				setState(234);
				_la = _input.LA(1);
				if (_la==R_EQ) {
					{
					setState(232); match(R_EQ);
					setState(233); expression_list();
					}
				}

				}
				break;
			case R_EQ:
				{
				setState(236); match(R_EQ);
				setState(237); 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(240); id_list();
			setState(241); match(R_SHORT_VAR);
			setState(242); 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(244); match(ID);
			setState(249);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==R_VIRGULA) {
				{
				{
				setState(245); match(R_VIRGULA);
				setState(246); match(ID);
				}
				}
				setState(251);
				_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(252); expression_list();
			setState(254);
			_la = _input.LA(1);
			if (((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (R_ASSIG_EXTEND - 67)) | (1L << (R_ASSIG_COPY - 67)) | (1L << (R_OP_DIV - 67)) | (1L << (R_OP_ADD - 67)) | (1L << (R_OP_SUB - 67)) | (1L << (R_OP_AST - 67)))) != 0)) {
				{
				setState(253); assign_modify();
				}
			}

			setState(256); match(R_EQ);
			setState(257); 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(259);
			_la = _input.LA(1);
			if ( !(((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (R_ASSIG_EXTEND - 67)) | (1L << (R_ASSIG_COPY - 67)) | (1L << (R_OP_DIV - 67)) | (1L << (R_OP_ADD - 67)) | (1L << (R_OP_SUB - 67)) | (1L << (R_OP_AST - 67)))) != 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(261); match(R_CHA_E);
			setState(262); expression(0);
			setState(263); 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(265); match(R_PAR_E);
			setState(275);
			switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
			case 1:
				{
				setState(266); expression_list();
				}
				break;

			case 2:
				{
				setState(267); expression_list_typed();
				setState(272);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==R_VIRGULA) {
					{
					{
					setState(268); match(R_VIRGULA);
					setState(269); expression_list_typed();
					}
					}
					setState(274);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			}
			setState(277); 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(280);
			switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
			case 1:
				{
				setState(279); id_list();
				}
				break;
			}
			setState(282); 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(297);
			switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(284); match(R_CONSTANTE);
				setState(285); dec_const_part();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(286); match(R_CONSTANTE);
				setState(287); match(R_PAR_E);
				setState(288); dec_const_part();
				setState(292);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==ID) {
					{
					{
					setState(289); dec_const_part();
					}
					}
					setState(294);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(295); 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(299); match(ID);
			setState(301);
			_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(300); type();
				}
			}

			setState(303); match(R_EQ);
			setState(304); 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(306); match(R_FUNCTION);
			setState(308);
			switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
			case 1:
				{
				setState(307); receive_type();
				}
				break;
			}
			setState(311);
			_la = _input.LA(1);
			if (_la==ID) {
				{
				setState(310); ((Def_functionContext)_localctx).name = match(ID);
				}
			}

			setState(313); arguments();
			setState(315);
			_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(314); return_dec();
				}
			}

			setState(317); 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(319); type();
			setState(324);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==R_VIRGULA) {
				{
				{
				setState(320); match(R_VIRGULA);
				setState(321); type();
				}
				}
				setState(326);
				_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(327); match(R_PAR_E);
			setState(328); match(ID);
			setState(330);
			switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
			case 1:
				{
				setState(329); match(R_OP_AST);
				}
				break;
			}
			setState(332); type();
			setState(333); 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(335); match(R_SWITCH);
			setState(336); test();
			setState(337); match(R_COL_E);
			setState(339); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(338); def_case();
				}
				}
				setState(341); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==R_DEFAULT || _la==R_CASE );
			setState(343); 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(355);
			switch (_input.LA(1)) {
			case R_CASE:
				enterOuterAlt(_localctx, 1);
				{
				setState(345); match(R_CASE);
				setState(346); expression_list();
				setState(347); match(R_COLON);
				setState(348); statement_list();
				setState(350);
				_la = _input.LA(1);
				if (_la==R_BREAK) {
					{
					setState(349); match(R_BREAK);
					}
				}

				}
				break;
			case R_DEFAULT:
				enterOuterAlt(_localctx, 2);
				{
				setState(352); match(R_DEFAULT);
				setState(353); match(R_COLON);
				setState(354); 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(358); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(357); statement();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(360); 
				_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(365);
			switch (_input.LA(1)) {
			case T_INTEIRO:
				enterOuterAlt(_localctx, 1);
				{
				setState(362); match(T_INTEIRO);
				}
				break;
			case T_BOOL_TRUE:
			case T_BOOL_FALSE:
				enterOuterAlt(_localctx, 2);
				{
				setState(363);
				_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(364); 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(367); def_if_block();
			setState(372);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
			while ( _alt!=2 && _alt!=ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(368); match(R_ELSE);
					setState(369); def_if_block();
					}
					} 
				}
				setState(374);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
			}
			setState(377);
			_la = _input.LA(1);
			if (_la==R_ELSE) {
				{
				setState(375); match(R_ELSE);
				setState(376); 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(379); match(R_IF);
			setState(380); test();
			setState(381); 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 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(383); match(R_FOR);
			setState(386);
			switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
			case 1:
				{
				setState(384); for_clause();
				}
				break;

			case 2:
				{
				setState(385); for_each();
				}
				break;
			}
			setState(388); 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(393);
			switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
			case 1:
				{
				setState(390); initialization();
				setState(391); match(R_PT_VIRG);
				}
				break;
			}
			setState(395); test();
			setState(398);
			_la = _input.LA(1);
			if (_la==R_PT_VIRG) {
				{
				setState(396); match(R_PT_VIRG);
				setState(397); 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(400); base_stmt();
			}
		}
		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, 60, RULE_test);
		try {
			setState(408);
			switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(402); expression(0);
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(403); base_stmt();
				setState(406);
				switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
				case 1:
					{
					setState(404); match(R_PT_VIRG);
					setState(405); 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, 62, RULE_increment);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(410); 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, 64, RULE_for_each);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(412); primary_expr(0);
			setState(413); match(R_VIRGULA);
			setState(414); primary_expr(0);
			setState(415);
			_la = _input.LA(1);
			if ( !(_la==R_SHORT_VAR || _la==R_EQ) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			setState(416); match(R_RANGE);
			setState(417); 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, 66, RULE_range);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(419); 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, 68, RULE_return_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(421); match(R_RETURN);
			setState(423);
			switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
			case 1:
				{
				setState(422); 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, 70, RULE_expression_list);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(425); expression(0);
			setState(430);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,39,_ctx);
			while ( _alt!=2 && _alt!=ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(426); match(R_VIRGULA);
					setState(427); expression(0);
					}
					} 
				}
				setState(432);
				_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 = 72;
		enterRecursionRule(_localctx, 72, RULE_expression, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(439);
			switch (_input.LA(1)) {
			case R_PAR_E:
				{
				setState(434); match(R_PAR_E);
				setState(435); expression(0);
				setState(436); 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(438); unary_expr();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			_ctx.stop = _input.LT(-1);
			setState(458);
			_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(456);
					switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
					case 1:
						{
						_localctx = new ExpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(441);
						if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
						setState(442);
						((ExpressionContext)_localctx).op = _input.LT(1);
						_la = _input.LA(1);
						if ( !(((((_la - 13)) & ~0x3f) == 0 && ((1L << (_la - 13)) & ((1L << (R_OP_MOD - 13)) | (1L << (R_END - 13)) | (1L << (R_OP_DIV - 13)) | (1L << (R_OP_ADD - 13)) | (1L << (R_OP_SUB - 13)) | (1L << (R_OP_AST - 13)))) != 0)) ) {
							((ExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
						}
						consume();
						setState(443); expression(6);
						}
						break;

					case 2:
						{
						_localctx = new ExpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(444);
						if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
						setState(445);
						((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(446); expression(5);
						}
						break;

					case 3:
						{
						_localctx = new ExpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(447);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(448);
						((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(449); expression(4);
						}
						break;

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

					case 5:
						{
						_localctx = new ExpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(453);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(454);
						((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(455); expression(2);
						}
						break;
					}
					} 
				}
				setState(460);
				_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, 74, RULE_unary_expr);
		int _la;
		try {
			setState(464);
			switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(461);
				((Unary_exprContext)_localctx).op = _input.LT(1);
				_la = _input.LA(1);
				if ( !(((((_la - 9)) & ~0x3f) == 0 && ((1L << (_la - 9)) & ((1L << (R_REFERENCE - 9)) | (1L << (R_EXCLAMATION - 9)) | (1L << (R_OP_SUB - 9)) | (1L << (R_OP_AST - 9)))) != 0)) ) {
					((Unary_exprContext)_localctx).op = (Token)_errHandler.recoverInline(this);
				}
				consume();
				setState(462); primary_expr(0);
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(463); 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 = 76;
		enterRecursionRule(_localctx, 76, RULE_primary_expr, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(471);
			switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
			case 1:
				{
				setState(467); ((Primary_exprContext)_localctx).operand = operand();
				((Primary_exprContext)_localctx).id =  ((Primary_exprContext)_localctx).operand.Value;
				}
				break;

			case 2:
				{
				setState(470); literal();
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(487);
			_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(485);
					switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
					case 1:
						{
						_localctx = new Primary_exprContext(_parentctx, _parentState);
						_localctx.pe = _prevctx;
						pushNewRecursionContext(_localctx, _startState, RULE_primary_expr);
						setState(473);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(474); 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(477);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(478); 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(481);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(482); arguments();
						((Primary_exprContext)_localctx).id =  ((Primary_exprContext)_localctx).pea.id;
						}
						break;
					}
					} 
				}
				setState(489);
				_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, 78, RULE_operand);
		try {
			setState(495);
			switch (_input.LA(1)) {
			case ID:
				enterOuterAlt(_localctx, 1);
				{
				setState(490); ((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(492); ((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, 80, RULE_literal);
		try {
			setState(499);
			switch (_input.LA(1)) {
			case R_FUNCTION:
				enterOuterAlt(_localctx, 1);
				{
				setState(497); 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(498); 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, 82, RULE_base_stmt);
		try {
			setState(506);
			switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				}
				break;

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

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

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

			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(505); 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, 84, RULE_func_literal);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(508); match(R_FUNCTION);
			setState(509); arguments();
			setState(511);
			_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(510); return_dec();
				}
			}

			setState(513); 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, 86, RULE_composite);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(515); literalType();
			setState(516); 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, 88, RULE_literalType);
		try {
			setState(521);
			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(518); typename();
				}
				break;
			case R_STRUCT:
				enterOuterAlt(_localctx, 2);
				{
				setState(519); structType();
				}
				break;
			case R_CHA_E:
				enterOuterAlt(_localctx, 3);
				{
				setState(520); 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, 90, RULE_structType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(523); match(R_STRUCT);
			setState(524); match(R_COL_E);
			setState(526); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(525); fieldDecl();
				}
				}
				setState(528); 
				_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(530); 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, 92, RULE_fieldDecl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(536);
			switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) {
			case 1:
				{
				setState(532); id_list();
				setState(533); type();
				}
				break;

			case 2:
				{
				setState(535); anon_field();
				}
				break;
			}
			setState(539);
			_la = _input.LA(1);
			if (_la==T_STRING) {
				{
				setState(538); 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, 94, RULE_anon_field);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(542);
			switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
			case 1:
				{
				setState(541); match(R_OP_AST);
				}
				break;
			}
			setState(544); 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, 96, RULE_arrayType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(546); match(R_CHA_E);
			setState(548);
			_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 - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (R_OP_SUB - 71)) | (1L << (R_OP_AST - 71)) | (1L << (T_CHAR - 71)) | (1L << (T_BOOL_TRUE - 71)) | (1L << (T_BOOL_FALSE - 71)) | (1L << (ID - 71)) | (1L << (T_INTEIRO - 71)))) != 0)) {
				{
				setState(547); expression(0);
				}
			}

			setState(550); match(R_CHA_D);
			setState(551); 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, 98, RULE_inc_dec);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(553); expression(0);
			setState(554);
			((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, 100, RULE_literal_value);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(556); match(R_COL_E);
			setState(563);
			_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 - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (R_OP_SUB - 71)) | (1L << (R_OP_AST - 71)) | (1L << (T_CHAR - 71)) | (1L << (T_BOOL_TRUE - 71)) | (1L << (T_BOOL_FALSE - 71)) | (1L << (ID - 71)) | (1L << (T_INTEIRO - 71)))) != 0)) {
				{
				setState(559);
				switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
				case 1:
					{
					setState(557); expression_list();
					}
					break;

				case 2:
					{
					setState(558); element_list();
					}
					break;
				}
				setState(561); match(R_VIRGULA);
				}
			}

			setState(565); 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, 102, RULE_element_list);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(567); keyed_element();
			setState(572);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,59,_ctx);
			while ( _alt!=2 && _alt!=ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(568); match(R_VIRGULA);
					setState(569); keyed_element();
					}
					} 
				}
				setState(574);
				_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, 104, RULE_keyed_element);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(575); match(ID);
			setState(576); match(R_COLON);
			setState(577); 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, 106, RULE_expression_seletor);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(579); match(R_PONTO);
			setState(580); 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, 108, RULE_def_block);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(582); match(R_COL_E);
			setState(584); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(583); statement();
				}
				}
				setState(586); 
				_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 - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (R_OP_SUB - 71)) | (1L << (R_OP_AST - 71)) | (1L << (T_CHAR - 71)) | (1L << (T_BOOL_TRUE - 71)) | (1L << (T_BOOL_FALSE - 71)) | (1L << (ID - 71)) | (1L << (T_INTEIRO - 71)))) != 0) );
			setState(588); 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, 110, RULE_callExpr);
		try {
			setState(594);
			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(591); primary_expr(0);
				setState(592); 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, 112, RULE_statement);
		try {
			setState(612);
			switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(596); dec_var_short();
				}
				break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			case 16:
				enterOuterAlt(_localctx, 16);
				{
				setState(611); 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, 114, RULE_fallthroughStmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(614); 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, 116, RULE_label_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(616); match(ID);
			setState(617); match(R_COLON);
			setState(618); 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, 118, RULE_throwStmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(620); match(R_THROW);
			setState(621); expression(0);
			setState(622); 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, 120, RULE_try_catch);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(624); match(R_TRY);
			setState(625); def_block();
			setState(626); catch_exception();
			setState(628);
			_la = _input.LA(1);
			if (_la==R_FINALLY) {
				{
				setState(627); 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, 122, RULE_catch_exception);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(630); match(R_CATCH);
			setState(631); match(R_PAR_E);
			setState(632); dec_var();
			setState(633); match(R_PAR_D);
			setState(634); 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, 124, RULE_finally_try);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(636); match(R_FINALLY);
			setState(637); 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, 126, RULE_flux_control);
		try {
			setState(646);
			switch (_input.LA(1)) {
			case R_GOTO:
				enterOuterAlt(_localctx, 1);
				{
				setState(639); ((Flux_controlContext)_localctx).R_GOTO = match(R_GOTO);
				setState(640); 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(642); ((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(644); ((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, 128, RULE_newstmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(648); match(R_NEW);
			setState(649); match(R_PAR_E);
			setState(650); type();
			setState(653);
			_la = _input.LA(1);
			if (_la==R_VIRGULA) {
				{
				setState(651); match(R_VIRGULA);
				setState(652); match(T_INTEIRO);
				}
			}

			setState(655); 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, 130, RULE_delete);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(657); match(R_DELETE);
			setState(658); expression(0);
			setState(661);
			_la = _input.LA(1);
			if (_la==R_VIRGULA) {
				{
				setState(659); match(R_VIRGULA);
				setState(660); 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, 132, RULE_type);
		try {
			setState(672);
			switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(663); ((TypeContext)_localctx).typename = typename();
				((TypeContext)_localctx).ltype =  ((TypeContext)_localctx).typename.ltype;
				}
				break;

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

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(669); 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, 134, RULE_indexedType);
		try {
			setState(681);
			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(674); ((IndexedTypeContext)_localctx).typename = typename();
				((IndexedTypeContext)_localctx).ltype =  ((IndexedTypeContext)_localctx).typename.ltype;
				}
				break;
			case R_CHA_E:
				enterOuterAlt(_localctx, 2);
				{
				setState(677); index();
				setState(678); ((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, 136, RULE_typename);
		try {
			setState(695);
			switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(683); ((TypenameContext)_localctx).ID = match(ID);
				((TypenameContext)_localctx).ltype =  (((TypenameContext)_localctx).ID!=null?((TypenameContext)_localctx).ID.getText():null);
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(685); ((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(688); ((TypenameContext)_localctx).baseType = baseType();
				((TypenameContext)_localctx).ltype =  ((TypenameContext)_localctx).baseType.ltype;
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(691); match(R_OP_AST);
				setState(692); ((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, 138, RULE_qualifiedId);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(697); match(ID);
			setState(698); match(R_PONTO);
			setState(699); 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, 140, RULE_baseType);
		try {
			setState(711);
			switch (_input.LA(1)) {
			case R_INT:
				enterOuterAlt(_localctx, 1);
				{
				setState(701); ((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(703); ((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(705); ((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(707); ((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(709); ((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, 142, RULE_mapType);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(713); match(R_MAP);
			setState(714); match(R_CHA_E);
			setState(715); ((MapTypeContext)_localctx).k = type();
			setState(716); match(R_CHA_D);
			setState(717); ((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, 144, RULE_buildtags);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(721); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(720); build_stmt();
				}
				}
				setState(723); 
				_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 BuildtagContext buildtag() {
			return getRuleContext(BuildtagContext.class,0);
		}
		public List<TerminalNode> R_VIRGULA() { return getTokens(IvannosysGrammarParser.R_VIRGULA); }
		public List<TerminalNode> ID() { return getTokens(IvannosysGrammarParser.ID); }
		public TerminalNode R_AT() { return getToken(IvannosysGrammarParser.R_AT, 0); }
		public TerminalNode R_VIRGULA(int i) {
			return getToken(IvannosysGrammarParser.R_VIRGULA, i);
		}
		public TerminalNode ID(int i) {
			return getToken(IvannosysGrammarParser.ID, 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, 146, RULE_build_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(725); match(R_AT);
			setState(726); buildtag();
			setState(727); match(ID);
			setState(732);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==R_VIRGULA) {
				{
				{
				setState(728); match(R_VIRGULA);
				setState(729); match(ID);
				}
				}
				setState(734);
				_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 BuildtagContext extends ParserRuleContext {
		public TerminalNode BUILD_TARGET() { return getToken(IvannosysGrammarParser.BUILD_TARGET, 0); }
		public BuildtagContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_buildtag; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).enterBuildtag(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof IvannosysGrammarListener ) ((IvannosysGrammarListener)listener).exitBuildtag(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof IvannosysGrammarVisitor ) return ((IvannosysGrammarVisitor<? extends T>)visitor).visitBuildtag(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BuildtagContext buildtag() throws RecognitionException {
		BuildtagContext _localctx = new BuildtagContext(_ctx, getState());
		enterRule(_localctx, 148, RULE_buildtag);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(735); match(BUILD_TARGET);
			}
		}
		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 36: return expression_sempred((ExpressionContext)_localctx, predIndex);

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