<filename>gen/UNaIAParser.py
# Generated from /home/brayan/Documentos/UNAL/Semestre 9/Lenguajes/UNaIA/UNa-IA/UNa-IA/Grammar/UNaIA.g4 by ANTLR 4.8
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3&")
        buf.write("\u00a9\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\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")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\3\2\3\2\3\2\7\2*\n\2\f\2\16\2-\13\2\3\2\5\2\60\n\2\3")
        buf.write("\3\3\3\5\3\64\n\3\3\4\3\4\3\4\3\4\5\4:\n\4\3\4\3\4\5\4")
        buf.write(">\n\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5")
        buf.write("\3\5\3\5\5\5N\n\5\3\6\3\6\3\6\3\6\5\6T\n\6\3\7\3\7\3\b")
        buf.write("\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\bb\n\b\3\t\3\t")
        buf.write("\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3")
        buf.write("\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\5\fz\n\f\3\r\3\r\3\r\3")
        buf.write("\r\3\r\3\16\3\16\3\16\3\16\3\16\3\16\5\16\u0087\n\16\3")
        buf.write("\16\3\16\3\16\3\16\5\16\u008d\n\16\5\16\u008f\n\16\3\17")
        buf.write("\3\17\3\17\3\17\5\17\u0095\n\17\3\17\3\17\5\17\u0099\n")
        buf.write("\17\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\22\3\22")
        buf.write("\3\22\3\22\3\23\3\23\3\23\2\2\24\2\4\6\b\n\f\16\20\22")
        buf.write("\24\26\30\32\34\36 \"$\2\3\3\2\26\34\2\u00b0\2+\3\2\2")
        buf.write("\2\4\61\3\2\2\2\6=\3\2\2\2\bM\3\2\2\2\nO\3\2\2\2\fU\3")
        buf.write("\2\2\2\16a\3\2\2\2\20c\3\2\2\2\22h\3\2\2\2\24m\3\2\2\2")
        buf.write("\26r\3\2\2\2\30{\3\2\2\2\32\u0080\3\2\2\2\34\u0090\3\2")
        buf.write("\2\2\36\u009a\3\2\2\2 \u009e\3\2\2\2\"\u00a2\3\2\2\2$")
        buf.write("\u00a6\3\2\2\2&*\5\b\5\2\'*\5\16\b\2(*\5\4\3\2)&\3\2\2")
        buf.write("\2)\'\3\2\2\2)(\3\2\2\2*-\3\2\2\2+)\3\2\2\2+,\3\2\2\2")
        buf.write(",/\3\2\2\2-+\3\2\2\2.\60\5$\23\2/.\3\2\2\2/\60\3\2\2\2")
        buf.write("\60\3\3\2\2\2\61\63\7\n\2\2\62\64\7$\2\2\63\62\3\2\2\2")
        buf.write("\63\64\3\2\2\2\64\5\3\2\2\2\65\66\7\4\2\2\669\7$\2\2\67")
        buf.write("8\7\36\2\28:\7$\2\29\67\3\2\2\29:\3\2\2\2:>\3\2\2\2;<")
        buf.write("\7\5\2\2<>\7$\2\2=\65\3\2\2\2=;\3\2\2\2>\7\3\2\2\2?@\7")
        buf.write("#\2\2@A\7 \2\2AN\5\6\4\2BC\7#\2\2CD\7 \2\2DN\5\f\7\2E")
        buf.write("F\7#\2\2FG\7 \2\2GN\5\16\b\2HI\7#\2\2IJ\7\17\2\2JK\7#")
        buf.write("\2\2KL\7 \2\2LN\5\n\6\2M?\3\2\2\2MB\3\2\2\2ME\3\2\2\2")
        buf.write("MH\3\2\2\2N\t\3\2\2\2OP\7\r\2\2PS\7#\2\2QR\7\37\2\2RT")
        buf.write("\7%\2\2SQ\3\2\2\2ST\3\2\2\2T\13\3\2\2\2UV\t\2\2\2V\r\3")
        buf.write("\2\2\2Wb\5\20\t\2Xb\5\22\n\2Yb\5\24\13\2Zb\5\26\f\2[b")
        buf.write("\5\30\r\2\\b\5\32\16\2]b\5\34\17\2^b\5\36\20\2_b\5 \21")
        buf.write("\2`b\5\"\22\2aW\3\2\2\2aX\3\2\2\2aY\3\2\2\2aZ\3\2\2\2")
        buf.write("a[\3\2\2\2a\\\3\2\2\2a]\3\2\2\2a^\3\2\2\2a_\3\2\2\2a`")
        buf.write("\3\2\2\2b\17\3\2\2\2cd\7\t\2\2de\7#\2\2ef\7\16\2\2fg\7")
        buf.write("#\2\2g\21\3\2\2\2hi\7\13\2\2ij\7#\2\2jk\7\16\2\2kl\7#")
        buf.write("\2\2l\23\3\2\2\2mn\7\f\2\2no\7#\2\2op\7\16\2\2pq\7#\2")
        buf.write("\2q\25\3\2\2\2rs\7\22\2\2sy\7#\2\2tu\7!\2\2uv\7%\2\2v")
        buf.write("w\7\36\2\2wx\7%\2\2xz\7\"\2\2yt\3\2\2\2yz\3\2\2\2z\27")
        buf.write("\3\2\2\2{|\7\6\2\2|}\7#\2\2}~\7\16\2\2~\177\7#\2\2\177")
        buf.write("\31\3\2\2\2\u0080\u0081\7\7\2\2\u0081\u0082\7#\2\2\u0082")
        buf.write("\u0083\7\16\2\2\u0083\u0086\7#\2\2\u0084\u0085\7\20\2")
        buf.write("\2\u0085\u0087\7$\2\2\u0086\u0084\3\2\2\2\u0086\u0087")
        buf.write("\3\2\2\2\u0087\u008e\3\2\2\2\u0088\u0089\7\21\2\2\u0089")
        buf.write("\u008c\7$\2\2\u008a\u008b\7\17\2\2\u008b\u008d\7$\2\2")
        buf.write("\u008c\u008a\3\2\2\2\u008c\u008d\3\2\2\2\u008d\u008f\3")
        buf.write("\2\2\2\u008e\u0088\3\2\2\2\u008e\u008f\3\2\2\2\u008f\33")
        buf.write("\3\2\2\2\u0090\u0091\7\b\2\2\u0091\u0094\7#\2\2\u0092")
        buf.write("\u0093\7\20\2\2\u0093\u0095\7$\2\2\u0094\u0092\3\2\2\2")
        buf.write("\u0094\u0095\3\2\2\2\u0095\u0098\3\2\2\2\u0096\u0097\7")
        buf.write("\21\2\2\u0097\u0099\7$\2\2\u0098\u0096\3\2\2\2\u0098\u0099")
        buf.write("\3\2\2\2\u0099\35\3\2\2\2\u009a\u009b\7\23\2\2\u009b\u009c")
        buf.write("\7#\2\2\u009c\u009d\7$\2\2\u009d\37\3\2\2\2\u009e\u009f")
        buf.write("\7\24\2\2\u009f\u00a0\7#\2\2\u00a0\u00a1\7$\2\2\u00a1")
        buf.write("!\3\2\2\2\u00a2\u00a3\7\25\2\2\u00a3\u00a4\7#\2\2\u00a4")
        buf.write("\u00a5\7$\2\2\u00a5#\3\2\2\2\u00a6\u00a7\7\35\2\2\u00a7")
        buf.write("%\3\2\2\2\21)+/\639=MSay\u0086\u008c\u008e\u0094\u0098")
        return buf.getvalue()


class UNaIAParser ( Parser ):

    grammarFileName = "UNaIA.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "'ejemplos'", "'datos'", 
                     "'estadisticas'", "'graficar'", "'exportar'", "'entrenar'", 
                     "'ayuda'", "'evaluar'", "'predecir'", "'dividirDatos'", 
                     "'con'", "'y'", "'en'", "'como'", "'reportar'", "'quantil'", 
                     "'estandarizar'", "'minmax'", "'regresionLogistica'", 
                     "'bayes'", "'knn'", "'svm'", "'arbolDeDecision'", "'bosqueAleatorio'", 
                     "'auto'", "'python'", "','", "':'", "'='", "'('", "')'" ]

    symbolicNames = [ "<INVALID>", "COMMENT", "EJEMPLOS", "DATOS", "ESTADISTICAS", 
                      "GRAFICAR", "EXPORTAR", "ENTRENAR", "AYUDA", "EVALUAR", 
                      "PREDECIR", "DIVIDIRDATOS", "CON", "Y", "EN", "COMO", 
                      "REPORTAR", "QUANTIL", "ESTANDARIZAR", "MINMAX", "REGRESIONLOGISTICA", 
                      "BAYES", "KNN", "SVM", "ARBOLDEDECISION", "BOSQUEALEATORIO", 
                      "AUTO", "PYTHON", "COMA", "DOS_PUNTOS", "ASIG", "PAR_IZQ", 
                      "PAR_DER", "ID", "STRING", "NUMERO", "ESPACIO" ]

    RULE_programa = 0
    RULE_ayuda = 1
    RULE_datos = 2
    RULE_asignacion = 3
    RULE_division = 4
    RULE_modelo = 5
    RULE_metodo = 6
    RULE_entrenamiento = 7
    RULE_evaluacion = 8
    RULE_prediccion = 9
    RULE_reporte = 10
    RULE_estadisticas = 11
    RULE_graficas = 12
    RULE_exportacion = 13
    RULE_quantil = 14
    RULE_estandarizacion = 15
    RULE_escaladominmax = 16
    RULE_codigo_python = 17

    ruleNames =  [ "programa", "ayuda", "datos", "asignacion", "division", 
                   "modelo", "metodo", "entrenamiento", "evaluacion", "prediccion", 
                   "reporte", "estadisticas", "graficas", "exportacion", 
                   "quantil", "estandarizacion", "escaladominmax", "codigo_python" ]

    EOF = Token.EOF
    COMMENT=1
    EJEMPLOS=2
    DATOS=3
    ESTADISTICAS=4
    GRAFICAR=5
    EXPORTAR=6
    ENTRENAR=7
    AYUDA=8
    EVALUAR=9
    PREDECIR=10
    DIVIDIRDATOS=11
    CON=12
    Y=13
    EN=14
    COMO=15
    REPORTAR=16
    QUANTIL=17
    ESTANDARIZAR=18
    MINMAX=19
    REGRESIONLOGISTICA=20
    BAYES=21
    KNN=22
    SVM=23
    ARBOLDEDECISION=24
    BOSQUEALEATORIO=25
    AUTO=26
    PYTHON=27
    COMA=28
    DOS_PUNTOS=29
    ASIG=30
    PAR_IZQ=31
    PAR_DER=32
    ID=33
    STRING=34
    NUMERO=35
    ESPACIO=36

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.8")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class ProgramaContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def asignacion(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(UNaIAParser.AsignacionContext)
            else:
                return self.getTypedRuleContext(UNaIAParser.AsignacionContext,i)


        def metodo(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(UNaIAParser.MetodoContext)
            else:
                return self.getTypedRuleContext(UNaIAParser.MetodoContext,i)


        def ayuda(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(UNaIAParser.AyudaContext)
            else:
                return self.getTypedRuleContext(UNaIAParser.AyudaContext,i)


        def codigo_python(self):
            return self.getTypedRuleContext(UNaIAParser.Codigo_pythonContext,0)


        def getRuleIndex(self):
            return UNaIAParser.RULE_programa

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPrograma" ):
                listener.enterPrograma(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPrograma" ):
                listener.exitPrograma(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPrograma" ):
                return visitor.visitPrograma(self)
            else:
                return visitor.visitChildren(self)




    def programa(self):

        localctx = UNaIAParser.ProgramaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_programa)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 41
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << UNaIAParser.ESTADISTICAS) | (1 << UNaIAParser.GRAFICAR) | (1 << UNaIAParser.EXPORTAR) | (1 << UNaIAParser.ENTRENAR) | (1 << UNaIAParser.AYUDA) | (1 << UNaIAParser.EVALUAR) | (1 << UNaIAParser.PREDECIR) | (1 << UNaIAParser.REPORTAR) | (1 << UNaIAParser.QUANTIL) | (1 << UNaIAParser.ESTANDARIZAR) | (1 << UNaIAParser.MINMAX) | (1 << UNaIAParser.ID))) != 0):
                self.state = 39
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [UNaIAParser.ID]:
                    self.state = 36
                    self.asignacion()
                    pass
                elif token in [UNaIAParser.ESTADISTICAS, UNaIAParser.GRAFICAR, UNaIAParser.EXPORTAR, UNaIAParser.ENTRENAR, UNaIAParser.EVALUAR, UNaIAParser.PREDECIR, UNaIAParser.REPORTAR, UNaIAParser.QUANTIL, UNaIAParser.ESTANDARIZAR, UNaIAParser.MINMAX]:
                    self.state = 37
                    self.metodo()
                    pass
                elif token in [UNaIAParser.AYUDA]:
                    self.state = 38
                    self.ayuda()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 43
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 45
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==UNaIAParser.PYTHON:
                self.state = 44
                self.codigo_python()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class AyudaContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def AYUDA(self):
            return self.getToken(UNaIAParser.AYUDA, 0)

        def STRING(self):
            return self.getToken(UNaIAParser.STRING, 0)

        def getRuleIndex(self):
            return UNaIAParser.RULE_ayuda

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAyuda" ):
                listener.enterAyuda(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAyuda" ):
                listener.exitAyuda(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAyuda" ):
                return visitor.visitAyuda(self)
            else:
                return visitor.visitChildren(self)




    def ayuda(self):

        localctx = UNaIAParser.AyudaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_ayuda)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 47
            self.match(UNaIAParser.AYUDA)
            self.state = 49
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==UNaIAParser.STRING:
                self.state = 48
                self.match(UNaIAParser.STRING)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class DatosContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return UNaIAParser.RULE_datos

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class DatosDatosContext(DatosContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a UNaIAParser.DatosContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DATOS(self):
            return self.getToken(UNaIAParser.DATOS, 0)
        def STRING(self):
            return self.getToken(UNaIAParser.STRING, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDatosDatos" ):
                listener.enterDatosDatos(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDatosDatos" ):
                listener.exitDatosDatos(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDatosDatos" ):
                return visitor.visitDatosDatos(self)
            else:
                return visitor.visitChildren(self)


    class DatosEjemplosContext(DatosContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a UNaIAParser.DatosContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def EJEMPLOS(self):
            return self.getToken(UNaIAParser.EJEMPLOS, 0)
        def STRING(self, i:int=None):
            if i is None:
                return self.getTokens(UNaIAParser.STRING)
            else:
                return self.getToken(UNaIAParser.STRING, i)
        def COMA(self):
            return self.getToken(UNaIAParser.COMA, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDatosEjemplos" ):
                listener.enterDatosEjemplos(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDatosEjemplos" ):
                listener.exitDatosEjemplos(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDatosEjemplos" ):
                return visitor.visitDatosEjemplos(self)
            else:
                return visitor.visitChildren(self)



    def datos(self):

        localctx = UNaIAParser.DatosContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_datos)
        self._la = 0 # Token type
        try:
            self.state = 59
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [UNaIAParser.EJEMPLOS]:
                localctx = UNaIAParser.DatosEjemplosContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 51
                self.match(UNaIAParser.EJEMPLOS)
                self.state = 52
                self.match(UNaIAParser.STRING)
                self.state = 55
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==UNaIAParser.COMA:
                    self.state = 53
                    self.match(UNaIAParser.COMA)
                    self.state = 54
                    self.match(UNaIAParser.STRING)


                pass
            elif token in [UNaIAParser.DATOS]:
                localctx = UNaIAParser.DatosDatosContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 57
                self.match(UNaIAParser.DATOS)
                self.state = 58
                self.match(UNaIAParser.STRING)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class AsignacionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return UNaIAParser.RULE_asignacion

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class AsigMetodoContext(AsignacionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a UNaIAParser.AsignacionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(UNaIAParser.ID, 0)
        def ASIG(self):
            return self.getToken(UNaIAParser.ASIG, 0)
        def metodo(self):
            return self.getTypedRuleContext(UNaIAParser.MetodoContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAsigMetodo" ):
                listener.enterAsigMetodo(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAsigMetodo" ):
                listener.exitAsigMetodo(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAsigMetodo" ):
                return visitor.visitAsigMetodo(self)
            else:
                return visitor.visitChildren(self)


    class AsigMultiContext(AsignacionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a UNaIAParser.AsignacionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(UNaIAParser.ID)
            else:
                return self.getToken(UNaIAParser.ID, i)
        def Y(self):
            return self.getToken(UNaIAParser.Y, 0)
        def ASIG(self):
            return self.getToken(UNaIAParser.ASIG, 0)
        def division(self):
            return self.getTypedRuleContext(UNaIAParser.DivisionContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAsigMulti" ):
                listener.enterAsigMulti(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAsigMulti" ):
                listener.exitAsigMulti(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAsigMulti" ):
                return visitor.visitAsigMulti(self)
            else:
                return visitor.visitChildren(self)


    class AsigModeloContext(AsignacionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a UNaIAParser.AsignacionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(UNaIAParser.ID, 0)
        def ASIG(self):
            return self.getToken(UNaIAParser.ASIG, 0)
        def modelo(self):
            return self.getTypedRuleContext(UNaIAParser.ModeloContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAsigModelo" ):
                listener.enterAsigModelo(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAsigModelo" ):
                listener.exitAsigModelo(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAsigModelo" ):
                return visitor.visitAsigModelo(self)
            else:
                return visitor.visitChildren(self)


    class AsigDatosContext(AsignacionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a UNaIAParser.AsignacionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(UNaIAParser.ID, 0)
        def ASIG(self):
            return self.getToken(UNaIAParser.ASIG, 0)
        def datos(self):
            return self.getTypedRuleContext(UNaIAParser.DatosContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAsigDatos" ):
                listener.enterAsigDatos(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAsigDatos" ):
                listener.exitAsigDatos(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAsigDatos" ):
                return visitor.visitAsigDatos(self)
            else:
                return visitor.visitChildren(self)



    def asignacion(self):

        localctx = UNaIAParser.AsignacionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_asignacion)
        try:
            self.state = 75
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                localctx = UNaIAParser.AsigDatosContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 61
                self.match(UNaIAParser.ID)
                self.state = 62
                self.match(UNaIAParser.ASIG)
                self.state = 63
                self.datos()
                pass

            elif la_ == 2:
                localctx = UNaIAParser.AsigModeloContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 64
                self.match(UNaIAParser.ID)
                self.state = 65
                self.match(UNaIAParser.ASIG)
                self.state = 66
                self.modelo()
                pass

            elif la_ == 3:
                localctx = UNaIAParser.AsigMetodoContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 67
                self.match(UNaIAParser.ID)
                self.state = 68
                self.match(UNaIAParser.ASIG)
                self.state = 69
                self.metodo()
                pass

            elif la_ == 4:
                localctx = UNaIAParser.AsigMultiContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 70
                self.match(UNaIAParser.ID)
                self.state = 71
                self.match(UNaIAParser.Y)
                self.state = 72
                self.match(UNaIAParser.ID)
                self.state = 73
                self.match(UNaIAParser.ASIG)
                self.state = 74
                self.division()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class DivisionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DIVIDIRDATOS(self):
            return self.getToken(UNaIAParser.DIVIDIRDATOS, 0)

        def ID(self):
            return self.getToken(UNaIAParser.ID, 0)

        def DOS_PUNTOS(self):
            return self.getToken(UNaIAParser.DOS_PUNTOS, 0)

        def NUMERO(self):
            return self.getToken(UNaIAParser.NUMERO, 0)

        def getRuleIndex(self):
            return UNaIAParser.RULE_division

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDivision" ):
                listener.enterDivision(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDivision" ):
                listener.exitDivision(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDivision" ):
                return visitor.visitDivision(self)
            else:
                return visitor.visitChildren(self)




    def division(self):

        localctx = UNaIAParser.DivisionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_division)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 77
            self.match(UNaIAParser.DIVIDIRDATOS)
            self.state = 78
            self.match(UNaIAParser.ID)
            self.state = 81
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==UNaIAParser.DOS_PUNTOS:
                self.state = 79
                self.match(UNaIAParser.DOS_PUNTOS)
                self.state = 80
                self.match(UNaIAParser.NUMERO)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class ModeloContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def REGRESIONLOGISTICA(self):
            return self.getToken(UNaIAParser.REGRESIONLOGISTICA, 0)

        def BAYES(self):
            return self.getToken(UNaIAParser.BAYES, 0)

        def KNN(self):
            return self.getToken(UNaIAParser.KNN, 0)

        def SVM(self):
            return self.getToken(UNaIAParser.SVM, 0)

        def ARBOLDEDECISION(self):
            return self.getToken(UNaIAParser.ARBOLDEDECISION, 0)

        def BOSQUEALEATORIO(self):
            return self.getToken(UNaIAParser.BOSQUEALEATORIO, 0)

        def AUTO(self):
            return self.getToken(UNaIAParser.AUTO, 0)

        def getRuleIndex(self):
            return UNaIAParser.RULE_modelo

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterModelo" ):
                listener.enterModelo(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitModelo" ):
                listener.exitModelo(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitModelo" ):
                return visitor.visitModelo(self)
            else:
                return visitor.visitChildren(self)




    def modelo(self):

        localctx = UNaIAParser.ModeloContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_modelo)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 83
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << UNaIAParser.REGRESIONLOGISTICA) | (1 << UNaIAParser.BAYES) | (1 << UNaIAParser.KNN) | (1 << UNaIAParser.SVM) | (1 << UNaIAParser.ARBOLDEDECISION) | (1 << UNaIAParser.BOSQUEALEATORIO) | (1 << UNaIAParser.AUTO))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class MetodoContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def entrenamiento(self):
            return self.getTypedRuleContext(UNaIAParser.EntrenamientoContext,0)


        def evaluacion(self):
            return self.getTypedRuleContext(UNaIAParser.EvaluacionContext,0)


        def prediccion(self):
            return self.getTypedRuleContext(UNaIAParser.PrediccionContext,0)


        def reporte(self):
            return self.getTypedRuleContext(UNaIAParser.ReporteContext,0)


        def estadisticas(self):
            return self.getTypedRuleContext(UNaIAParser.EstadisticasContext,0)


        def graficas(self):
            return self.getTypedRuleContext(UNaIAParser.GraficasContext,0)


        def exportacion(self):
            return self.getTypedRuleContext(UNaIAParser.ExportacionContext,0)


        def quantil(self):
            return self.getTypedRuleContext(UNaIAParser.QuantilContext,0)


        def estandarizacion(self):
            return self.getTypedRuleContext(UNaIAParser.EstandarizacionContext,0)


        def escaladominmax(self):
            return self.getTypedRuleContext(UNaIAParser.EscaladominmaxContext,0)


        def getRuleIndex(self):
            return UNaIAParser.RULE_metodo

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMetodo" ):
                listener.enterMetodo(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMetodo" ):
                listener.exitMetodo(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMetodo" ):
                return visitor.visitMetodo(self)
            else:
                return visitor.visitChildren(self)




    def metodo(self):

        localctx = UNaIAParser.MetodoContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_metodo)
        try:
            self.state = 95
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [UNaIAParser.ENTRENAR]:
                self.enterOuterAlt(localctx, 1)
                self.state = 85
                self.entrenamiento()
                pass
            elif token in [UNaIAParser.EVALUAR]:
                self.enterOuterAlt(localctx, 2)
                self.state = 86
                self.evaluacion()
                pass
            elif token in [UNaIAParser.PREDECIR]:
                self.enterOuterAlt(localctx, 3)
                self.state = 87
                self.prediccion()
                pass
            elif token in [UNaIAParser.REPORTAR]:
                self.enterOuterAlt(localctx, 4)
                self.state = 88
                self.reporte()
                pass
            elif token in [UNaIAParser.ESTADISTICAS]:
                self.enterOuterAlt(localctx, 5)
                self.state = 89
                self.estadisticas()
                pass
            elif token in [UNaIAParser.GRAFICAR]:
                self.enterOuterAlt(localctx, 6)
                self.state = 90
                self.graficas()
                pass
            elif token in [UNaIAParser.EXPORTAR]:
                self.enterOuterAlt(localctx, 7)
                self.state = 91
                self.exportacion()
                pass
            elif token in [UNaIAParser.QUANTIL]:
                self.enterOuterAlt(localctx, 8)
                self.state = 92
                self.quantil()
                pass
            elif token in [UNaIAParser.ESTANDARIZAR]:
                self.enterOuterAlt(localctx, 9)
                self.state = 93
                self.estandarizacion()
                pass
            elif token in [UNaIAParser.MINMAX]:
                self.enterOuterAlt(localctx, 10)
                self.state = 94
                self.escaladominmax()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class EntrenamientoContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ENTRENAR(self):
            return self.getToken(UNaIAParser.ENTRENAR, 0)

        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(UNaIAParser.ID)
            else:
                return self.getToken(UNaIAParser.ID, i)

        def CON(self):
            return self.getToken(UNaIAParser.CON, 0)

        def getRuleIndex(self):
            return UNaIAParser.RULE_entrenamiento

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEntrenamiento" ):
                listener.enterEntrenamiento(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEntrenamiento" ):
                listener.exitEntrenamiento(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEntrenamiento" ):
                return visitor.visitEntrenamiento(self)
            else:
                return visitor.visitChildren(self)




    def entrenamiento(self):

        localctx = UNaIAParser.EntrenamientoContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_entrenamiento)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 97
            self.match(UNaIAParser.ENTRENAR)
            self.state = 98
            self.match(UNaIAParser.ID)
            self.state = 99
            self.match(UNaIAParser.CON)
            self.state = 100
            self.match(UNaIAParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class EvaluacionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EVALUAR(self):
            return self.getToken(UNaIAParser.EVALUAR, 0)

        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(UNaIAParser.ID)
            else:
                return self.getToken(UNaIAParser.ID, i)

        def CON(self):
            return self.getToken(UNaIAParser.CON, 0)

        def getRuleIndex(self):
            return UNaIAParser.RULE_evaluacion

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEvaluacion" ):
                listener.enterEvaluacion(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEvaluacion" ):
                listener.exitEvaluacion(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEvaluacion" ):
                return visitor.visitEvaluacion(self)
            else:
                return visitor.visitChildren(self)




    def evaluacion(self):

        localctx = UNaIAParser.EvaluacionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_evaluacion)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 102
            self.match(UNaIAParser.EVALUAR)
            self.state = 103
            self.match(UNaIAParser.ID)
            self.state = 104
            self.match(UNaIAParser.CON)
            self.state = 105
            self.match(UNaIAParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class PrediccionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PREDECIR(self):
            return self.getToken(UNaIAParser.PREDECIR, 0)

        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(UNaIAParser.ID)
            else:
                return self.getToken(UNaIAParser.ID, i)

        def CON(self):
            return self.getToken(UNaIAParser.CON, 0)

        def getRuleIndex(self):
            return UNaIAParser.RULE_prediccion

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPrediccion" ):
                listener.enterPrediccion(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPrediccion" ):
                listener.exitPrediccion(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPrediccion" ):
                return visitor.visitPrediccion(self)
            else:
                return visitor.visitChildren(self)




    def prediccion(self):

        localctx = UNaIAParser.PrediccionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_prediccion)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 107
            self.match(UNaIAParser.PREDECIR)
            self.state = 108
            self.match(UNaIAParser.ID)
            self.state = 109
            self.match(UNaIAParser.CON)
            self.state = 110
            self.match(UNaIAParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class ReporteContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def REPORTAR(self):
            return self.getToken(UNaIAParser.REPORTAR, 0)

        def ID(self):
            return self.getToken(UNaIAParser.ID, 0)

        def PAR_IZQ(self):
            return self.getToken(UNaIAParser.PAR_IZQ, 0)

        def NUMERO(self, i:int=None):
            if i is None:
                return self.getTokens(UNaIAParser.NUMERO)
            else:
                return self.getToken(UNaIAParser.NUMERO, i)

        def COMA(self):
            return self.getToken(UNaIAParser.COMA, 0)

        def PAR_DER(self):
            return self.getToken(UNaIAParser.PAR_DER, 0)

        def getRuleIndex(self):
            return UNaIAParser.RULE_reporte

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterReporte" ):
                listener.enterReporte(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitReporte" ):
                listener.exitReporte(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReporte" ):
                return visitor.visitReporte(self)
            else:
                return visitor.visitChildren(self)




    def reporte(self):

        localctx = UNaIAParser.ReporteContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_reporte)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 112
            self.match(UNaIAParser.REPORTAR)
            self.state = 113
            self.match(UNaIAParser.ID)
            self.state = 119
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==UNaIAParser.PAR_IZQ:
                self.state = 114
                self.match(UNaIAParser.PAR_IZQ)
                self.state = 115
                self.match(UNaIAParser.NUMERO)
                self.state = 116
                self.match(UNaIAParser.COMA)
                self.state = 117
                self.match(UNaIAParser.NUMERO)
                self.state = 118
                self.match(UNaIAParser.PAR_DER)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class EstadisticasContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ESTADISTICAS(self):
            return self.getToken(UNaIAParser.ESTADISTICAS, 0)

        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(UNaIAParser.ID)
            else:
                return self.getToken(UNaIAParser.ID, i)

        def CON(self):
            return self.getToken(UNaIAParser.CON, 0)

        def getRuleIndex(self):
            return UNaIAParser.RULE_estadisticas

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEstadisticas" ):
                listener.enterEstadisticas(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEstadisticas" ):
                listener.exitEstadisticas(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEstadisticas" ):
                return visitor.visitEstadisticas(self)
            else:
                return visitor.visitChildren(self)




    def estadisticas(self):

        localctx = UNaIAParser.EstadisticasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_estadisticas)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 121
            self.match(UNaIAParser.ESTADISTICAS)
            self.state = 122
            self.match(UNaIAParser.ID)
            self.state = 123
            self.match(UNaIAParser.CON)
            self.state = 124
            self.match(UNaIAParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class GraficasContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def GRAFICAR(self):
            return self.getToken(UNaIAParser.GRAFICAR, 0)

        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(UNaIAParser.ID)
            else:
                return self.getToken(UNaIAParser.ID, i)

        def CON(self):
            return self.getToken(UNaIAParser.CON, 0)

        def EN(self):
            return self.getToken(UNaIAParser.EN, 0)

        def STRING(self, i:int=None):
            if i is None:
                return self.getTokens(UNaIAParser.STRING)
            else:
                return self.getToken(UNaIAParser.STRING, i)

        def COMO(self):
            return self.getToken(UNaIAParser.COMO, 0)

        def Y(self):
            return self.getToken(UNaIAParser.Y, 0)

        def getRuleIndex(self):
            return UNaIAParser.RULE_graficas

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGraficas" ):
                listener.enterGraficas(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGraficas" ):
                listener.exitGraficas(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGraficas" ):
                return visitor.visitGraficas(self)
            else:
                return visitor.visitChildren(self)




    def graficas(self):

        localctx = UNaIAParser.GraficasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_graficas)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 126
            self.match(UNaIAParser.GRAFICAR)
            self.state = 127
            self.match(UNaIAParser.ID)
            self.state = 128
            self.match(UNaIAParser.CON)
            self.state = 129
            self.match(UNaIAParser.ID)
            self.state = 132
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==UNaIAParser.EN:
                self.state = 130
                self.match(UNaIAParser.EN)
                self.state = 131
                self.match(UNaIAParser.STRING)


            self.state = 140
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==UNaIAParser.COMO:
                self.state = 134
                self.match(UNaIAParser.COMO)
                self.state = 135
                self.match(UNaIAParser.STRING)
                self.state = 138
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==UNaIAParser.Y:
                    self.state = 136
                    self.match(UNaIAParser.Y)
                    self.state = 137
                    self.match(UNaIAParser.STRING)




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class ExportacionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EXPORTAR(self):
            return self.getToken(UNaIAParser.EXPORTAR, 0)

        def ID(self):
            return self.getToken(UNaIAParser.ID, 0)

        def EN(self):
            return self.getToken(UNaIAParser.EN, 0)

        def STRING(self, i:int=None):
            if i is None:
                return self.getTokens(UNaIAParser.STRING)
            else:
                return self.getToken(UNaIAParser.STRING, i)

        def COMO(self):
            return self.getToken(UNaIAParser.COMO, 0)

        def getRuleIndex(self):
            return UNaIAParser.RULE_exportacion

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExportacion" ):
                listener.enterExportacion(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExportacion" ):
                listener.exitExportacion(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExportacion" ):
                return visitor.visitExportacion(self)
            else:
                return visitor.visitChildren(self)




    def exportacion(self):

        localctx = UNaIAParser.ExportacionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_exportacion)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 142
            self.match(UNaIAParser.EXPORTAR)
            self.state = 143
            self.match(UNaIAParser.ID)
            self.state = 146
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==UNaIAParser.EN:
                self.state = 144
                self.match(UNaIAParser.EN)
                self.state = 145
                self.match(UNaIAParser.STRING)


            self.state = 150
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==UNaIAParser.COMO:
                self.state = 148
                self.match(UNaIAParser.COMO)
                self.state = 149
                self.match(UNaIAParser.STRING)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class QuantilContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def QUANTIL(self):
            return self.getToken(UNaIAParser.QUANTIL, 0)

        def ID(self):
            return self.getToken(UNaIAParser.ID, 0)

        def STRING(self):
            return self.getToken(UNaIAParser.STRING, 0)

        def getRuleIndex(self):
            return UNaIAParser.RULE_quantil

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQuantil" ):
                listener.enterQuantil(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQuantil" ):
                listener.exitQuantil(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQuantil" ):
                return visitor.visitQuantil(self)
            else:
                return visitor.visitChildren(self)




    def quantil(self):

        localctx = UNaIAParser.QuantilContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_quantil)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 152
            self.match(UNaIAParser.QUANTIL)
            self.state = 153
            self.match(UNaIAParser.ID)
            self.state = 154
            self.match(UNaIAParser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class EstandarizacionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ESTANDARIZAR(self):
            return self.getToken(UNaIAParser.ESTANDARIZAR, 0)

        def ID(self):
            return self.getToken(UNaIAParser.ID, 0)

        def STRING(self):
            return self.getToken(UNaIAParser.STRING, 0)

        def getRuleIndex(self):
            return UNaIAParser.RULE_estandarizacion

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEstandarizacion" ):
                listener.enterEstandarizacion(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEstandarizacion" ):
                listener.exitEstandarizacion(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEstandarizacion" ):
                return visitor.visitEstandarizacion(self)
            else:
                return visitor.visitChildren(self)




    def estandarizacion(self):

        localctx = UNaIAParser.EstandarizacionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_estandarizacion)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 156
            self.match(UNaIAParser.ESTANDARIZAR)
            self.state = 157
            self.match(UNaIAParser.ID)
            self.state = 158
            self.match(UNaIAParser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class EscaladominmaxContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def MINMAX(self):
            return self.getToken(UNaIAParser.MINMAX, 0)

        def ID(self):
            return self.getToken(UNaIAParser.ID, 0)

        def STRING(self):
            return self.getToken(UNaIAParser.STRING, 0)

        def getRuleIndex(self):
            return UNaIAParser.RULE_escaladominmax

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEscaladominmax" ):
                listener.enterEscaladominmax(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEscaladominmax" ):
                listener.exitEscaladominmax(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEscaladominmax" ):
                return visitor.visitEscaladominmax(self)
            else:
                return visitor.visitChildren(self)




    def escaladominmax(self):

        localctx = UNaIAParser.EscaladominmaxContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_escaladominmax)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 160
            self.match(UNaIAParser.MINMAX)
            self.state = 161
            self.match(UNaIAParser.ID)
            self.state = 162
            self.match(UNaIAParser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx


    class Codigo_pythonContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PYTHON(self):
            return self.getToken(UNaIAParser.PYTHON, 0)

        def getRuleIndex(self):
            return UNaIAParser.RULE_codigo_python

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCodigo_python" ):
                listener.enterCodigo_python(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCodigo_python" ):
                listener.exitCodigo_python(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCodigo_python" ):
                return visitor.visitCodigo_python(self)
            else:
                return visitor.visitChildren(self)




    def codigo_python(self):

        localctx = UNaIAParser.Codigo_pythonContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_codigo_python)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 164
            self.match(UNaIAParser.PYTHON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
            exit(1)
        finally:
            self.exitRule()
        return localctx





