# Generated from UNML.g4 by ANTLR 4.7
# encoding: utf-8
from __future__ import print_function
from antlr4 import *
from io import StringIO
import sys

def serializedATN():
    with StringIO() as buf:
        buf.write(u"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3")
        buf.write(u"^\u01af\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t")
        buf.write(u"\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")
        buf.write(u"\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4")
        buf.write(u"\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30")
        buf.write(u"\t\30\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2")
        buf.write(u"\3\2\3\2\3\2\3\2\5\2A\n\2\3\3\3\3\3\4\7\4F\n\4\f\4\16")
        buf.write(u"\4I\13\4\3\4\3\4\3\5\6\5N\n\5\r\5\16\5O\3\5\3\5\3\5\3")
        buf.write(u"\5\3\6\3\6\3\6\3\6\3\6\5\6[\n\6\3\6\3\6\3\6\3\6\3\6\5")
        buf.write(u"\6b\n\6\3\6\5\6e\n\6\3\7\3\7\3\b\3\b\3\t\3\t\5\tm\n\t")
        buf.write(u"\3\n\3\n\3\n\7\nr\n\n\f\n\16\nu\13\n\3\n\3\n\3\13\3\13")
        buf.write(u"\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f")
        buf.write(u"\3\f\3\f\3\f\7\f\u008a\n\f\f\f\16\f\u008d\13\f\3\f\3")
        buf.write(u"\f\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\16\7\16\u0099\n")
        buf.write(u"\16\f\16\16\16\u009c\13\16\3\16\3\16\3\16\3\16\3\16\3")
        buf.write(u"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16")
        buf.write(u"\6\16\u00ae\n\16\r\16\16\16\u00af\3\16\3\16\5\16\u00b4")
        buf.write(u"\n\16\3\17\3\17\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3")
        buf.write(u"\21\3\21\3\21\3\21\5\21\u00c3\n\21\3\22\3\22\3\22\3\22")
        buf.write(u"\3\22\3\22\3\22\3\22\3\22\3\22\7\22\u00cf\n\22\f\22\16")
        buf.write(u"\22\u00d2\13\22\3\22\3\22\5\22\u00d6\n\22\3\23\3\23\3")
        buf.write(u"\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23")
        buf.write(u"\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3")
        buf.write(u"\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u00f7\n\23")
        buf.write(u"\3\24\3\24\3\24\3\24\3\24\7\24\u00fe\n\24\f\24\16\24")
        buf.write(u"\u0101\13\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\7\24")
        buf.write(u"\u010a\n\24\f\24\16\24\u010d\13\24\3\24\3\24\5\24\u0111")
        buf.write(u"\n\24\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3")
        buf.write(u"\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25")
        buf.write(u"\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3")
        buf.write(u"\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25")
        buf.write(u"\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3")
        buf.write(u"\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25")
        buf.write(u"\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3")
        buf.write(u"\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25")
        buf.write(u"\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3")
        buf.write(u"\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25")
        buf.write(u"\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3")
        buf.write(u"\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25")
        buf.write(u"\3\25\3\25\3\25\3\25\3\25\5\25\u0195\n\25\3\26\3\26\3")
        buf.write(u"\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\5\26")
        buf.write(u"\u01a3\n\26\3\27\3\27\3\27\7\27\u01a8\n\27\f\27\16\27")
        buf.write(u"\u01ab\13\27\3\30\3\30\3\30\2\2\31\2\4\6\b\n\f\16\20")
        buf.write(u"\22\24\26\30\32\34\36 \"$&(*,.\2\b\4\2\5\589\3\2Y[\3")
        buf.write(u"\2 !\3\2?@\3\2?D\3\2:;\2\u01d1\2@\3\2\2\2\4B\3\2\2\2")
        buf.write(u"\6G\3\2\2\2\bM\3\2\2\2\nd\3\2\2\2\ff\3\2\2\2\16h\3\2")
        buf.write(u"\2\2\20l\3\2\2\2\22n\3\2\2\2\24x\3\2\2\2\26~\3\2\2\2")
        buf.write(u"\30\u0090\3\2\2\2\32\u00b3\3\2\2\2\34\u00b5\3\2\2\2\36")
        buf.write(u"\u00b7\3\2\2\2 \u00c2\3\2\2\2\"\u00d5\3\2\2\2$\u00f6")
        buf.write(u"\3\2\2\2&\u0110\3\2\2\2(\u0194\3\2\2\2*\u01a2\3\2\2\2")
        buf.write(u",\u01a4\3\2\2\2.\u01ac\3\2\2\2\60\61\7\22\2\2\61\62\7")
        buf.write(u"\t\2\2\62\63\5\4\3\2\63\64\7\n\2\2\64\65\7\23\2\2\65")
        buf.write(u"A\3\2\2\2\66\67\7\22\2\2\678\7\t\2\289\7\n\2\29A\7\23")
        buf.write(u"\2\2:;\7\22\2\2;<\7\t\2\2<=\5$\23\2=>\7\n\2\2>?\7\23")
        buf.write(u"\2\2?A\3\2\2\2@\60\3\2\2\2@\66\3\2\2\2@:\3\2\2\2A\3\3")
        buf.write(u"\2\2\2BC\5\6\4\2C\5\3\2\2\2DF\5\b\5\2ED\3\2\2\2FI\3\2")
        buf.write(u"\2\2GE\3\2\2\2GH\3\2\2\2HJ\3\2\2\2IG\3\2\2\2JK\5\b\5")
        buf.write(u"\2K\7\3\2\2\2LN\5\n\6\2ML\3\2\2\2NO\3\2\2\2OM\3\2\2\2")
        buf.write(u"OP\3\2\2\2PQ\3\2\2\2QR\5\22\n\2RS\7#\2\2ST\7\4\2\2T\t")
        buf.write(u"\3\2\2\2UV\7$\2\2VZ\7X\2\2WX\5\f\7\2XY\5\16\b\2Y[\3\2")
        buf.write(u"\2\2ZW\3\2\2\2Z[\3\2\2\2[\\\3\2\2\2\\e\7\4\2\2]^\7%\2")
        buf.write(u"\2^_\7Y\2\2_a\7\6\2\2`b\5\20\t\2a`\3\2\2\2ab\3\2\2\2")
        buf.write(u"bc\3\2\2\2ce\7\4\2\2dU\3\2\2\2d]\3\2\2\2e\13\3\2\2\2")
        buf.write(u"fg\t\2\2\2g\r\3\2\2\2hi\t\3\2\2i\17\3\2\2\2jm\7%\2\2")
        buf.write(u"km\5\16\b\2lj\3\2\2\2lk\3\2\2\2m\21\3\2\2\2no\7\20\2")
        buf.write(u"\2os\5\24\13\2pr\5\26\f\2qp\3\2\2\2ru\3\2\2\2sq\3\2\2")
        buf.write(u"\2st\3\2\2\2tv\3\2\2\2us\3\2\2\2vw\7\21\2\2w\23\3\2\2")
        buf.write(u"\2xy\5\30\r\2yz\7Y\2\2z{\7\17\2\2{|\5\32\16\2|}\7\4\2")
        buf.write(u"\2}\25\3\2\2\2~\177\7\"\2\2\177\u0080\7Y\2\2\u0080\u0081")
        buf.write(u"\7\17\2\2\u0081\u0082\5\32\16\2\u0082\u0083\7\16\2\2")
        buf.write(u"\u0083\u0084\5\f\7\2\u0084\u008b\5\16\b\2\u0085\u0086")
        buf.write(u"\7\16\2\2\u0086\u0087\5\f\7\2\u0087\u0088\5\16\b\2\u0088")
        buf.write(u"\u008a\3\2\2\2\u0089\u0085\3\2\2\2\u008a\u008d\3\2\2")
        buf.write(u"\2\u008b\u0089\3\2\2\2\u008b\u008c\3\2\2\2\u008c\u008e")
        buf.write(u"\3\2\2\2\u008d\u008b\3\2\2\2\u008e\u008f\7\4\2\2\u008f")
        buf.write(u"\27\3\2\2\2\u0090\u0091\t\4\2\2\u0091\31\3\2\2\2\u0092")
        buf.write(u"\u0093\5\16\b\2\u0093\u0094\7A\2\2\u0094\u009a\7X\2\2")
        buf.write(u"\u0095\u0096\5\34\17\2\u0096\u0097\5\32\16\2\u0097\u0099")
        buf.write(u"\3\2\2\2\u0098\u0095\3\2\2\2\u0099\u009c\3\2\2\2\u009a")
        buf.write(u"\u0098\3\2\2\2\u009a\u009b\3\2\2\2\u009b\u00b4\3\2\2")
        buf.write(u"\2\u009c\u009a\3\2\2\2\u009d\u009e\7\7\2\2\u009e\u009f")
        buf.write(u"\5\32\16\2\u009f\u00a0\7\b\2\2\u00a0\u00b4\3\2\2\2\u00a1")
        buf.write(u"\u00b4\7X\2\2\u00a2\u00a3\7X\2\2\u00a3\u00a4\5\34\17")
        buf.write(u"\2\u00a4\u00a5\5\32\16\2\u00a5\u00b4\3\2\2\2\u00a6\u00a7")
        buf.write(u"\5\16\b\2\u00a7\u00a8\5\36\20\2\u00a8\u00ad\7\7\2\2\u00a9")
        buf.write(u"\u00aa\7X\2\2\u00aa\u00ab\5\34\17\2\u00ab\u00ac\7X\2")
        buf.write(u"\2\u00ac\u00ae\3\2\2\2\u00ad\u00a9\3\2\2\2\u00ae\u00af")
        buf.write(u"\3\2\2\2\u00af\u00ad\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0")
        buf.write(u"\u00b1\3\2\2\2\u00b1\u00b2\7\b\2\2\u00b2\u00b4\3\2\2")
        buf.write(u"\2\u00b3\u0092\3\2\2\2\u00b3\u009d\3\2\2\2\u00b3\u00a1")
        buf.write(u"\3\2\2\2\u00b3\u00a2\3\2\2\2\u00b3\u00a6\3\2\2\2\u00b4")
        buf.write(u"\33\3\2\2\2\u00b5\u00b6\t\5\2\2\u00b6\35\3\2\2\2\u00b7")
        buf.write(u"\u00b8\t\6\2\2\u00b8\37\3\2\2\2\u00b9\u00ba\7\7\2\2\u00ba")
        buf.write(u"\u00bb\5 \21\2\u00bb\u00bc\7\b\2\2\u00bc\u00c3\3\2\2")
        buf.write(u"\2\u00bd\u00c3\5\16\b\2\u00be\u00c3\5&\24\2\u00bf\u00c3")
        buf.write(u"\5(\25\2\u00c0\u00c3\5*\26\2\u00c1\u00c3\3\2\2\2\u00c2")
        buf.write(u"\u00b9\3\2\2\2\u00c2\u00bd\3\2\2\2\u00c2\u00be\3\2\2")
        buf.write(u"\2\u00c2\u00bf\3\2\2\2\u00c2\u00c0\3\2\2\2\u00c2\u00c1")
        buf.write(u"\3\2\2\2\u00c3!\3\2\2\2\u00c4\u00c5\7\7\2\2\u00c5\u00c6")
        buf.write(u"\5\"\22\2\u00c6\u00c7\7\b\2\2\u00c7\u00d6\3\2\2\2\u00c8")
        buf.write(u"\u00c9\5\16\b\2\u00c9\u00ca\5\36\20\2\u00ca\u00d0\5\16")
        buf.write(u"\b\2\u00cb\u00cc\5\36\20\2\u00cc\u00cd\5\"\22\2\u00cd")
        buf.write(u"\u00cf\3\2\2\2\u00ce\u00cb\3\2\2\2\u00cf\u00d2\3\2\2")
        buf.write(u"\2\u00d0\u00ce\3\2\2\2\u00d0\u00d1\3\2\2\2\u00d1\u00d6")
        buf.write(u"\3\2\2\2\u00d2\u00d0\3\2\2\2\u00d3\u00d6\5 \21\2\u00d4")
        buf.write(u"\u00d6\5$\23\2\u00d5\u00c4\3\2\2\2\u00d5\u00c8\3\2\2")
        buf.write(u"\2\u00d5\u00d3\3\2\2\2\u00d5\u00d4\3\2\2\2\u00d6#\3\2")
        buf.write(u"\2\2\u00d7\u00d8\7\7\2\2\u00d8\u00d9\5$\23\2\u00d9\u00da")
        buf.write(u"\7\b\2\2\u00da\u00f7\3\2\2\2\u00db\u00dc\7<\2\2\u00dc")
        buf.write(u"\u00dd\7\7\2\2\u00dd\u00de\7Y\2\2\u00de\u00f7\7\b\2\2")
        buf.write(u"\u00df\u00e0\7<\2\2\u00e0\u00e1\7\7\2\2\u00e1\u00e2\5")
        buf.write(u"$\23\2\u00e2\u00e3\7\b\2\2\u00e3\u00f7\3\2\2\2\u00e4")
        buf.write(u"\u00e5\7\7\2\2\u00e5\u00e6\7Y\2\2\u00e6\u00e7\5\f\7\2")
        buf.write(u"\u00e7\u00e8\7Y\2\2\u00e8\u00e9\7\b\2\2\u00e9\u00f7\3")
        buf.write(u"\2\2\2\u00ea\u00eb\7\7\2\2\u00eb\u00ec\7Y\2\2\u00ec\u00ed")
        buf.write(u"\5.\30\2\u00ed\u00ee\7Y\2\2\u00ee\u00ef\7\b\2\2\u00ef")
        buf.write(u"\u00f7\3\2\2\2\u00f0\u00f1\7\7\2\2\u00f1\u00f2\5$\23")
        buf.write(u"\2\u00f2\u00f3\5.\30\2\u00f3\u00f4\5$\23\2\u00f4\u00f5")
        buf.write(u"\7\b\2\2\u00f5\u00f7\3\2\2\2\u00f6\u00d7\3\2\2\2\u00f6")
        buf.write(u"\u00db\3\2\2\2\u00f6\u00df\3\2\2\2\u00f6\u00e4\3\2\2")
        buf.write(u"\2\u00f6\u00ea\3\2\2\2\u00f6\u00f0\3\2\2\2\u00f7%\3\2")
        buf.write(u"\2\2\u00f8\u00f9\7Y\2\2\u00f9\u00fa\7\13\2\2\u00fa\u00ff")
        buf.write(u"\5$\23\2\u00fb\u00fc\7\16\2\2\u00fc\u00fe\5$\23\2\u00fd")
        buf.write(u"\u00fb\3\2\2\2\u00fe\u0101\3\2\2\2\u00ff\u00fd\3\2\2")
        buf.write(u"\2\u00ff\u0100\3\2\2\2\u0100\u0102\3\2\2\2\u0101\u00ff")
        buf.write(u"\3\2\2\2\u0102\u0103\7\4\2\2\u0103\u0111\3\2\2\2\u0104")
        buf.write(u"\u0105\7Y\2\2\u0105\u0106\7\13\2\2\u0106\u010b\5 \21")
        buf.write(u"\2\u0107\u0108\7\16\2\2\u0108\u010a\5 \21\2\u0109\u0107")
        buf.write(u"\3\2\2\2\u010a\u010d\3\2\2\2\u010b\u0109\3\2\2\2\u010b")
        buf.write(u"\u010c\3\2\2\2\u010c\u010e\3\2\2\2\u010d\u010b\3\2\2")
        buf.write(u"\2\u010e\u010f\7\4\2\2\u010f\u0111\3\2\2\2\u0110\u00f8")
        buf.write(u"\3\2\2\2\u0110\u0104\3\2\2\2\u0111\'\3\2\2\2\u0112\u0113")
        buf.write(u"\7E\2\2\u0113\u0114\7\7\2\2\u0114\u0115\5\16\b\2\u0115")
        buf.write(u"\u0116\7\b\2\2\u0116\u0195\3\2\2\2\u0117\u0118\7F\2\2")
        buf.write(u"\u0118\u0119\7\7\2\2\u0119\u011a\5\16\b\2\u011a\u011b")
        buf.write(u"\7\b\2\2\u011b\u0195\3\2\2\2\u011c\u011d\7F\2\2\u011d")
        buf.write(u"\u011e\7\7\2\2\u011e\u011f\5\16\b\2\u011f\u0120\7\16")
        buf.write(u"\2\2\u0120\u0121\5\16\b\2\u0121\u0122\7\b\2\2\u0122\u0195")
        buf.write(u"\3\2\2\2\u0123\u0124\7G\2\2\u0124\u0125\7\7\2\2\u0125")
        buf.write(u"\u0126\5\16\b\2\u0126\u0127\7\b\2\2\u0127\u0195\3\2\2")
        buf.write(u"\2\u0128\u0129\7H\2\2\u0129\u012a\7\7\2\2\u012a\u012b")
        buf.write(u"\5\16\b\2\u012b\u012c\7\b\2\2\u012c\u0195\3\2\2\2\u012d")
        buf.write(u"\u012e\7I\2\2\u012e\u012f\7\7\2\2\u012f\u0130\5\16\b")
        buf.write(u"\2\u0130\u0131\7\b\2\2\u0131\u0195\3\2\2\2\u0132\u0133")
        buf.write(u"\7K\2\2\u0133\u0134\7\7\2\2\u0134\u0135\5\16\b\2\u0135")
        buf.write(u"\u0136\7\b\2\2\u0136\u0195\3\2\2\2\u0137\u0138\7L\2\2")
        buf.write(u"\u0138\u0139\7\7\2\2\u0139\u013a\5\16\b\2\u013a\u013b")
        buf.write(u"\7\b\2\2\u013b\u0195\3\2\2\2\u013c\u013d\7M\2\2\u013d")
        buf.write(u"\u013e\7\7\2\2\u013e\u013f\5\16\b\2\u013f\u0140\7\b\2")
        buf.write(u"\2\u0140\u0195\3\2\2\2\u0141\u0142\7N\2\2\u0142\u0143")
        buf.write(u"\7\7\2\2\u0143\u0144\5\16\b\2\u0144\u0145\7\b\2\2\u0145")
        buf.write(u"\u0195\3\2\2\2\u0146\u0147\7!\2\2\u0147\u0148\7\7\2\2")
        buf.write(u"\u0148\u0149\5,\27\2\u0149\u014a\7\b\2\2\u014a\u0195")
        buf.write(u"\3\2\2\2\u014b\u014c\7 \2\2\u014c\u014d\7\7\2\2\u014d")
        buf.write(u"\u014e\5,\27\2\u014e\u014f\7\b\2\2\u014f\u0195\3\2\2")
        buf.write(u"\2\u0150\u0151\7O\2\2\u0151\u0152\7\7\2\2\u0152\u0153")
        buf.write(u"\5\16\b\2\u0153\u0154\7\b\2\2\u0154\u0195\3\2\2\2\u0155")
        buf.write(u"\u0156\7O\2\2\u0156\u0157\7\7\2\2\u0157\u0158\5\16\b")
        buf.write(u"\2\u0158\u0159\7\16\2\2\u0159\u015a\5\16\b\2\u015a\u015b")
        buf.write(u"\7\b\2\2\u015b\u0195\3\2\2\2\u015c\u015d\7P\2\2\u015d")
        buf.write(u"\u015e\7\7\2\2\u015e\u015f\5\16\b\2\u015f\u0160\7\b\2")
        buf.write(u"\2\u0160\u0195\3\2\2\2\u0161\u0162\7Q\2\2\u0162\u0163")
        buf.write(u"\7\7\2\2\u0163\u0164\5\16\b\2\u0164\u0165\7\b\2\2\u0165")
        buf.write(u"\u0195\3\2\2\2\u0166\u0167\7R\2\2\u0167\u0168\7\7\2\2")
        buf.write(u"\u0168\u0169\5\16\b\2\u0169\u016a\7\b\2\2\u016a\u0195")
        buf.write(u"\3\2\2\2\u016b\u016c\7S\2\2\u016c\u016d\7\7\2\2\u016d")
        buf.write(u"\u016e\5\16\b\2\u016e\u016f\7\b\2\2\u016f\u0195\3\2\2")
        buf.write(u"\2\u0170\u0171\7T\2\2\u0171\u0172\7\7\2\2\u0172\u0195")
        buf.write(u"\7\b\2\2\u0173\u0174\7T\2\2\u0174\u0175\7\7\2\2\u0175")
        buf.write(u"\u0176\5\16\b\2\u0176\u0177\7\16\2\2\u0177\u0178\5\16")
        buf.write(u"\b\2\u0178\u0179\7\b\2\2\u0179\u0195\3\2\2\2\u017a\u017b")
        buf.write(u"\7U\2\2\u017b\u017c\7\7\2\2\u017c\u0195\7\b\2\2\u017d")
        buf.write(u"\u017e\7U\2\2\u017e\u017f\7\7\2\2\u017f\u0180\5\16\b")
        buf.write(u"\2\u0180\u0181\7\16\2\2\u0181\u0182\5\16\b\2\u0182\u0183")
        buf.write(u"\7\b\2\2\u0183\u0195\3\2\2\2\u0184\u0185\7V\2\2\u0185")
        buf.write(u"\u0186\7\7\2\2\u0186\u0187\5\16\b\2\u0187\u0188\7\16")
        buf.write(u"\2\2\u0188\u0189\5\16\b\2\u0189\u018a\7\b\2\2\u018a\u0195")
        buf.write(u"\3\2\2\2\u018b\u018c\7V\2\2\u018c\u018d\7\7\2\2\u018d")
        buf.write(u"\u018e\5\16\b\2\u018e\u018f\7\16\2\2\u018f\u0190\5\16")
        buf.write(u"\b\2\u0190\u0191\7\16\2\2\u0191\u0192\5\16\b\2\u0192")
        buf.write(u"\u0193\7\b\2\2\u0193\u0195\3\2\2\2\u0194\u0112\3\2\2")
        buf.write(u"\2\u0194\u0117\3\2\2\2\u0194\u011c\3\2\2\2\u0194\u0123")
        buf.write(u"\3\2\2\2\u0194\u0128\3\2\2\2\u0194\u012d\3\2\2\2\u0194")
        buf.write(u"\u0132\3\2\2\2\u0194\u0137\3\2\2\2\u0194\u013c\3\2\2")
        buf.write(u"\2\u0194\u0141\3\2\2\2\u0194\u0146\3\2\2\2\u0194\u014b")
        buf.write(u"\3\2\2\2\u0194\u0150\3\2\2\2\u0194\u0155\3\2\2\2\u0194")
        buf.write(u"\u015c\3\2\2\2\u0194\u0161\3\2\2\2\u0194\u0166\3\2\2")
        buf.write(u"\2\u0194\u016b\3\2\2\2\u0194\u0170\3\2\2\2\u0194\u0173")
        buf.write(u"\3\2\2\2\u0194\u017a\3\2\2\2\u0194\u017d\3\2\2\2\u0194")
        buf.write(u"\u0184\3\2\2\2\u0194\u018b\3\2\2\2\u0195)\3\2\2\2\u0196")
        buf.write(u"\u0197\7+\2\2\u0197\u0198\5$\23\2\u0198\u0199\7-\2\2")
        buf.write(u"\u0199\u019a\5 \21\2\u019a\u01a3\3\2\2\2\u019b\u019c")
        buf.write(u"\7+\2\2\u019c\u019d\5$\23\2\u019d\u019e\7-\2\2\u019e")
        buf.write(u"\u019f\5 \21\2\u019f\u01a0\7,\2\2\u01a0\u01a1\5 \21\2")
        buf.write(u"\u01a1\u01a3\3\2\2\2\u01a2\u0196\3\2\2\2\u01a2\u019b")
        buf.write(u"\3\2\2\2\u01a3+\3\2\2\2\u01a4\u01a9\7Y\2\2\u01a5\u01a6")
        buf.write(u"\7\16\2\2\u01a6\u01a8\7Y\2\2\u01a7\u01a5\3\2\2\2\u01a8")
        buf.write(u"\u01ab\3\2\2\2\u01a9\u01a7\3\2\2\2\u01a9\u01aa\3\2\2")
        buf.write(u"\2\u01aa-\3\2\2\2\u01ab\u01a9\3\2\2\2\u01ac\u01ad\t\7")
        buf.write(u"\2\2\u01ad/\3\2\2\2\30@GOZadls\u008b\u009a\u00af\u00b3")
        buf.write(u"\u00c2\u00d0\u00d5\u00f6\u00ff\u010b\u0110\u0194\u01a2")
        buf.write(u"\u01a9")
        return buf.getvalue()


class UNMLParser ( Parser ):

    grammarFileName = "UNML.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ u"<INVALID>", u"<INVALID>", u"';'", u"'='", u"':='", 
                     u"'('", u"')'", u"'{'", u"'}'", u"'['", u"']'", u"'X~'", 
                     u"','", u"':'", u"'begin'", u"'end'", u"'MODEL'", u"'ENDMODEL'", 
                     u"'union'", u"'by'", u"'cross'", u"'in'", u"'within'", 
                     u"'diff'", u"'inter'", u"'symdiff'", u"'set'", u"'vector'", 
                     u"'matrix'", u"'simplex'", u"'minimize'", u"'maximize'", 
                     u"'constrain'", u"'solve'", u"'var'", u"'param'", u"'int'", 
                     u"'double'", u"'string'", u"'boolean'", u"'null'", 
                     u"'if'", u"'else'", u"'then'", u"'while'", u"'break'", 
                     u"'do'", u"'for'", u"'select'", u"'case'", u"'=='", 
                     u"<INVALID>", u"'>'", u"'<'", u"'>='", u"'<='", u"<INVALID>", 
                     u"<INVALID>", u"<INVALID>", u"'true'", u"'false'", 
                     u"'+'", u"'-'", u"'*'", u"'/'", u"'%'", u"<INVALID>", 
                     u"'abs'", u"'atan'", u"'card'", u"'ceil'", u"'cos'", 
                     u"'exp'", u"'floor'", u"'length'", u"'log'", u"'log10'", 
                     u"'round'", u"'sin'", u"'sqrt'", u"'tan'", u"'trunc'", 
                     u"'uniform'", u"'normal'", u"'substr'" ]

    symbolicNames = [ u"<INVALID>", u"COMMENT", u"SEMICOLON", u"ASSING", 
                      u"ALLOCATE", u"LF_PAREN", u"RG_PAREN", u"LF_BRACE", 
                      u"RG_BRACE", u"LF_SPARE", u"RG_SPARE", u"SEPARATOR", 
                      u"COMMA", u"TWO_POINTS", u"DELIMITER_BEGIN", u"DELIMITER_END", 
                      u"MODEL", u"ENDMODEL", u"UNION", u"BY", u"CROSS", 
                      u"IN", u"WITHIN", u"DIFF", u"INTER", u"SYMDIFF", u"SET", 
                      u"VECTOR", u"MATRIX", u"SIMPLEX", u"MINIMIZE", u"MAXIMIZE", 
                      u"CONSTRAIN", u"SOLVE", u"VARIBLE", u"PARAMETER", 
                      u"INT", u"DOUBLE", u"STRING", u"BOOL", u"NULL", u"IF", 
                      u"ELSE", u"THEN", u"WHILE", u"BREAK", u"DO", u"FOR", 
                      u"SELECT", u"CASE", u"EQUAL", u"DIFFERENT", u"GREATER", 
                      u"MINOR", u"GREATER_THAN", u"MINOR_THAN", u"AND", 
                      u"OR", u"NOT", u"TRUE", u"FALSE", u"ADD", u"MINUS", 
                      u"MULT", u"DIV", u"MOD", u"EXP", u"ABS", u"ATAN", 
                      u"CARD", u"CEIL", u"COS", u"EXP_FUN", u"FLOOR", u"LENGTH", 
                      u"LOG", u"LOGTEN", u"ROUND", u"SIN", u"SQRT", u"TAN", 
                      u"TRUNCT", u"UNIFORM", u"NORMAL", u"SUBSTR", u"SIGN", 
                      u"VAR_ID", u"ID", u"INTEGER", u"REAL", u"WORD", u"WS", 
                      u"OTHER" ]

    RULE_compilationUnit = 0
    RULE_block = 1
    RULE_propositions_sequence = 2
    RULE_proposition = 3
    RULE_assign_statement = 4
    RULE_inequation_operator = 5
    RULE_numeric_literal = 6
    RULE_option = 7
    RULE_building_block = 8
    RULE_function_statement = 9
    RULE_constrain_statement = 10
    RULE_type_objective = 11
    RULE_lineal_expression = 12
    RULE_lineal_operator = 13
    RULE_aritmetic_operator = 14
    RULE_numeric_expression = 15
    RULE_aritmetic_expression = 16
    RULE_logical_expression = 17
    RULE_subscripted_parameters = 18
    RULE_function_reference = 19
    RULE_conditional_expression = 20
    RULE_list_of_ids = 21
    RULE_logic_operator = 22

    ruleNames =  [ u"compilationUnit", u"block", u"propositions_sequence", 
                   u"proposition", u"assign_statement", u"inequation_operator", 
                   u"numeric_literal", u"option", u"building_block", u"function_statement", 
                   u"constrain_statement", u"type_objective", u"lineal_expression", 
                   u"lineal_operator", u"aritmetic_operator", u"numeric_expression", 
                   u"aritmetic_expression", u"logical_expression", u"subscripted_parameters", 
                   u"function_reference", u"conditional_expression", u"list_of_ids", 
                   u"logic_operator" ]

    EOF = Token.EOF
    COMMENT=1
    SEMICOLON=2
    ASSING=3
    ALLOCATE=4
    LF_PAREN=5
    RG_PAREN=6
    LF_BRACE=7
    RG_BRACE=8
    LF_SPARE=9
    RG_SPARE=10
    SEPARATOR=11
    COMMA=12
    TWO_POINTS=13
    DELIMITER_BEGIN=14
    DELIMITER_END=15
    MODEL=16
    ENDMODEL=17
    UNION=18
    BY=19
    CROSS=20
    IN=21
    WITHIN=22
    DIFF=23
    INTER=24
    SYMDIFF=25
    SET=26
    VECTOR=27
    MATRIX=28
    SIMPLEX=29
    MINIMIZE=30
    MAXIMIZE=31
    CONSTRAIN=32
    SOLVE=33
    VARIBLE=34
    PARAMETER=35
    INT=36
    DOUBLE=37
    STRING=38
    BOOL=39
    NULL=40
    IF=41
    ELSE=42
    THEN=43
    WHILE=44
    BREAK=45
    DO=46
    FOR=47
    SELECT=48
    CASE=49
    EQUAL=50
    DIFFERENT=51
    GREATER=52
    MINOR=53
    GREATER_THAN=54
    MINOR_THAN=55
    AND=56
    OR=57
    NOT=58
    TRUE=59
    FALSE=60
    ADD=61
    MINUS=62
    MULT=63
    DIV=64
    MOD=65
    EXP=66
    ABS=67
    ATAN=68
    CARD=69
    CEIL=70
    COS=71
    EXP_FUN=72
    FLOOR=73
    LENGTH=74
    LOG=75
    LOGTEN=76
    ROUND=77
    SIN=78
    SQRT=79
    TAN=80
    TRUNCT=81
    UNIFORM=82
    NORMAL=83
    SUBSTR=84
    SIGN=85
    VAR_ID=86
    ID=87
    INTEGER=88
    REAL=89
    WORD=90
    WS=91
    OTHER=92

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



    class CompilationUnitContext(ParserRuleContext):

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

        def MODEL(self):
            return self.getToken(UNMLParser.MODEL, 0)

        def LF_BRACE(self):
            return self.getToken(UNMLParser.LF_BRACE, 0)

        def block(self):
            return self.getTypedRuleContext(UNMLParser.BlockContext,0)


        def RG_BRACE(self):
            return self.getToken(UNMLParser.RG_BRACE, 0)

        def ENDMODEL(self):
            return self.getToken(UNMLParser.ENDMODEL, 0)

        def logical_expression(self):
            return self.getTypedRuleContext(UNMLParser.Logical_expressionContext,0)


        def getRuleIndex(self):
            return UNMLParser.RULE_compilationUnit

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

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

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




    def compilationUnit(self):

        localctx = UNMLParser.CompilationUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_compilationUnit)
        try:
            self.state = 62
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 46
                self.match(UNMLParser.MODEL)
                self.state = 47
                self.match(UNMLParser.LF_BRACE)
                self.state = 48
                self.block()
                self.state = 49
                self.match(UNMLParser.RG_BRACE)
                self.state = 50
                self.match(UNMLParser.ENDMODEL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 52
                self.match(UNMLParser.MODEL)
                self.state = 53
                self.match(UNMLParser.LF_BRACE)
                self.state = 54
                self.match(UNMLParser.RG_BRACE)
                self.state = 55
                self.match(UNMLParser.ENDMODEL)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 56
                self.match(UNMLParser.MODEL)
                self.state = 57
                self.match(UNMLParser.LF_BRACE)
                self.state = 58
                self.logical_expression()
                self.state = 59
                self.match(UNMLParser.RG_BRACE)
                self.state = 60
                self.match(UNMLParser.ENDMODEL)
                pass


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

    class BlockContext(ParserRuleContext):

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

        def propositions_sequence(self):
            return self.getTypedRuleContext(UNMLParser.Propositions_sequenceContext,0)


        def getRuleIndex(self):
            return UNMLParser.RULE_block

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

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

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




    def block(self):

        localctx = UNMLParser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_block)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 64
            self.propositions_sequence()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Propositions_sequenceContext(ParserRuleContext):

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

        def proposition(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.PropositionContext)
            else:
                return self.getTypedRuleContext(UNMLParser.PropositionContext,i)


        def getRuleIndex(self):
            return UNMLParser.RULE_propositions_sequence

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

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

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




    def propositions_sequence(self):

        localctx = UNMLParser.Propositions_sequenceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_propositions_sequence)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 69
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,1,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 66
                    self.proposition() 
                self.state = 71
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,1,self._ctx)

            self.state = 72
            self.proposition()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PropositionContext(ParserRuleContext):

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

        def building_block(self):
            return self.getTypedRuleContext(UNMLParser.Building_blockContext,0)


        def SOLVE(self):
            return self.getToken(UNMLParser.SOLVE, 0)

        def SEMICOLON(self):
            return self.getToken(UNMLParser.SEMICOLON, 0)

        def assign_statement(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.Assign_statementContext)
            else:
                return self.getTypedRuleContext(UNMLParser.Assign_statementContext,i)


        def getRuleIndex(self):
            return UNMLParser.RULE_proposition

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

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

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




    def proposition(self):

        localctx = UNMLParser.PropositionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_proposition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 75 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 74
                self.assign_statement()
                self.state = 77 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==UNMLParser.VARIBLE or _la==UNMLParser.PARAMETER):
                    break

            self.state = 79
            self.building_block()
            self.state = 80
            self.match(UNMLParser.SOLVE)
            self.state = 81
            self.match(UNMLParser.SEMICOLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Assign_statementContext(ParserRuleContext):

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

        def VARIBLE(self):
            return self.getToken(UNMLParser.VARIBLE, 0)

        def VAR_ID(self):
            return self.getToken(UNMLParser.VAR_ID, 0)

        def SEMICOLON(self):
            return self.getToken(UNMLParser.SEMICOLON, 0)

        def inequation_operator(self):
            return self.getTypedRuleContext(UNMLParser.Inequation_operatorContext,0)


        def numeric_literal(self):
            return self.getTypedRuleContext(UNMLParser.Numeric_literalContext,0)


        def PARAMETER(self):
            return self.getToken(UNMLParser.PARAMETER, 0)

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

        def ALLOCATE(self):
            return self.getToken(UNMLParser.ALLOCATE, 0)

        def option(self):
            return self.getTypedRuleContext(UNMLParser.OptionContext,0)


        def getRuleIndex(self):
            return UNMLParser.RULE_assign_statement

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

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

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




    def assign_statement(self):

        localctx = UNMLParser.Assign_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_assign_statement)
        self._la = 0 # Token type
        try:
            self.state = 98
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [UNMLParser.VARIBLE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 83
                self.match(UNMLParser.VARIBLE)
                self.state = 84
                self.match(UNMLParser.VAR_ID)
                self.state = 88
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << UNMLParser.ASSING) | (1 << UNMLParser.GREATER_THAN) | (1 << UNMLParser.MINOR_THAN))) != 0):
                    self.state = 85
                    self.inequation_operator()
                    self.state = 86
                    self.numeric_literal()


                self.state = 90
                self.match(UNMLParser.SEMICOLON)
                pass
            elif token in [UNMLParser.PARAMETER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 91
                self.match(UNMLParser.PARAMETER)
                self.state = 92
                self.match(UNMLParser.ID)
                self.state = 93
                self.match(UNMLParser.ALLOCATE)
                self.state = 95
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 35)) & ~0x3f) == 0 and ((1 << (_la - 35)) & ((1 << (UNMLParser.PARAMETER - 35)) | (1 << (UNMLParser.ID - 35)) | (1 << (UNMLParser.INTEGER - 35)) | (1 << (UNMLParser.REAL - 35)))) != 0):
                    self.state = 94
                    self.option()


                self.state = 97
                self.match(UNMLParser.SEMICOLON)
                pass
            else:
                raise NoViableAltException(self)

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

    class Inequation_operatorContext(ParserRuleContext):

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

        def GREATER_THAN(self):
            return self.getToken(UNMLParser.GREATER_THAN, 0)

        def ASSING(self):
            return self.getToken(UNMLParser.ASSING, 0)

        def MINOR_THAN(self):
            return self.getToken(UNMLParser.MINOR_THAN, 0)

        def getRuleIndex(self):
            return UNMLParser.RULE_inequation_operator

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

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

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




    def inequation_operator(self):

        localctx = UNMLParser.Inequation_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_inequation_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 100
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << UNMLParser.ASSING) | (1 << UNMLParser.GREATER_THAN) | (1 << UNMLParser.MINOR_THAN))) != 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)
        finally:
            self.exitRule()
        return localctx

    class Numeric_literalContext(ParserRuleContext):

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

        def INTEGER(self):
            return self.getToken(UNMLParser.INTEGER, 0)

        def REAL(self):
            return self.getToken(UNMLParser.REAL, 0)

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

        def getRuleIndex(self):
            return UNMLParser.RULE_numeric_literal

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

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

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




    def numeric_literal(self):

        localctx = UNMLParser.Numeric_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_numeric_literal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 102
            _la = self._input.LA(1)
            if not(((((_la - 87)) & ~0x3f) == 0 and ((1 << (_la - 87)) & ((1 << (UNMLParser.ID - 87)) | (1 << (UNMLParser.INTEGER - 87)) | (1 << (UNMLParser.REAL - 87)))) != 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)
        finally:
            self.exitRule()
        return localctx

    class OptionContext(ParserRuleContext):

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

        def PARAMETER(self):
            return self.getToken(UNMLParser.PARAMETER, 0)

        def numeric_literal(self):
            return self.getTypedRuleContext(UNMLParser.Numeric_literalContext,0)


        def getRuleIndex(self):
            return UNMLParser.RULE_option

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

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

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




    def option(self):

        localctx = UNMLParser.OptionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_option)
        try:
            self.state = 106
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [UNMLParser.PARAMETER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 104
                self.match(UNMLParser.PARAMETER)
                pass
            elif token in [UNMLParser.ID, UNMLParser.INTEGER, UNMLParser.REAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 105
                self.numeric_literal()
                pass
            else:
                raise NoViableAltException(self)

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

    class Building_blockContext(ParserRuleContext):

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

        def DELIMITER_BEGIN(self):
            return self.getToken(UNMLParser.DELIMITER_BEGIN, 0)

        def function_statement(self):
            return self.getTypedRuleContext(UNMLParser.Function_statementContext,0)


        def DELIMITER_END(self):
            return self.getToken(UNMLParser.DELIMITER_END, 0)

        def constrain_statement(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.Constrain_statementContext)
            else:
                return self.getTypedRuleContext(UNMLParser.Constrain_statementContext,i)


        def getRuleIndex(self):
            return UNMLParser.RULE_building_block

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

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

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




    def building_block(self):

        localctx = UNMLParser.Building_blockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_building_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 108
            self.match(UNMLParser.DELIMITER_BEGIN)
            self.state = 109
            self.function_statement()
            self.state = 113
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==UNMLParser.CONSTRAIN:
                self.state = 110
                self.constrain_statement()
                self.state = 115
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 116
            self.match(UNMLParser.DELIMITER_END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Function_statementContext(ParserRuleContext):

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

        def type_objective(self):
            return self.getTypedRuleContext(UNMLParser.Type_objectiveContext,0)


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

        def TWO_POINTS(self):
            return self.getToken(UNMLParser.TWO_POINTS, 0)

        def lineal_expression(self):
            return self.getTypedRuleContext(UNMLParser.Lineal_expressionContext,0)


        def SEMICOLON(self):
            return self.getToken(UNMLParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return UNMLParser.RULE_function_statement

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

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

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




    def function_statement(self):

        localctx = UNMLParser.Function_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_function_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 118
            self.type_objective()
            self.state = 119
            self.match(UNMLParser.ID)
            self.state = 120
            self.match(UNMLParser.TWO_POINTS)
            self.state = 121
            self.lineal_expression()
            self.state = 122
            self.match(UNMLParser.SEMICOLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Constrain_statementContext(ParserRuleContext):

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

        def CONSTRAIN(self):
            return self.getToken(UNMLParser.CONSTRAIN, 0)

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

        def TWO_POINTS(self):
            return self.getToken(UNMLParser.TWO_POINTS, 0)

        def lineal_expression(self):
            return self.getTypedRuleContext(UNMLParser.Lineal_expressionContext,0)


        def COMMA(self, i=None):
            if i is None:
                return self.getTokens(UNMLParser.COMMA)
            else:
                return self.getToken(UNMLParser.COMMA, i)

        def inequation_operator(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.Inequation_operatorContext)
            else:
                return self.getTypedRuleContext(UNMLParser.Inequation_operatorContext,i)


        def numeric_literal(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.Numeric_literalContext)
            else:
                return self.getTypedRuleContext(UNMLParser.Numeric_literalContext,i)


        def SEMICOLON(self):
            return self.getToken(UNMLParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return UNMLParser.RULE_constrain_statement

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

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

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




    def constrain_statement(self):

        localctx = UNMLParser.Constrain_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_constrain_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 124
            self.match(UNMLParser.CONSTRAIN)
            self.state = 125
            self.match(UNMLParser.ID)
            self.state = 126
            self.match(UNMLParser.TWO_POINTS)
            self.state = 127
            self.lineal_expression()
            self.state = 128
            self.match(UNMLParser.COMMA)
            self.state = 129
            self.inequation_operator()
            self.state = 130
            self.numeric_literal()
            self.state = 137
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==UNMLParser.COMMA:
                self.state = 131
                self.match(UNMLParser.COMMA)
                self.state = 132
                self.inequation_operator()
                self.state = 133
                self.numeric_literal()
                self.state = 139
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 140
            self.match(UNMLParser.SEMICOLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Type_objectiveContext(ParserRuleContext):

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

        def MAXIMIZE(self):
            return self.getToken(UNMLParser.MAXIMIZE, 0)

        def MINIMIZE(self):
            return self.getToken(UNMLParser.MINIMIZE, 0)

        def getRuleIndex(self):
            return UNMLParser.RULE_type_objective

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

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

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




    def type_objective(self):

        localctx = UNMLParser.Type_objectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_type_objective)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 142
            _la = self._input.LA(1)
            if not(_la==UNMLParser.MINIMIZE or _la==UNMLParser.MAXIMIZE):
                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)
        finally:
            self.exitRule()
        return localctx

    class Lineal_expressionContext(ParserRuleContext):

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

        def numeric_literal(self):
            return self.getTypedRuleContext(UNMLParser.Numeric_literalContext,0)


        def MULT(self):
            return self.getToken(UNMLParser.MULT, 0)

        def VAR_ID(self, i=None):
            if i is None:
                return self.getTokens(UNMLParser.VAR_ID)
            else:
                return self.getToken(UNMLParser.VAR_ID, i)

        def lineal_operator(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.Lineal_operatorContext)
            else:
                return self.getTypedRuleContext(UNMLParser.Lineal_operatorContext,i)


        def lineal_expression(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.Lineal_expressionContext)
            else:
                return self.getTypedRuleContext(UNMLParser.Lineal_expressionContext,i)


        def LF_PAREN(self):
            return self.getToken(UNMLParser.LF_PAREN, 0)

        def RG_PAREN(self):
            return self.getToken(UNMLParser.RG_PAREN, 0)

        def aritmetic_operator(self):
            return self.getTypedRuleContext(UNMLParser.Aritmetic_operatorContext,0)


        def getRuleIndex(self):
            return UNMLParser.RULE_lineal_expression

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

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

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




    def lineal_expression(self):

        localctx = UNMLParser.Lineal_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_lineal_expression)
        self._la = 0 # Token type
        try:
            self.state = 177
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 144
                self.numeric_literal()
                self.state = 145
                self.match(UNMLParser.MULT)
                self.state = 146
                self.match(UNMLParser.VAR_ID)
                self.state = 152
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,9,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 147
                        self.lineal_operator()
                        self.state = 148
                        self.lineal_expression() 
                    self.state = 154
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,9,self._ctx)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 155
                self.match(UNMLParser.LF_PAREN)
                self.state = 156
                self.lineal_expression()
                self.state = 157
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 159
                self.match(UNMLParser.VAR_ID)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 160
                self.match(UNMLParser.VAR_ID)
                self.state = 161
                self.lineal_operator()
                self.state = 162
                self.lineal_expression()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 164
                self.numeric_literal()
                self.state = 165
                self.aritmetic_operator()
                self.state = 166
                self.match(UNMLParser.LF_PAREN)
                self.state = 171 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 167
                    self.match(UNMLParser.VAR_ID)
                    self.state = 168
                    self.lineal_operator()
                    self.state = 169
                    self.match(UNMLParser.VAR_ID)
                    self.state = 173 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==UNMLParser.VAR_ID):
                        break

                self.state = 175
                self.match(UNMLParser.RG_PAREN)
                pass


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

    class Lineal_operatorContext(ParserRuleContext):

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

        def ADD(self):
            return self.getToken(UNMLParser.ADD, 0)

        def MINUS(self):
            return self.getToken(UNMLParser.MINUS, 0)

        def getRuleIndex(self):
            return UNMLParser.RULE_lineal_operator

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

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

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




    def lineal_operator(self):

        localctx = UNMLParser.Lineal_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_lineal_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 179
            _la = self._input.LA(1)
            if not(_la==UNMLParser.ADD or _la==UNMLParser.MINUS):
                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)
        finally:
            self.exitRule()
        return localctx

    class Aritmetic_operatorContext(ParserRuleContext):

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

        def ADD(self):
            return self.getToken(UNMLParser.ADD, 0)

        def MINUS(self):
            return self.getToken(UNMLParser.MINUS, 0)

        def MULT(self):
            return self.getToken(UNMLParser.MULT, 0)

        def DIV(self):
            return self.getToken(UNMLParser.DIV, 0)

        def MOD(self):
            return self.getToken(UNMLParser.MOD, 0)

        def EXP(self):
            return self.getToken(UNMLParser.EXP, 0)

        def getRuleIndex(self):
            return UNMLParser.RULE_aritmetic_operator

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

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

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




    def aritmetic_operator(self):

        localctx = UNMLParser.Aritmetic_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_aritmetic_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 181
            _la = self._input.LA(1)
            if not(((((_la - 61)) & ~0x3f) == 0 and ((1 << (_la - 61)) & ((1 << (UNMLParser.ADD - 61)) | (1 << (UNMLParser.MINUS - 61)) | (1 << (UNMLParser.MULT - 61)) | (1 << (UNMLParser.DIV - 61)) | (1 << (UNMLParser.MOD - 61)) | (1 << (UNMLParser.EXP - 61)))) != 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)
        finally:
            self.exitRule()
        return localctx

    class Numeric_expressionContext(ParserRuleContext):

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

        def LF_PAREN(self):
            return self.getToken(UNMLParser.LF_PAREN, 0)

        def numeric_expression(self):
            return self.getTypedRuleContext(UNMLParser.Numeric_expressionContext,0)


        def RG_PAREN(self):
            return self.getToken(UNMLParser.RG_PAREN, 0)

        def numeric_literal(self):
            return self.getTypedRuleContext(UNMLParser.Numeric_literalContext,0)


        def subscripted_parameters(self):
            return self.getTypedRuleContext(UNMLParser.Subscripted_parametersContext,0)


        def function_reference(self):
            return self.getTypedRuleContext(UNMLParser.Function_referenceContext,0)


        def conditional_expression(self):
            return self.getTypedRuleContext(UNMLParser.Conditional_expressionContext,0)


        def getRuleIndex(self):
            return UNMLParser.RULE_numeric_expression

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

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

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




    def numeric_expression(self):

        localctx = UNMLParser.Numeric_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_numeric_expression)
        try:
            self.state = 192
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 183
                self.match(UNMLParser.LF_PAREN)
                self.state = 184
                self.numeric_expression()
                self.state = 185
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 187
                self.numeric_literal()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 188
                self.subscripted_parameters()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 189
                self.function_reference()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 190
                self.conditional_expression()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)

                pass


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

    class Aritmetic_expressionContext(ParserRuleContext):

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

        def LF_PAREN(self):
            return self.getToken(UNMLParser.LF_PAREN, 0)

        def aritmetic_expression(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.Aritmetic_expressionContext)
            else:
                return self.getTypedRuleContext(UNMLParser.Aritmetic_expressionContext,i)


        def RG_PAREN(self):
            return self.getToken(UNMLParser.RG_PAREN, 0)

        def numeric_literal(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.Numeric_literalContext)
            else:
                return self.getTypedRuleContext(UNMLParser.Numeric_literalContext,i)


        def aritmetic_operator(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.Aritmetic_operatorContext)
            else:
                return self.getTypedRuleContext(UNMLParser.Aritmetic_operatorContext,i)


        def numeric_expression(self):
            return self.getTypedRuleContext(UNMLParser.Numeric_expressionContext,0)


        def logical_expression(self):
            return self.getTypedRuleContext(UNMLParser.Logical_expressionContext,0)


        def getRuleIndex(self):
            return UNMLParser.RULE_aritmetic_expression

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

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

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




    def aritmetic_expression(self):

        localctx = UNMLParser.Aritmetic_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_aritmetic_expression)
        try:
            self.state = 211
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 194
                self.match(UNMLParser.LF_PAREN)
                self.state = 195
                self.aritmetic_expression()
                self.state = 196
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 198
                self.numeric_literal()
                self.state = 199
                self.aritmetic_operator()
                self.state = 200
                self.numeric_literal()
                self.state = 206
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,13,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 201
                        self.aritmetic_operator()
                        self.state = 202
                        self.aritmetic_expression() 
                    self.state = 208
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,13,self._ctx)

                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 209
                self.numeric_expression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 210
                self.logical_expression()
                pass


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

    class Logical_expressionContext(ParserRuleContext):

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

        def LF_PAREN(self):
            return self.getToken(UNMLParser.LF_PAREN, 0)

        def logical_expression(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.Logical_expressionContext)
            else:
                return self.getTypedRuleContext(UNMLParser.Logical_expressionContext,i)


        def RG_PAREN(self):
            return self.getToken(UNMLParser.RG_PAREN, 0)

        def NOT(self):
            return self.getToken(UNMLParser.NOT, 0)

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

        def inequation_operator(self):
            return self.getTypedRuleContext(UNMLParser.Inequation_operatorContext,0)


        def logic_operator(self):
            return self.getTypedRuleContext(UNMLParser.Logic_operatorContext,0)


        def getRuleIndex(self):
            return UNMLParser.RULE_logical_expression

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

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

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




    def logical_expression(self):

        localctx = UNMLParser.Logical_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_logical_expression)
        try:
            self.state = 244
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 213
                self.match(UNMLParser.LF_PAREN)
                self.state = 214
                self.logical_expression()
                self.state = 215
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 217
                self.match(UNMLParser.NOT)
                self.state = 218
                self.match(UNMLParser.LF_PAREN)
                self.state = 219
                self.match(UNMLParser.ID)
                self.state = 220
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 221
                self.match(UNMLParser.NOT)
                self.state = 222
                self.match(UNMLParser.LF_PAREN)
                self.state = 223
                self.logical_expression()
                self.state = 224
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 226
                self.match(UNMLParser.LF_PAREN)
                self.state = 227
                self.match(UNMLParser.ID)
                self.state = 228
                self.inequation_operator()
                self.state = 229
                self.match(UNMLParser.ID)
                self.state = 230
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 232
                self.match(UNMLParser.LF_PAREN)
                self.state = 233
                self.match(UNMLParser.ID)
                self.state = 234
                self.logic_operator()
                self.state = 235
                self.match(UNMLParser.ID)
                self.state = 236
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 238
                self.match(UNMLParser.LF_PAREN)
                self.state = 239
                self.logical_expression()
                self.state = 240
                self.logic_operator()
                self.state = 241
                self.logical_expression()
                self.state = 242
                self.match(UNMLParser.RG_PAREN)
                pass


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

    class Subscripted_parametersContext(ParserRuleContext):

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

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

        def LF_SPARE(self):
            return self.getToken(UNMLParser.LF_SPARE, 0)

        def logical_expression(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.Logical_expressionContext)
            else:
                return self.getTypedRuleContext(UNMLParser.Logical_expressionContext,i)


        def SEMICOLON(self):
            return self.getToken(UNMLParser.SEMICOLON, 0)

        def COMMA(self, i=None):
            if i is None:
                return self.getTokens(UNMLParser.COMMA)
            else:
                return self.getToken(UNMLParser.COMMA, i)

        def numeric_expression(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.Numeric_expressionContext)
            else:
                return self.getTypedRuleContext(UNMLParser.Numeric_expressionContext,i)


        def getRuleIndex(self):
            return UNMLParser.RULE_subscripted_parameters

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

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

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




    def subscripted_parameters(self):

        localctx = UNMLParser.Subscripted_parametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_subscripted_parameters)
        self._la = 0 # Token type
        try:
            self.state = 270
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 246
                self.match(UNMLParser.ID)
                self.state = 247
                self.match(UNMLParser.LF_SPARE)
                self.state = 248
                self.logical_expression()
                self.state = 253
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==UNMLParser.COMMA:
                    self.state = 249
                    self.match(UNMLParser.COMMA)
                    self.state = 250
                    self.logical_expression()
                    self.state = 255
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 256
                self.match(UNMLParser.SEMICOLON)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 258
                self.match(UNMLParser.ID)
                self.state = 259
                self.match(UNMLParser.LF_SPARE)
                self.state = 260
                self.numeric_expression()
                self.state = 265
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==UNMLParser.COMMA:
                    self.state = 261
                    self.match(UNMLParser.COMMA)
                    self.state = 262
                    self.numeric_expression()
                    self.state = 267
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 268
                self.match(UNMLParser.SEMICOLON)
                pass


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

    class Function_referenceContext(ParserRuleContext):

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

        def ABS(self):
            return self.getToken(UNMLParser.ABS, 0)

        def LF_PAREN(self):
            return self.getToken(UNMLParser.LF_PAREN, 0)

        def numeric_literal(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.Numeric_literalContext)
            else:
                return self.getTypedRuleContext(UNMLParser.Numeric_literalContext,i)


        def RG_PAREN(self):
            return self.getToken(UNMLParser.RG_PAREN, 0)

        def ATAN(self):
            return self.getToken(UNMLParser.ATAN, 0)

        def COMMA(self, i=None):
            if i is None:
                return self.getTokens(UNMLParser.COMMA)
            else:
                return self.getToken(UNMLParser.COMMA, i)

        def CARD(self):
            return self.getToken(UNMLParser.CARD, 0)

        def CEIL(self):
            return self.getToken(UNMLParser.CEIL, 0)

        def COS(self):
            return self.getToken(UNMLParser.COS, 0)

        def FLOOR(self):
            return self.getToken(UNMLParser.FLOOR, 0)

        def LENGTH(self):
            return self.getToken(UNMLParser.LENGTH, 0)

        def LOG(self):
            return self.getToken(UNMLParser.LOG, 0)

        def LOGTEN(self):
            return self.getToken(UNMLParser.LOGTEN, 0)

        def MAXIMIZE(self):
            return self.getToken(UNMLParser.MAXIMIZE, 0)

        def list_of_ids(self):
            return self.getTypedRuleContext(UNMLParser.List_of_idsContext,0)


        def MINIMIZE(self):
            return self.getToken(UNMLParser.MINIMIZE, 0)

        def ROUND(self):
            return self.getToken(UNMLParser.ROUND, 0)

        def SIN(self):
            return self.getToken(UNMLParser.SIN, 0)

        def SQRT(self):
            return self.getToken(UNMLParser.SQRT, 0)

        def TAN(self):
            return self.getToken(UNMLParser.TAN, 0)

        def TRUNCT(self):
            return self.getToken(UNMLParser.TRUNCT, 0)

        def UNIFORM(self):
            return self.getToken(UNMLParser.UNIFORM, 0)

        def NORMAL(self):
            return self.getToken(UNMLParser.NORMAL, 0)

        def SUBSTR(self):
            return self.getToken(UNMLParser.SUBSTR, 0)

        def getRuleIndex(self):
            return UNMLParser.RULE_function_reference

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

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

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




    def function_reference(self):

        localctx = UNMLParser.Function_referenceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_function_reference)
        try:
            self.state = 402
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 272
                self.match(UNMLParser.ABS)
                self.state = 273
                self.match(UNMLParser.LF_PAREN)
                self.state = 274
                self.numeric_literal()
                self.state = 275
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 277
                self.match(UNMLParser.ATAN)
                self.state = 278
                self.match(UNMLParser.LF_PAREN)
                self.state = 279
                self.numeric_literal()
                self.state = 280
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 282
                self.match(UNMLParser.ATAN)
                self.state = 283
                self.match(UNMLParser.LF_PAREN)
                self.state = 284
                self.numeric_literal()
                self.state = 285
                self.match(UNMLParser.COMMA)
                self.state = 286
                self.numeric_literal()
                self.state = 287
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 289
                self.match(UNMLParser.CARD)
                self.state = 290
                self.match(UNMLParser.LF_PAREN)
                self.state = 291
                self.numeric_literal()
                self.state = 292
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 294
                self.match(UNMLParser.CEIL)
                self.state = 295
                self.match(UNMLParser.LF_PAREN)
                self.state = 296
                self.numeric_literal()
                self.state = 297
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 299
                self.match(UNMLParser.COS)
                self.state = 300
                self.match(UNMLParser.LF_PAREN)
                self.state = 301
                self.numeric_literal()
                self.state = 302
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 304
                self.match(UNMLParser.FLOOR)
                self.state = 305
                self.match(UNMLParser.LF_PAREN)
                self.state = 306
                self.numeric_literal()
                self.state = 307
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 309
                self.match(UNMLParser.LENGTH)
                self.state = 310
                self.match(UNMLParser.LF_PAREN)
                self.state = 311
                self.numeric_literal()
                self.state = 312
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 314
                self.match(UNMLParser.LOG)
                self.state = 315
                self.match(UNMLParser.LF_PAREN)
                self.state = 316
                self.numeric_literal()
                self.state = 317
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 319
                self.match(UNMLParser.LOGTEN)
                self.state = 320
                self.match(UNMLParser.LF_PAREN)
                self.state = 321
                self.numeric_literal()
                self.state = 322
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 324
                self.match(UNMLParser.MAXIMIZE)
                self.state = 325
                self.match(UNMLParser.LF_PAREN)
                self.state = 326
                self.list_of_ids()
                self.state = 327
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 329
                self.match(UNMLParser.MINIMIZE)
                self.state = 330
                self.match(UNMLParser.LF_PAREN)
                self.state = 331
                self.list_of_ids()
                self.state = 332
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 334
                self.match(UNMLParser.ROUND)
                self.state = 335
                self.match(UNMLParser.LF_PAREN)
                self.state = 336
                self.numeric_literal()
                self.state = 337
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 339
                self.match(UNMLParser.ROUND)
                self.state = 340
                self.match(UNMLParser.LF_PAREN)
                self.state = 341
                self.numeric_literal()
                self.state = 342
                self.match(UNMLParser.COMMA)
                self.state = 343
                self.numeric_literal()
                self.state = 344
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 346
                self.match(UNMLParser.SIN)
                self.state = 347
                self.match(UNMLParser.LF_PAREN)
                self.state = 348
                self.numeric_literal()
                self.state = 349
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 351
                self.match(UNMLParser.SQRT)
                self.state = 352
                self.match(UNMLParser.LF_PAREN)
                self.state = 353
                self.numeric_literal()
                self.state = 354
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 356
                self.match(UNMLParser.TAN)
                self.state = 357
                self.match(UNMLParser.LF_PAREN)
                self.state = 358
                self.numeric_literal()
                self.state = 359
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 361
                self.match(UNMLParser.TRUNCT)
                self.state = 362
                self.match(UNMLParser.LF_PAREN)
                self.state = 363
                self.numeric_literal()
                self.state = 364
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 366
                self.match(UNMLParser.UNIFORM)
                self.state = 367
                self.match(UNMLParser.LF_PAREN)
                self.state = 368
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 369
                self.match(UNMLParser.UNIFORM)
                self.state = 370
                self.match(UNMLParser.LF_PAREN)
                self.state = 371
                self.numeric_literal()
                self.state = 372
                self.match(UNMLParser.COMMA)
                self.state = 373
                self.numeric_literal()
                self.state = 374
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 376
                self.match(UNMLParser.NORMAL)
                self.state = 377
                self.match(UNMLParser.LF_PAREN)
                self.state = 378
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 379
                self.match(UNMLParser.NORMAL)
                self.state = 380
                self.match(UNMLParser.LF_PAREN)
                self.state = 381
                self.numeric_literal()
                self.state = 382
                self.match(UNMLParser.COMMA)
                self.state = 383
                self.numeric_literal()
                self.state = 384
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)
                self.state = 386
                self.match(UNMLParser.SUBSTR)
                self.state = 387
                self.match(UNMLParser.LF_PAREN)
                self.state = 388
                self.numeric_literal()
                self.state = 389
                self.match(UNMLParser.COMMA)
                self.state = 390
                self.numeric_literal()
                self.state = 391
                self.match(UNMLParser.RG_PAREN)
                pass

            elif la_ == 24:
                self.enterOuterAlt(localctx, 24)
                self.state = 393
                self.match(UNMLParser.SUBSTR)
                self.state = 394
                self.match(UNMLParser.LF_PAREN)
                self.state = 395
                self.numeric_literal()
                self.state = 396
                self.match(UNMLParser.COMMA)
                self.state = 397
                self.numeric_literal()
                self.state = 398
                self.match(UNMLParser.COMMA)
                self.state = 399
                self.numeric_literal()
                self.state = 400
                self.match(UNMLParser.RG_PAREN)
                pass


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

    class Conditional_expressionContext(ParserRuleContext):

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

        def IF(self):
            return self.getToken(UNMLParser.IF, 0)

        def logical_expression(self):
            return self.getTypedRuleContext(UNMLParser.Logical_expressionContext,0)


        def THEN(self):
            return self.getToken(UNMLParser.THEN, 0)

        def numeric_expression(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(UNMLParser.Numeric_expressionContext)
            else:
                return self.getTypedRuleContext(UNMLParser.Numeric_expressionContext,i)


        def ELSE(self):
            return self.getToken(UNMLParser.ELSE, 0)

        def getRuleIndex(self):
            return UNMLParser.RULE_conditional_expression

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

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

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




    def conditional_expression(self):

        localctx = UNMLParser.Conditional_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_conditional_expression)
        try:
            self.state = 416
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 404
                self.match(UNMLParser.IF)
                self.state = 405
                self.logical_expression()
                self.state = 406
                self.match(UNMLParser.THEN)
                self.state = 407
                self.numeric_expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 409
                self.match(UNMLParser.IF)
                self.state = 410
                self.logical_expression()
                self.state = 411
                self.match(UNMLParser.THEN)
                self.state = 412
                self.numeric_expression()
                self.state = 413
                self.match(UNMLParser.ELSE)
                self.state = 414
                self.numeric_expression()
                pass


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

    class List_of_idsContext(ParserRuleContext):

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

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

        def COMMA(self, i=None):
            if i is None:
                return self.getTokens(UNMLParser.COMMA)
            else:
                return self.getToken(UNMLParser.COMMA, i)

        def getRuleIndex(self):
            return UNMLParser.RULE_list_of_ids

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

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

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




    def list_of_ids(self):

        localctx = UNMLParser.List_of_idsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_list_of_ids)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 418
            self.match(UNMLParser.ID)
            self.state = 423
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==UNMLParser.COMMA:
                self.state = 419
                self.match(UNMLParser.COMMA)
                self.state = 420
                self.match(UNMLParser.ID)
                self.state = 425
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class Logic_operatorContext(ParserRuleContext):

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

        def AND(self):
            return self.getToken(UNMLParser.AND, 0)

        def OR(self):
            return self.getToken(UNMLParser.OR, 0)

        def getRuleIndex(self):
            return UNMLParser.RULE_logic_operator

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

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

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




    def logic_operator(self):

        localctx = UNMLParser.Logic_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_logic_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 426
            _la = self._input.LA(1)
            if not(_la==UNMLParser.AND or _la==UNMLParser.OR):
                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)
        finally:
            self.exitRule()
        return localctx





