# Generated from /home/ax/Workspace/norm/norm/grammar/norm.g4 by ANTLR 4.7.2
# encoding: utf-8
from antlr4 import *
from io import StringIO
from typing.io import TextIO
import sys


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3H")
        buf.write("\u0367\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\3\2\3\2\5\2e\n\2\3\2\3\2\7\2")
        buf.write("i\n\2\f\2\16\2l\13\2\3\2\3\2\5\2p\n\2\3\2\3\2\7\2t\n\2")
        buf.write("\f\2\16\2w\13\2\3\2\5\2z\n\2\3\3\3\3\5\3~\n\3\3\3\3\3")
        buf.write("\5\3\u0082\n\3\3\3\3\3\5\3\u0086\n\3\3\3\3\3\5\3\u008a")
        buf.write("\n\3\3\3\5\3\u008d\n\3\3\3\3\3\5\3\u0091\n\3\3\3\5\3\u0094")
        buf.write("\n\3\3\3\3\3\5\3\u0098\n\3\3\3\3\3\5\3\u009c\n\3\3\3\3")
        buf.write("\3\3\3\3\3\3\3\5\3\u00a3\n\3\3\3\5\3\u00a6\n\3\3\3\3\3")
        buf.write("\5\3\u00aa\n\3\3\3\3\3\5\3\u00ae\n\3\3\3\3\3\3\3\3\3\3")
        buf.write("\3\5\3\u00b5\n\3\3\3\5\3\u00b8\n\3\3\3\3\3\5\3\u00bc\n")
        buf.write("\3\3\3\3\3\5\3\u00c0\n\3\3\3\3\3\3\3\5\3\u00c5\n\3\3\3")
        buf.write("\5\3\u00c8\n\3\3\3\3\3\5\3\u00cc\n\3\3\3\3\3\5\3\u00d0")
        buf.write("\n\3\3\3\5\3\u00d3\n\3\5\3\u00d5\n\3\3\4\3\4\3\4\7\4\u00da")
        buf.write("\n\4\f\4\16\4\u00dd\13\4\5\4\u00df\n\4\3\5\3\5\3\5\3\5")
        buf.write("\3\5\5\5\u00e6\n\5\3\5\3\5\3\5\7\5\u00eb\n\5\f\5\16\5")
        buf.write("\u00ee\13\5\3\5\5\5\u00f1\n\5\3\5\3\5\5\5\u00f5\n\5\3")
        buf.write("\5\5\5\u00f8\n\5\5\5\u00fa\n\5\3\6\3\6\3\6\3\6\7\6\u0100")
        buf.write("\n\6\f\6\16\6\u0103\13\6\3\6\3\6\3\6\3\6\3\6\3\6\7\6\u010b")
        buf.write("\n\6\f\6\16\6\u010e\13\6\3\6\3\6\3\6\5\6\u0113\n\6\3\6")
        buf.write("\3\6\5\6\u0117\n\6\3\6\5\6\u011a\n\6\5\6\u011c\n\6\3\7")
        buf.write("\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u012a")
        buf.write("\n\b\3\b\3\b\5\b\u012e\n\b\3\b\7\b\u0131\n\b\f\b\16\b")
        buf.write("\u0134\13\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u013c\n\b\3\b")
        buf.write("\3\b\5\b\u0140\n\b\3\b\7\b\u0143\n\b\f\b\16\b\u0146\13")
        buf.write("\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u014e\n\b\3\b\3\b\5\b\u0152")
        buf.write("\n\b\3\b\7\b\u0155\n\b\f\b\16\b\u0158\13\b\3\b\3\b\3\b")
        buf.write("\3\b\3\b\3\b\5\b\u0160\n\b\3\b\3\b\5\b\u0164\n\b\3\b\7")
        buf.write("\b\u0167\n\b\f\b\16\b\u016a\13\b\3\b\3\b\5\b\u016e\n\b")
        buf.write("\3\t\3\t\5\t\u0172\n\t\3\t\3\t\5\t\u0176\n\t\3\t\7\t\u0179")
        buf.write("\n\t\f\t\16\t\u017c\13\t\3\t\5\t\u017f\n\t\3\t\3\t\3\n")
        buf.write("\3\n\5\n\u0185\n\n\3\n\3\n\3\n\3\n\5\n\u018b\n\n\3\13")
        buf.write("\5\13\u018e\n\13\3\13\3\13\3\13\3\13\5\13\u0194\n\13\3")
        buf.write("\13\3\13\3\13\3\13\7\13\u019a\n\13\f\13\16\13\u019d\13")
        buf.write("\13\3\f\3\f\3\f\3\f\3\f\5\f\u01a4\n\f\3\f\3\f\3\f\7\f")
        buf.write("\u01a9\n\f\f\f\16\f\u01ac\13\f\3\r\5\r\u01af\n\r\3\r\3")
        buf.write("\r\5\r\u01b3\n\r\3\r\3\r\5\r\u01b7\n\r\3\r\3\r\5\r\u01bb")
        buf.write("\n\r\3\r\3\r\5\r\u01bf\n\r\3\r\3\r\5\r\u01c3\n\r\3\16")
        buf.write("\3\16\5\16\u01c7\n\16\3\16\3\16\5\16\u01cb\n\16\3\16\3")
        buf.write("\16\5\16\u01cf\n\16\3\16\5\16\u01d2\n\16\3\17\3\17\5\17")
        buf.write("\u01d6\n\17\3\17\3\17\5\17\u01da\n\17\3\17\7\17\u01dd")
        buf.write("\n\17\f\17\16\17\u01e0\13\17\3\20\3\20\3\20\5\20\u01e5")
        buf.write("\n\20\3\20\3\20\5\20\u01e9\n\20\3\20\3\20\5\20\u01ed\n")
        buf.write("\20\3\21\3\21\5\21\u01f1\n\21\3\21\3\21\5\21\u01f5\n\21")
        buf.write("\3\21\7\21\u01f8\n\21\f\21\16\21\u01fb\13\21\3\22\3\22")
        buf.write("\5\22\u01ff\n\22\3\22\3\22\3\22\3\22\5\22\u0205\n\22\3")
        buf.write("\23\3\23\5\23\u0209\n\23\3\23\3\23\5\23\u020d\n\23\3\23")
        buf.write("\3\23\3\24\3\24\5\24\u0213\n\24\3\24\3\24\5\24\u0217\n")
        buf.write("\24\3\24\7\24\u021a\n\24\f\24\16\24\u021d\13\24\3\25\3")
        buf.write("\25\3\25\3\25\3\25\5\25\u0224\n\25\3\25\5\25\u0227\n\25")
        buf.write("\3\25\3\25\5\25\u022b\n\25\3\25\5\25\u022e\n\25\3\26\3")
        buf.write("\26\3\27\3\27\5\27\u0234\n\27\3\27\3\27\3\27\3\27\5\27")
        buf.write("\u023a\n\27\3\27\3\27\5\27\u023e\n\27\3\27\7\27\u0241")
        buf.write("\n\27\f\27\16\27\u0244\13\27\3\27\3\27\5\27\u0248\n\27")
        buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30")
        buf.write("\3\30\5\30\u0256\n\30\3\30\3\30\5\30\u025a\n\30\3\30\7")
        buf.write("\30\u025d\n\30\f\30\16\30\u0260\13\30\3\30\3\30\3\30\3")
        buf.write("\30\3\30\5\30\u0267\n\30\3\30\3\30\5\30\u026b\n\30\3\30")
        buf.write("\7\30\u026e\n\30\f\30\16\30\u0271\13\30\3\30\3\30\5\30")
        buf.write("\u0275\n\30\3\31\7\31\u0278\n\31\f\31\16\31\u027b\13\31")
        buf.write("\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33")
        buf.write("\5\33\u0288\n\33\3\33\3\33\5\33\u028c\n\33\3\33\3\33\5")
        buf.write("\33\u0290\n\33\3\33\3\33\3\33\3\33\5\33\u0296\n\33\5\33")
        buf.write("\u0298\n\33\3\34\3\34\3\34\3\34\3\34\5\34\u029f\n\34\3")
        buf.write("\34\3\34\5\34\u02a3\n\34\3\34\7\34\u02a6\n\34\f\34\16")
        buf.write("\34\u02a9\13\34\3\34\3\34\5\34\u02ad\n\34\3\35\3\35\3")
        buf.write("\35\3\35\3\35\3\35\3\35\5\35\u02b6\n\35\3\35\3\35\5\35")
        buf.write("\u02ba\n\35\3\35\3\35\5\35\u02be\n\35\3\35\7\35\u02c1")
        buf.write("\n\35\f\35\16\35\u02c4\13\35\3\36\3\36\3\36\3\36\5\36")
        buf.write("\u02ca\n\36\3\36\5\36\u02cd\n\36\3\36\5\36\u02d0\n\36")
        buf.write("\3\36\5\36\u02d3\n\36\3\36\5\36\u02d6\n\36\3\36\3\36\3")
        buf.write("\36\3\36\3\36\3\36\3\36\5\36\u02df\n\36\3\37\3\37\3\37")
        buf.write("\3\37\3\37\3\37\3\37\3\37\3\37\5\37\u02ea\n\37\3\37\3")
        buf.write("\37\5\37\u02ee\n\37\3\37\3\37\5\37\u02f2\n\37\3\37\3\37")
        buf.write("\3\37\5\37\u02f7\n\37\3\37\3\37\5\37\u02fb\n\37\3\37\3")
        buf.write("\37\3\37\5\37\u0300\n\37\3\37\3\37\5\37\u0304\n\37\3\37")
        buf.write("\7\37\u0307\n\37\f\37\16\37\u030a\13\37\3 \3 \3 \3 \3")
        buf.write(" \5 \u0311\n \3!\3!\3!\5!\u0316\n!\3!\5!\u0319\n!\3!\3")
        buf.write("!\5!\u031d\n!\3!\5!\u0320\n!\3!\3!\3!\3!\7!\u0326\n!\f")
        buf.write("!\16!\u0329\13!\3\"\5\"\u032c\n\"\3\"\5\"\u032f\n\"\3")
        buf.write("\"\3\"\3#\3#\3#\3#\3#\3#\3#\3#\3#\5#\u033c\n#\3$\3$\3")
        buf.write("%\3%\3&\3&\3\'\3\'\3(\3(\3)\3)\3*\3*\3+\3+\3,\3,\3-\3")
        buf.write("-\3.\5.\u0353\n.\3.\3.\5.\u0357\n.\3/\3/\3/\5/\u035c\n")
        buf.write("/\3\60\3\60\3\61\5\61\u0361\n\61\3\61\3\61\5\61\u0365")
        buf.write("\n\61\3\61\2\6\268<@\62\2\4\6\b\n\f\16\20\22\24\26\30")
        buf.write("\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`\2")
        buf.write("\f\3\2\32\33\4\2\23\24HH\5\2\3\3\23\24HH\4\2\5\6CC\3\2")
        buf.write("FG\3\2\66\67\3\2\64\65\3\2\62\63\3\28=\3\2)\61\2\u03ec")
        buf.write("\2b\3\2\2\2\4\u00d4\3\2\2\2\6\u00de\3\2\2\2\b\u00f9\3")
        buf.write("\2\2\2\n\u011b\3\2\2\2\f\u011d\3\2\2\2\16\u016d\3\2\2")
        buf.write("\2\20\u016f\3\2\2\2\22\u018a\3\2\2\2\24\u018d\3\2\2\2")
        buf.write("\26\u01a3\3\2\2\2\30\u01ae\3\2\2\2\32\u01d1\3\2\2\2\34")
        buf.write("\u01d3\3\2\2\2\36\u01ec\3\2\2\2 \u01ee\3\2\2\2\"\u01fc")
        buf.write("\3\2\2\2$\u0206\3\2\2\2&\u0210\3\2\2\2(\u021e\3\2\2\2")
        buf.write("*\u022f\3\2\2\2,\u0247\3\2\2\2.\u0274\3\2\2\2\60\u0279")
        buf.write("\3\2\2\2\62\u027c\3\2\2\2\64\u0297\3\2\2\2\66\u02ac\3")
        buf.write("\2\2\28\u02b5\3\2\2\2:\u02de\3\2\2\2<\u02e9\3\2\2\2>\u0310")
        buf.write("\3\2\2\2@\u031f\3\2\2\2B\u032b\3\2\2\2D\u033b\3\2\2\2")
        buf.write("F\u033d\3\2\2\2H\u033f\3\2\2\2J\u0341\3\2\2\2L\u0343\3")
        buf.write("\2\2\2N\u0345\3\2\2\2P\u0347\3\2\2\2R\u0349\3\2\2\2T\u034b")
        buf.write("\3\2\2\2V\u034d\3\2\2\2X\u034f\3\2\2\2Z\u0352\3\2\2\2")
        buf.write("\\\u0358\3\2\2\2^\u035d\3\2\2\2`\u0360\3\2\2\2bd\5\4\3")
        buf.write("\2ce\t\2\2\2dc\3\2\2\2de\3\2\2\2ef\3\2\2\2fu\7%\2\2gi")
        buf.write("\t\2\2\2hg\3\2\2\2il\3\2\2\2jh\3\2\2\2jk\3\2\2\2km\3\2")
        buf.write("\2\2lj\3\2\2\2mo\5\4\3\2np\t\2\2\2on\3\2\2\2op\3\2\2\2")
        buf.write("pq\3\2\2\2qr\7%\2\2rt\3\2\2\2sj\3\2\2\2tw\3\2\2\2us\3")
        buf.write("\2\2\2uv\3\2\2\2vy\3\2\2\2wu\3\2\2\2xz\t\2\2\2yx\3\2\2")
        buf.write("\2yz\3\2\2\2z\3\3\2\2\2{\u00d5\5\6\4\2|~\5\6\4\2}|\3\2")
        buf.write("\2\2}~\3\2\2\2~\177\3\2\2\2\177\u00d5\5\n\6\2\u0080\u0082")
        buf.write("\5\6\4\2\u0081\u0080\3\2\2\2\u0081\u0082\3\2\2\2\u0082")
        buf.write("\u0083\3\2\2\2\u0083\u00d5\5\b\5\2\u0084\u0086\5\6\4\2")
        buf.write("\u0085\u0084\3\2\2\2\u0085\u0086\3\2\2\2\u0086\u0087\3")
        buf.write("\2\2\2\u0087\u00d5\5\f\7\2\u0088\u008a\5\6\4\2\u0089\u0088")
        buf.write("\3\2\2\2\u0089\u008a\3\2\2\2\u008a\u008c\3\2\2\2\u008b")
        buf.write("\u008d\t\2\2\2\u008c\u008b\3\2\2\2\u008c\u008d\3\2\2\2")
        buf.write("\u008d\u008e\3\2\2\2\u008e\u00d5\5D#\2\u008f\u0091\5\6")
        buf.write("\4\2\u0090\u008f\3\2\2\2\u0090\u0091\3\2\2\2\u0091\u0093")
        buf.write("\3\2\2\2\u0092\u0094\t\2\2\2\u0093\u0092\3\2\2\2\u0093")
        buf.write("\u0094\3\2\2\2\u0094\u0095\3\2\2\2\u0095\u0097\5\22\n")
        buf.write("\2\u0096\u0098\t\2\2\2\u0097\u0096\3\2\2\2\u0097\u0098")
        buf.write("\3\2\2\2\u0098\u0099\3\2\2\2\u0099\u009b\7\b\2\2\u009a")
        buf.write("\u009c\t\2\2\2\u009b\u009a\3\2\2\2\u009b\u009c\3\2\2\2")
        buf.write("\u009c\u009d\3\2\2\2\u009d\u009e\7\34\2\2\u009e\u009f")
        buf.write("\5\34\17\2\u009f\u00a0\7\35\2\2\u00a0\u00d5\3\2\2\2\u00a1")
        buf.write("\u00a3\5\6\4\2\u00a2\u00a1\3\2\2\2\u00a2\u00a3\3\2\2\2")
        buf.write("\u00a3\u00a5\3\2\2\2\u00a4\u00a6\t\2\2\2\u00a5\u00a4\3")
        buf.write("\2\2\2\u00a5\u00a6\3\2\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00a9")
        buf.write("\5\22\n\2\u00a8\u00aa\t\2\2\2\u00a9\u00a8\3\2\2\2\u00a9")
        buf.write("\u00aa\3\2\2\2\u00aa\u00ab\3\2\2\2\u00ab\u00ad\7\b\2\2")
        buf.write("\u00ac\u00ae\t\2\2\2\u00ad\u00ac\3\2\2\2\u00ad\u00ae\3")
        buf.write("\2\2\2\u00ae\u00af\3\2\2\2\u00af\u00b0\7\34\2\2\u00b0")
        buf.write("\u00b1\5&\24\2\u00b1\u00b2\7\35\2\2\u00b2\u00d5\3\2\2")
        buf.write("\2\u00b3\u00b5\5\6\4\2\u00b4\u00b3\3\2\2\2\u00b4\u00b5")
        buf.write("\3\2\2\2\u00b5\u00b7\3\2\2\2\u00b6\u00b8\t\2\2\2\u00b7")
        buf.write("\u00b6\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00b9\3\2\2\2")
        buf.write("\u00b9\u00bb\5\22\n\2\u00ba\u00bc\t\2\2\2\u00bb\u00ba")
        buf.write("\3\2\2\2\u00bb\u00bc\3\2\2\2\u00bc\u00bd\3\2\2\2\u00bd")
        buf.write("\u00bf\7\b\2\2\u00be\u00c0\t\2\2\2\u00bf\u00be\3\2\2\2")
        buf.write("\u00bf\u00c0\3\2\2\2\u00c0\u00c1\3\2\2\2\u00c1\u00c2\5")
        buf.write("\62\32\2\u00c2\u00d5\3\2\2\2\u00c3\u00c5\5\6\4\2\u00c4")
        buf.write("\u00c3\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\u00c7\3\2\2\2")
        buf.write("\u00c6\u00c8\t\2\2\2\u00c7\u00c6\3\2\2\2\u00c7\u00c8\3")
        buf.write("\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\u00d2\5(\25\2\u00ca\u00cc")
        buf.write("\t\2\2\2\u00cb\u00ca\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc")
        buf.write("\u00cd\3\2\2\2\u00cd\u00cf\7\b\2\2\u00ce\u00d0\t\2\2\2")
        buf.write("\u00cf\u00ce\3\2\2\2\u00cf\u00d0\3\2\2\2\u00d0\u00d1\3")
        buf.write("\2\2\2\u00d1\u00d3\5D#\2\u00d2\u00cb\3\2\2\2\u00d2\u00d3")
        buf.write("\3\2\2\2\u00d3\u00d5\3\2\2\2\u00d4{\3\2\2\2\u00d4}\3\2")
        buf.write("\2\2\u00d4\u0081\3\2\2\2\u00d4\u0085\3\2\2\2\u00d4\u0089")
        buf.write("\3\2\2\2\u00d4\u0090\3\2\2\2\u00d4\u00a2\3\2\2\2\u00d4")
        buf.write("\u00b4\3\2\2\2\u00d4\u00c4\3\2\2\2\u00d5\5\3\2\2\2\u00d6")
        buf.write("\u00df\7\r\2\2\u00d7\u00db\7\f\2\2\u00d8\u00da\7\f\2\2")
        buf.write("\u00d9\u00d8\3\2\2\2\u00da\u00dd\3\2\2\2\u00db\u00d9\3")
        buf.write("\2\2\2\u00db\u00dc\3\2\2\2\u00dc\u00df\3\2\2\2\u00dd\u00db")
        buf.write("\3\2\2\2\u00de\u00d6\3\2\2\2\u00de\u00d7\3\2\2\2\u00df")
        buf.write("\7\3\2\2\2\u00e0\u00e1\7\16\2\2\u00e1\u00fa\5\22\n\2\u00e2")
        buf.write("\u00e3\7\16\2\2\u00e3\u00e5\5\22\n\2\u00e4\u00e6\t\2\2")
        buf.write("\2\u00e5\u00e4\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6\u00e7")
        buf.write("\3\2\2\2\u00e7\u00ec\7H\2\2\u00e8\u00e9\7\'\2\2\u00e9")
        buf.write("\u00eb\7H\2\2\u00ea\u00e8\3\2\2\2\u00eb\u00ee\3\2\2\2")
        buf.write("\u00ec\u00ea\3\2\2\2\u00ec\u00ed\3\2\2\2\u00ed\u00f7\3")
        buf.write("\2\2\2\u00ee\u00ec\3\2\2\2\u00ef\u00f1\t\2\2\2\u00f0\u00ef")
        buf.write("\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2")
        buf.write("\u00f4\7#\2\2\u00f3\u00f5\t\2\2\2\u00f4\u00f3\3\2\2\2")
        buf.write("\u00f4\u00f5\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6\u00f8\7")
        buf.write("H\2\2\u00f7\u00f0\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8\u00fa")
        buf.write("\3\2\2\2\u00f9\u00e0\3\2\2\2\u00f9\u00e2\3\2\2\2\u00fa")
        buf.write("\t\3\2\2\2\u00fb\u00fc\7\20\2\2\u00fc\u0101\7H\2\2\u00fd")
        buf.write("\u00fe\7\'\2\2\u00fe\u0100\7H\2\2\u00ff\u00fd\3\2\2\2")
        buf.write("\u0100\u0103\3\2\2\2\u0101\u00ff\3\2\2\2\u0101\u0102\3")
        buf.write("\2\2\2\u0102\u0104\3\2\2\2\u0103\u0101\3\2\2\2\u0104\u0105")
        buf.write("\7\'\2\2\u0105\u011c\7\64\2\2\u0106\u0107\7\20\2\2\u0107")
        buf.write("\u010c\7H\2\2\u0108\u0109\7\'\2\2\u0109\u010b\7H\2\2\u010a")
        buf.write("\u0108\3\2\2\2\u010b\u010e\3\2\2\2\u010c\u010a\3\2\2\2")
        buf.write("\u010c\u010d\3\2\2\2\u010d\u010f\3\2\2\2\u010e\u010c\3")
        buf.write("\2\2\2\u010f\u0110\7\'\2\2\u0110\u0119\5\22\n\2\u0111")
        buf.write("\u0113\t\2\2\2\u0112\u0111\3\2\2\2\u0112\u0113\3\2\2\2")
        buf.write("\u0113\u0114\3\2\2\2\u0114\u0116\7#\2\2\u0115\u0117\t")
        buf.write("\2\2\2\u0116\u0115\3\2\2\2\u0116\u0117\3\2\2\2\u0117\u0118")
        buf.write("\3\2\2\2\u0118\u011a\7H\2\2\u0119\u0112\3\2\2\2\u0119")
        buf.write("\u011a\3\2\2\2\u011a\u011c\3\2\2\2\u011b\u00fb\3\2\2\2")
        buf.write("\u011b\u0106\3\2\2\2\u011c\13\3\2\2\2\u011d\u011e\7\22")
        buf.write("\2\2\u011e\u011f\5\22\n\2\u011f\r\3\2\2\2\u0120\u0121")
        buf.write("\7\27\2\2\u0121\u0122\7\34\2\2\u0122\u0123\5@!\2\u0123")
        buf.write("\u0124\7\35\2\2\u0124\u016e\3\2\2\2\u0125\u0126\7\31\2")
        buf.write("\2\u0126\u0127\7\34\2\2\u0127\u0132\5\26\f\2\u0128\u012a")
        buf.write("\7\32\2\2\u0129\u0128\3\2\2\2\u0129\u012a\3\2\2\2\u012a")
        buf.write("\u012b\3\2\2\2\u012b\u012d\7&\2\2\u012c\u012e\7\32\2\2")
        buf.write("\u012d\u012c\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u012f\3")
        buf.write("\2\2\2\u012f\u0131\5\26\f\2\u0130\u0129\3\2\2\2\u0131")
        buf.write("\u0134\3\2\2\2\u0132\u0130\3\2\2\2\u0132\u0133\3\2\2\2")
        buf.write("\u0133\u0135\3\2\2\2\u0134\u0132\3\2\2\2\u0135\u0136\7")
        buf.write("\35\2\2\u0136\u016e\3\2\2\2\u0137\u0138\7\30\2\2\u0138")
        buf.write("\u0139\7\34\2\2\u0139\u0144\5\26\f\2\u013a\u013c\7\32")
        buf.write("\2\2\u013b\u013a\3\2\2\2\u013b\u013c\3\2\2\2\u013c\u013d")
        buf.write("\3\2\2\2\u013d\u013f\7&\2\2\u013e\u0140\7\32\2\2\u013f")
        buf.write("\u013e\3\2\2\2\u013f\u0140\3\2\2\2\u0140\u0141\3\2\2\2")
        buf.write("\u0141\u0143\5\26\f\2\u0142\u013b\3\2\2\2\u0143\u0146")
        buf.write("\3\2\2\2\u0144\u0142\3\2\2\2\u0144\u0145\3\2\2\2\u0145")
        buf.write("\u0147\3\2\2\2\u0146\u0144\3\2\2\2\u0147\u0148\7\35\2")
        buf.write("\2\u0148\u016e\3\2\2\2\u0149\u014a\7\25\2\2\u014a\u014b")
        buf.write("\7\34\2\2\u014b\u0156\5\26\f\2\u014c\u014e\7\32\2\2\u014d")
        buf.write("\u014c\3\2\2\2\u014d\u014e\3\2\2\2\u014e\u014f\3\2\2\2")
        buf.write("\u014f\u0151\7&\2\2\u0150\u0152\7\32\2\2\u0151\u0150\3")
        buf.write("\2\2\2\u0151\u0152\3\2\2\2\u0152\u0153\3\2\2\2\u0153\u0155")
        buf.write("\5\26\f\2\u0154\u014d\3\2\2\2\u0155\u0158\3\2\2\2\u0156")
        buf.write("\u0154\3\2\2\2\u0156\u0157\3\2\2\2\u0157\u0159\3\2\2\2")
        buf.write("\u0158\u0156\3\2\2\2\u0159\u015a\7\35\2\2\u015a\u016e")
        buf.write("\3\2\2\2\u015b\u015c\7\26\2\2\u015c\u015d\7\34\2\2\u015d")
        buf.write("\u0168\5\26\f\2\u015e\u0160\7\32\2\2\u015f\u015e\3\2\2")
        buf.write("\2\u015f\u0160\3\2\2\2\u0160\u0161\3\2\2\2\u0161\u0163")
        buf.write("\7&\2\2\u0162\u0164\7\32\2\2\u0163\u0162\3\2\2\2\u0163")
        buf.write("\u0164\3\2\2\2\u0164\u0165\3\2\2\2\u0165\u0167\5\26\f")
        buf.write("\2\u0166\u015f\3\2\2\2\u0167\u016a\3\2\2\2\u0168\u0166")
        buf.write("\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u016b\3\2\2\2\u016a")
        buf.write("\u0168\3\2\2\2\u016b\u016c\7\35\2\2\u016c\u016e\3\2\2")
        buf.write("\2\u016d\u0120\3\2\2\2\u016d\u0125\3\2\2\2\u016d\u0137")
        buf.write("\3\2\2\2\u016d\u0149\3\2\2\2\u016d\u015b\3\2\2\2\u016e")
        buf.write("\17\3\2\2\2\u016f\u017a\5\16\b\2\u0170\u0172\7\32\2\2")
        buf.write("\u0171\u0170\3\2\2\2\u0171\u0172\3\2\2\2\u0172\u0173\3")
        buf.write("\2\2\2\u0173\u0175\7&\2\2\u0174\u0176\7\32\2\2\u0175\u0174")
        buf.write("\3\2\2\2\u0175\u0176\3\2\2\2\u0176\u0177\3\2\2\2\u0177")
        buf.write("\u0179\5\16\b\2\u0178\u0171\3\2\2\2\u0179\u017c\3\2\2")
        buf.write("\2\u017a\u0178\3\2\2\2\u017a\u017b\3\2\2\2\u017b\u017e")
        buf.write("\3\2\2\2\u017c\u017a\3\2\2\2\u017d\u017f\7\32\2\2\u017e")
        buf.write("\u017d\3\2\2\2\u017e\u017f\3\2\2\2\u017f\u0180\3\2\2\2")
        buf.write("\u0180\u0181\7&\2\2\u0181\21\3\2\2\2\u0182\u0184\7H\2")
        buf.write("\2\u0183\u0185\5*\26\2\u0184\u0183\3\2\2\2\u0184\u0185")
        buf.write("\3\2\2\2\u0185\u018b\3\2\2\2\u0186\u0187\7 \2\2\u0187")
        buf.write("\u0188\5\22\n\2\u0188\u0189\7!\2\2\u0189\u018b\3\2\2\2")
        buf.write("\u018a\u0182\3\2\2\2\u018a\u0186\3\2\2\2\u018b\23\3\2")
        buf.write("\2\2\u018c\u018e\t\3\2\2\u018d\u018c\3\2\2\2\u018d\u018e")
        buf.write("\3\2\2\2\u018e\u018f\3\2\2\2\u018f\u0190\7\36\2\2\u0190")
        buf.write("\u0191\5\26\f\2\u0191\u019b\7\37\2\2\u0192\u0194\t\4\2")
        buf.write("\2\u0193\u0192\3\2\2\2\u0193\u0194\3\2\2\2\u0194\u0195")
        buf.write("\3\2\2\2\u0195\u0196\7\36\2\2\u0196\u0197\5\26\f\2\u0197")
        buf.write("\u0198\7\37\2\2\u0198\u019a\3\2\2\2\u0199\u0193\3\2\2")
        buf.write("\2\u019a\u019d\3\2\2\2\u019b\u0199\3\2\2\2\u019b\u019c")
        buf.write("\3\2\2\2\u019c\25\3\2\2\2\u019d\u019b\3\2\2\2\u019e\u019f")
        buf.write("\b\f\1\2\u019f\u01a4\7H\2\2\u01a0\u01a4\7\23\2\2\u01a1")
        buf.write("\u01a4\7\24\2\2\u01a2\u01a4\5\24\13\2\u01a3\u019e\3\2")
        buf.write("\2\2\u01a3\u01a0\3\2\2\2\u01a3\u01a1\3\2\2\2\u01a3\u01a2")
        buf.write("\3\2\2\2\u01a4\u01aa\3\2\2\2\u01a5\u01a6\f\4\2\2\u01a6")
        buf.write("\u01a7\7\'\2\2\u01a7\u01a9\5\26\f\5\u01a8\u01a5\3\2\2")
        buf.write("\2\u01a9\u01ac\3\2\2\2\u01aa\u01a8\3\2\2\2\u01aa\u01ab")
        buf.write("\3\2\2\2\u01ab\27\3\2\2\2\u01ac\u01aa\3\2\2\2\u01ad\u01af")
        buf.write("\t\2\2\2\u01ae\u01ad\3\2\2\2\u01ae\u01af\3\2\2\2\u01af")
        buf.write("\u01b0\3\2\2\2\u01b0\u01b2\7$\2\2\u01b1\u01b3\t\2\2\2")
        buf.write("\u01b2\u01b1\3\2\2\2\u01b2\u01b3\3\2\2\2\u01b3\u01b4\3")
        buf.write("\2\2\2\u01b4\u01b6\7\24\2\2\u01b5\u01b7\7\32\2\2\u01b6")
        buf.write("\u01b5\3\2\2\2\u01b6\u01b7\3\2\2\2\u01b7\u01c2\3\2\2\2")
        buf.write("\u01b8\u01ba\7\34\2\2\u01b9\u01bb\7\32\2\2\u01ba\u01b9")
        buf.write("\3\2\2\2\u01ba\u01bb\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc")
        buf.write("\u01be\5.\30\2\u01bd\u01bf\7\32\2\2\u01be\u01bd\3\2\2")
        buf.write("\2\u01be\u01bf\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0\u01c1")
        buf.write("\7\35\2\2\u01c1\u01c3\3\2\2\2\u01c2\u01b8\3\2\2\2\u01c2")
        buf.write("\u01c3\3\2\2\2\u01c3\31\3\2\2\2\u01c4\u01c6\5\26\f\2\u01c5")
        buf.write("\u01c7\t\2\2\2\u01c6\u01c5\3\2\2\2\u01c6\u01c7\3\2\2\2")
        buf.write("\u01c7\u01c8\3\2\2\2\u01c8\u01ca\7$\2\2\u01c9\u01cb\t")
        buf.write("\2\2\2\u01ca\u01c9\3\2\2\2\u01ca\u01cb\3\2\2\2\u01cb\u01cc")
        buf.write("\3\2\2\2\u01cc\u01ce\5\22\n\2\u01cd\u01cf\5\30\r\2\u01ce")
        buf.write("\u01cd\3\2\2\2\u01ce\u01cf\3\2\2\2\u01cf\u01d2\3\2\2\2")
        buf.write("\u01d0\u01d2\5\"\22\2\u01d1\u01c4\3\2\2\2\u01d1\u01d0")
        buf.write("\3\2\2\2\u01d2\33\3\2\2\2\u01d3\u01de\5\32\16\2\u01d4")
        buf.write("\u01d6\t\2\2\2\u01d5\u01d4\3\2\2\2\u01d5\u01d6\3\2\2\2")
        buf.write("\u01d6\u01d7\3\2\2\2\u01d7\u01d9\7&\2\2\u01d8\u01da\t")
        buf.write("\2\2\2\u01d9\u01d8\3\2\2\2\u01d9\u01da\3\2\2\2\u01da\u01db")
        buf.write("\3\2\2\2\u01db\u01dd\5\32\16\2\u01dc\u01d5\3\2\2\2\u01dd")
        buf.write("\u01e0\3\2\2\2\u01de\u01dc\3\2\2\2\u01de\u01df\3\2\2\2")
        buf.write("\u01df\35\3\2\2\2\u01e0\u01de\3\2\2\2\u01e1\u01ed\5<\37")
        buf.write("\2\u01e2\u01e4\5\26\f\2\u01e3\u01e5\t\2\2\2\u01e4\u01e3")
        buf.write("\3\2\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e6\3\2\2\2\u01e6")
        buf.write("\u01e8\7#\2\2\u01e7\u01e9\t\2\2\2\u01e8\u01e7\3\2\2\2")
        buf.write("\u01e8\u01e9\3\2\2\2\u01e9\u01ea\3\2\2\2\u01ea\u01eb\5")
        buf.write("<\37\2\u01eb\u01ed\3\2\2\2\u01ec\u01e1\3\2\2\2\u01ec\u01e2")
        buf.write("\3\2\2\2\u01ed\37\3\2\2\2\u01ee\u01f9\5\36\20\2\u01ef")
        buf.write("\u01f1\t\2\2\2\u01f0\u01ef\3\2\2\2\u01f0\u01f1\3\2\2\2")
        buf.write("\u01f1\u01f2\3\2\2\2\u01f2\u01f4\7&\2\2\u01f3\u01f5\t")
        buf.write("\2\2\2\u01f4\u01f3\3\2\2\2\u01f4\u01f5\3\2\2\2\u01f5\u01f6")
        buf.write("\3\2\2\2\u01f6\u01f8\5\36\20\2\u01f7\u01f0\3\2\2\2\u01f8")
        buf.write("\u01fb\3\2\2\2\u01f9\u01f7\3\2\2\2\u01f9\u01fa\3\2\2\2")
        buf.write("\u01fa!\3\2\2\2\u01fb\u01f9\3\2\2\2\u01fc\u01fe\5\22\n")
        buf.write("\2\u01fd\u01ff\t\2\2\2\u01fe\u01fd\3\2\2\2\u01fe\u01ff")
        buf.write("\3\2\2\2\u01ff\u0204\3\2\2\2\u0200\u0201\7\36\2\2\u0201")
        buf.write("\u0202\5 \21\2\u0202\u0203\7\37\2\2\u0203\u0205\3\2\2")
        buf.write("\2\u0204\u0200\3\2\2\2\u0204\u0205\3\2\2\2\u0205#\3\2")
        buf.write("\2\2\u0206\u0208\5\26\f\2\u0207\u0209\t\2\2\2\u0208\u0207")
        buf.write("\3\2\2\2\u0208\u0209\3\2\2\2\u0209\u020a\3\2\2\2\u020a")
        buf.write("\u020c\7\4\2\2\u020b\u020d\t\2\2\2\u020c\u020b\3\2\2\2")
        buf.write("\u020c\u020d\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u020f\5")
        buf.write("\26\f\2\u020f%\3\2\2\2\u0210\u021b\5$\23\2\u0211\u0213")
        buf.write("\t\2\2\2\u0212\u0211\3\2\2\2\u0212\u0213\3\2\2\2\u0213")
        buf.write("\u0214\3\2\2\2\u0214\u0216\7&\2\2\u0215\u0217\t\2\2\2")
        buf.write("\u0216\u0215\3\2\2\2\u0216\u0217\3\2\2\2\u0217\u0218\3")
        buf.write("\2\2\2\u0218\u021a\5$\23\2\u0219\u0212\3\2\2\2\u021a\u021d")
        buf.write("\3\2\2\2\u021b\u0219\3\2\2\2\u021b\u021c\3\2\2\2\u021c")
        buf.write("\'\3\2\2\2\u021d\u021b\3\2\2\2\u021e\u0223\5\22\n\2\u021f")
        buf.write("\u0220\7\34\2\2\u0220\u0221\5\34\17\2\u0221\u0222\7\35")
        buf.write("\2\2\u0222\u0224\3\2\2\2\u0223\u021f\3\2\2\2\u0223\u0224")
        buf.write("\3\2\2\2\u0224\u022d\3\2\2\2\u0225\u0227\t\2\2\2\u0226")
        buf.write("\u0225\3\2\2\2\u0226\u0227\3\2\2\2\u0227\u0228\3\2\2\2")
        buf.write("\u0228\u022a\7$\2\2\u0229\u022b\t\2\2\2\u022a\u0229\3")
        buf.write("\2\2\2\u022a\u022b\3\2\2\2\u022b\u022c\3\2\2\2\u022c\u022e")
        buf.write("\5\22\n\2\u022d\u0226\3\2\2\2\u022d\u022e\3\2\2\2\u022e")
        buf.write(")\3\2\2\2\u022f\u0230\t\5\2\2\u0230+\3\2\2\2\u0231\u0233")
        buf.write("\7\7\2\2\u0232\u0234\5\26\f\2\u0233\u0232\3\2\2\2\u0233")
        buf.write("\u0234\3\2\2\2\u0234\u0248\3\2\2\2\u0235\u0236\7\7\2\2")
        buf.write("\u0236\u0237\7\34\2\2\u0237\u0242\5\26\f\2\u0238\u023a")
        buf.write("\7\32\2\2\u0239\u0238\3\2\2\2\u0239\u023a\3\2\2\2\u023a")
        buf.write("\u023b\3\2\2\2\u023b\u023d\7&\2\2\u023c\u023e\7\32\2\2")
        buf.write("\u023d\u023c\3\2\2\2\u023d\u023e\3\2\2\2\u023e\u023f\3")
        buf.write("\2\2\2\u023f\u0241\5\26\f\2\u0240\u0239\3\2\2\2\u0241")
        buf.write("\u0244\3\2\2\2\u0242\u0240\3\2\2\2\u0242\u0243\3\2\2\2")
        buf.write("\u0243\u0245\3\2\2\2\u0244\u0242\3\2\2\2\u0245\u0246\7")
        buf.write("\35\2\2\u0246\u0248\3\2\2\2\u0247\u0231\3\2\2\2\u0247")
        buf.write("\u0235\3\2\2\2\u0248-\3\2\2\2\u0249\u0275\5F$\2\u024a")
        buf.write("\u0275\5H%\2\u024b\u0275\5J&\2\u024c\u0275\5L\'\2\u024d")
        buf.write("\u0275\5N(\2\u024e\u0275\5P)\2\u024f\u0275\5R*\2\u0250")
        buf.write("\u0275\5T+\2\u0251\u0275\5V,\2\u0252\u0253\7\34\2\2\u0253")
        buf.write("\u025e\5.\30\2\u0254\u0256\7\32\2\2\u0255\u0254\3\2\2")
        buf.write("\2\u0255\u0256\3\2\2\2\u0256\u0257\3\2\2\2\u0257\u0259")
        buf.write("\7&\2\2\u0258\u025a\7\32\2\2\u0259\u0258\3\2\2\2\u0259")
        buf.write("\u025a\3\2\2\2\u025a\u025b\3\2\2\2\u025b\u025d\5.\30\2")
        buf.write("\u025c\u0255\3\2\2\2\u025d\u0260\3\2\2\2\u025e\u025c\3")
        buf.write("\2\2\2\u025e\u025f\3\2\2\2\u025f\u0261\3\2\2\2\u0260\u025e")
        buf.write("\3\2\2\2\u0261\u0262\7\35\2\2\u0262\u0275\3\2\2\2\u0263")
        buf.write("\u0264\7 \2\2\u0264\u026f\5.\30\2\u0265\u0267\7\32\2\2")
        buf.write("\u0266\u0265\3\2\2\2\u0266\u0267\3\2\2\2\u0267\u0268\3")
        buf.write("\2\2\2\u0268\u026a\7&\2\2\u0269\u026b\7\32\2\2\u026a\u0269")
        buf.write("\3\2\2\2\u026a\u026b\3\2\2\2\u026b\u026c\3\2\2\2\u026c")
        buf.write("\u026e\5.\30\2\u026d\u0266\3\2\2\2\u026e\u0271\3\2\2\2")
        buf.write("\u026f\u026d\3\2\2\2\u026f\u0270\3\2\2\2\u0270\u0272\3")
        buf.write("\2\2\2\u0271\u026f\3\2\2\2\u0272\u0273\7!\2\2\u0273\u0275")
        buf.write("\3\2\2\2\u0274\u0249\3\2\2\2\u0274\u024a\3\2\2\2\u0274")
        buf.write("\u024b\3\2\2\2\u0274\u024c\3\2\2\2\u0274\u024d\3\2\2\2")
        buf.write("\u0274\u024e\3\2\2\2\u0274\u024f\3\2\2\2\u0274\u0250\3")
        buf.write("\2\2\2\u0274\u0251\3\2\2\2\u0274\u0252\3\2\2\2\u0274\u0263")
        buf.write("\3\2\2\2\u0275/\3\2\2\2\u0276\u0278\n\6\2\2\u0277\u0276")
        buf.write("\3\2\2\2\u0278\u027b\3\2\2\2\u0279\u0277\3\2\2\2\u0279")
        buf.write("\u027a\3\2\2\2\u027a\61\3\2\2\2\u027b\u0279\3\2\2\2\u027c")
        buf.write("\u027d\7F\2\2\u027d\u027e\5\60\31\2\u027e\u027f\7G\2\2")
        buf.write("\u027f\63\3\2\2\2\u0280\u0298\5<\37\2\u0281\u0298\5,\27")
        buf.write("\2\u0282\u0283\5\26\f\2\u0283\u0284\5,\27\2\u0284\u0298")
        buf.write("\3\2\2\2\u0285\u0287\5\26\f\2\u0286\u0288\t\2\2\2\u0287")
        buf.write("\u0286\3\2\2\2\u0287\u0288\3\2\2\2\u0288\u0289\3\2\2\2")
        buf.write("\u0289\u028b\7#\2\2\u028a\u028c\t\2\2\2\u028b\u028a\3")
        buf.write("\2\2\2\u028b\u028c\3\2\2\2\u028c\u028d\3\2\2\2\u028d\u028f")
        buf.write("\5<\37\2\u028e\u0290\5,\27\2\u028f\u028e\3\2\2\2\u028f")
        buf.write("\u0290\3\2\2\2\u0290\u0298\3\2\2\2\u0291\u0292\5\26\f")
        buf.write("\2\u0292\u0293\5`\61\2\u0293\u0295\5<\37\2\u0294\u0296")
        buf.write("\5,\27\2\u0295\u0294\3\2\2\2\u0295\u0296\3\2\2\2\u0296")
        buf.write("\u0298\3\2\2\2\u0297\u0280\3\2\2\2\u0297\u0281\3\2\2\2")
        buf.write("\u0297\u0282\3\2\2\2\u0297\u0285\3\2\2\2\u0297\u0291\3")
        buf.write("\2\2\2\u0298\65\3\2\2\2\u0299\u029a\7\34\2\2\u029a\u02ad")
        buf.write("\7\35\2\2\u029b\u029c\7\34\2\2\u029c\u02a7\5\64\33\2\u029d")
        buf.write("\u029f\t\2\2\2\u029e\u029d\3\2\2\2\u029e\u029f\3\2\2\2")
        buf.write("\u029f\u02a0\3\2\2\2\u02a0\u02a2\7&\2\2\u02a1\u02a3\t")
        buf.write("\2\2\2\u02a2\u02a1\3\2\2\2\u02a2\u02a3\3\2\2\2\u02a3\u02a4")
        buf.write("\3\2\2\2\u02a4\u02a6\5\64\33\2\u02a5\u029e\3\2\2\2\u02a6")
        buf.write("\u02a9\3\2\2\2\u02a7\u02a5\3\2\2\2\u02a7\u02a8\3\2\2\2")
        buf.write("\u02a8\u02aa\3\2\2\2\u02a9\u02a7\3\2\2\2\u02aa\u02ab\7")
        buf.write("\35\2\2\u02ab\u02ad\3\2\2\2\u02ac\u0299\3\2\2\2\u02ac")
        buf.write("\u029b\3\2\2\2\u02ad\67\3\2\2\2\u02ae\u02af\b\35\1\2\u02af")
        buf.write("\u02b6\5.\30\2\u02b0\u02b6\5\26\f\2\u02b1\u02b6\5\66\34")
        buf.write("\2\u02b2\u02b3\5\26\f\2\u02b3\u02b4\5\66\34\2\u02b4\u02b6")
        buf.write("\3\2\2\2\u02b5\u02ae\3\2\2\2\u02b5\u02b0\3\2\2\2\u02b5")
        buf.write("\u02b1\3\2\2\2\u02b5\u02b2\3\2\2\2\u02b6\u02c2\3\2\2\2")
        buf.write("\u02b7\u02b9\f\3\2\2\u02b8\u02ba\t\2\2\2\u02b9\u02b8\3")
        buf.write("\2\2\2\u02b9\u02ba\3\2\2\2\u02ba\u02bb\3\2\2\2\u02bb\u02bd")
        buf.write("\7\'\2\2\u02bc\u02be\t\2\2\2\u02bd\u02bc\3\2\2\2\u02bd")
        buf.write("\u02be\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf\u02c1\58\35\4")
        buf.write("\u02c0\u02b7\3\2\2\2\u02c1\u02c4\3\2\2\2\u02c2\u02c0\3")
        buf.write("\2\2\2\u02c2\u02c3\3\2\2\2\u02c39\3\2\2\2\u02c4\u02c2")
        buf.write("\3\2\2\2\u02c5\u02df\58\35\2\u02c6\u02c7\58\35\2\u02c7")
        buf.write("\u02c9\7 \2\2\u02c8\u02ca\5J&\2\u02c9\u02c8\3\2\2\2\u02c9")
        buf.write("\u02ca\3\2\2\2\u02ca\u02cc\3\2\2\2\u02cb\u02cd\t\2\2\2")
        buf.write("\u02cc\u02cb\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd\u02cf\3")
        buf.write("\2\2\2\u02ce\u02d0\7$\2\2\u02cf\u02ce\3\2\2\2\u02cf\u02d0")
        buf.write("\3\2\2\2\u02d0\u02d2\3\2\2\2\u02d1\u02d3\t\2\2\2\u02d2")
        buf.write("\u02d1\3\2\2\2\u02d2\u02d3\3\2\2\2\u02d3\u02d5\3\2\2\2")
        buf.write("\u02d4\u02d6\5J&\2\u02d5\u02d4\3\2\2\2\u02d5\u02d6\3\2")
        buf.write("\2\2\u02d6\u02d7\3\2\2\2\u02d7\u02d8\7!\2\2\u02d8\u02df")
        buf.write("\3\2\2\2\u02d9\u02da\58\35\2\u02da\u02db\7 \2\2\u02db")
        buf.write("\u02dc\58\35\2\u02dc\u02dd\7!\2\2\u02dd\u02df\3\2\2\2")
        buf.write("\u02de\u02c5\3\2\2\2\u02de\u02c6\3\2\2\2\u02de\u02d9\3")
        buf.write("\2\2\2\u02df;\3\2\2\2\u02e0\u02e1\b\37\1\2\u02e1\u02ea")
        buf.write("\5:\36\2\u02e2\u02ea\5\62\32\2\u02e3\u02e4\7\34\2\2\u02e4")
        buf.write("\u02e5\5<\37\2\u02e5\u02e6\7\35\2\2\u02e6\u02ea\3\2\2")
        buf.write("\2\u02e7\u02e8\7\62\2\2\u02e8\u02ea\5<\37\6\u02e9\u02e0")
        buf.write("\3\2\2\2\u02e9\u02e2\3\2\2\2\u02e9\u02e3\3\2\2\2\u02e9")
        buf.write("\u02e7\3\2\2\2\u02ea\u0308\3\2\2\2\u02eb\u02ed\f\5\2\2")
        buf.write("\u02ec\u02ee\t\2\2\2\u02ed\u02ec\3\2\2\2\u02ed\u02ee\3")
        buf.write("\2\2\2\u02ee\u02ef\3\2\2\2\u02ef\u02f1\t\7\2\2\u02f0\u02f2")
        buf.write("\t\2\2\2\u02f1\u02f0\3\2\2\2\u02f1\u02f2\3\2\2\2\u02f2")
        buf.write("\u02f3\3\2\2\2\u02f3\u0307\5<\37\6\u02f4\u02f6\f\4\2\2")
        buf.write("\u02f5\u02f7\t\2\2\2\u02f6\u02f5\3\2\2\2\u02f6\u02f7\3")
        buf.write("\2\2\2\u02f7\u02f8\3\2\2\2\u02f8\u02fa\t\b\2\2\u02f9\u02fb")
        buf.write("\t\2\2\2\u02fa\u02f9\3\2\2\2\u02fa\u02fb\3\2\2\2\u02fb")
        buf.write("\u02fc\3\2\2\2\u02fc\u0307\5<\37\5\u02fd\u02ff\f\3\2\2")
        buf.write("\u02fe\u0300\t\2\2\2\u02ff\u02fe\3\2\2\2\u02ff\u0300\3")
        buf.write("\2\2\2\u0300\u0301\3\2\2\2\u0301\u0303\t\t\2\2\u0302\u0304")
        buf.write("\t\2\2\2\u0303\u0302\3\2\2\2\u0303\u0304\3\2\2\2\u0304")
        buf.write("\u0305\3\2\2\2\u0305\u0307\5<\37\4\u0306\u02eb\3\2\2\2")
        buf.write("\u0306\u02f4\3\2\2\2\u0306\u02fd\3\2\2\2\u0307\u030a\3")
        buf.write("\2\2\2\u0308\u0306\3\2\2\2\u0308\u0309\3\2\2\2\u0309=")
        buf.write("\3\2\2\2\u030a\u0308\3\2\2\2\u030b\u0311\5<\37\2\u030c")
        buf.write("\u030d\5<\37\2\u030d\u030e\5`\61\2\u030e\u030f\5<\37\2")
        buf.write("\u030f\u0311\3\2\2\2\u0310\u030b\3\2\2\2\u0310\u030c\3")
        buf.write("\2\2\2\u0311?\3\2\2\2\u0312\u0313\b!\1\2\u0313\u0315\5")
        buf.write("> \2\u0314\u0316\7\32\2\2\u0315\u0314\3\2\2\2\u0315\u0316")
        buf.write("\3\2\2\2\u0316\u0318\3\2\2\2\u0317\u0319\5,\27\2\u0318")
        buf.write("\u0317\3\2\2\2\u0318\u0319\3\2\2\2\u0319\u0320\3\2\2\2")
        buf.write("\u031a\u031c\78\2\2\u031b\u031d\7\32\2\2\u031c\u031b\3")
        buf.write("\2\2\2\u031c\u031d\3\2\2\2\u031d\u031e\3\2\2\2\u031e\u0320")
        buf.write("\5@!\4\u031f\u0312\3\2\2\2\u031f\u031a\3\2\2\2\u0320\u0327")
        buf.write("\3\2\2\2\u0321\u0322\f\3\2\2\u0322\u0323\5Z.\2\u0323\u0324")
        buf.write("\5@!\4\u0324\u0326\3\2\2\2\u0325\u0321\3\2\2\2\u0326\u0329")
        buf.write("\3\2\2\2\u0327\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328")
        buf.write("A\3\2\2\2\u0329\u0327\3\2\2\2\u032a\u032c\5\20\t\2\u032b")
        buf.write("\u032a\3\2\2\2\u032b\u032c\3\2\2\2\u032c\u032e\3\2\2\2")
        buf.write("\u032d\u032f\t\2\2\2\u032e\u032d\3\2\2\2\u032e\u032f\3")
        buf.write("\2\2\2\u032f\u0330\3\2\2\2\u0330\u0331\5@!\2\u0331C\3")
        buf.write("\2\2\2\u0332\u033c\5B\"\2\u0333\u0334\5B\"\2\u0334\u0335")
        buf.write("\5\\/\2\u0335\u0336\5D#\2\u0336\u033c\3\2\2\2\u0337\u0338")
        buf.write("\5\20\t\2\u0338\u0339\7\33\2\2\u0339\u033a\5D#\2\u033a")
        buf.write("\u033c\3\2\2\2\u033b\u0332\3\2\2\2\u033b\u0333\3\2\2\2")
        buf.write("\u033b\u0337\3\2\2\2\u033cE\3\2\2\2\u033d\u033e\7\"\2")
        buf.write("\2\u033eG\3\2\2\2\u033f\u0340\7>\2\2\u0340I\3\2\2\2\u0341")
        buf.write("\u0342\7?\2\2\u0342K\3\2\2\2\u0343\u0344\7@\2\2\u0344")
        buf.write("M\3\2\2\2\u0345\u0346\7A\2\2\u0346O\3\2\2\2\u0347\u0348")
        buf.write("\7B\2\2\u0348Q\3\2\2\2\u0349\u034a\7C\2\2\u034aS\3\2\2")
        buf.write("\2\u034b\u034c\7D\2\2\u034cU\3\2\2\2\u034d\u034e\7E\2")
        buf.write("\2\u034eW\3\2\2\2\u034f\u0350\t\n\2\2\u0350Y\3\2\2\2\u0351")
        buf.write("\u0353\7\32\2\2\u0352\u0351\3\2\2\2\u0352\u0353\3\2\2")
        buf.write("\2\u0353\u0354\3\2\2\2\u0354\u0356\5X-\2\u0355\u0357\7")
        buf.write("\32\2\2\u0356\u0355\3\2\2\2\u0356\u0357\3\2\2\2\u0357")
        buf.write("[\3\2\2\2\u0358\u0359\7\33\2\2\u0359\u035b\5X-\2\u035a")
        buf.write("\u035c\7\32\2\2\u035b\u035a\3\2\2\2\u035b\u035c\3\2\2")
        buf.write("\2\u035c]\3\2\2\2\u035d\u035e\t\13\2\2\u035e_\3\2\2\2")
        buf.write("\u035f\u0361\t\2\2\2\u0360\u035f\3\2\2\2\u0360\u0361\3")
        buf.write("\2\2\2\u0361\u0362\3\2\2\2\u0362\u0364\5^\60\2\u0363\u0365")
        buf.write("\t\2\2\2\u0364\u0363\3\2\2\2\u0364\u0365\3\2\2\2\u0365")
        buf.write("a\3\2\2\2\u0099djouy}\u0081\u0085\u0089\u008c\u0090\u0093")
        buf.write("\u0097\u009b\u00a2\u00a5\u00a9\u00ad\u00b4\u00b7\u00bb")
        buf.write("\u00bf\u00c4\u00c7\u00cb\u00cf\u00d2\u00d4\u00db\u00de")
        buf.write("\u00e5\u00ec\u00f0\u00f4\u00f7\u00f9\u0101\u010c\u0112")
        buf.write("\u0116\u0119\u011b\u0129\u012d\u0132\u013b\u013f\u0144")
        buf.write("\u014d\u0151\u0156\u015f\u0163\u0168\u016d\u0171\u0175")
        buf.write("\u017a\u017e\u0184\u018a\u018d\u0193\u019b\u01a3\u01aa")
        buf.write("\u01ae\u01b2\u01b6\u01ba\u01be\u01c2\u01c6\u01ca\u01ce")
        buf.write("\u01d1\u01d5\u01d9\u01de\u01e4\u01e8\u01ec\u01f0\u01f4")
        buf.write("\u01f9\u01fe\u0204\u0208\u020c\u0212\u0216\u021b\u0223")
        buf.write("\u0226\u022a\u022d\u0233\u0239\u023d\u0242\u0247\u0255")
        buf.write("\u0259\u025e\u0266\u026a\u026f\u0274\u0279\u0287\u028b")
        buf.write("\u028f\u0295\u0297\u029e\u02a2\u02a7\u02ac\u02b5\u02b9")
        buf.write("\u02bd\u02c2\u02c9\u02cc\u02cf\u02d2\u02d5\u02de\u02e9")
        buf.write("\u02ed\u02f1\u02f6\u02fa\u02ff\u0303\u0306\u0308\u0310")
        buf.write("\u0315\u0318\u031c\u031f\u0327\u032b\u032e\u033b\u0352")
        buf.write("\u0356\u035b\u0360\u0364")
        return buf.getvalue()


class normParser ( Parser ):

    grammarFileName = "norm.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'_'", "'->'", "'$latest'", "'$best'", 
                     "'?'", "<INVALID>", "':='", "'|='", "'&='", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "':'", "';'", 
                     "','", "'.'", "'..'", "<INVALID>", "<INVALID>", "'=='", 
                     "'!='", "'>='", "'<='", "'>'", "'<'", "'~'", "'-'", 
                     "'+'", "'*'", "'/'", "'**'", "'%'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "IMPL", "CEQ", "OEQ", "AEQ", 
                      "SINGLELINE", "MULTILINE", "SPACED_EXPORT", "EXPORT", 
                      "SPACED_IMPORT", "IMPORT", "SPACED_COMMAND", "COMMAND", 
                      "ARGOPT", "EXIST", "NEXIST", "WITH", "FOREACH", "FORANY", 
                      "WS", "NS", "LBR", "RBR", "LCBR", "RCBR", "LSBR", 
                      "RSBR", "NONE", "AS", "COLON", "SEMICOLON", "COMMA", 
                      "DOT", "DOTDOT", "IN", "NI", "EQ", "NE", "GE", "LE", 
                      "GT", "LT", "LK", "MINUS", "PLUS", "TIMES", "DIVIDE", 
                      "EXP", "MOD", "NOT", "AND", "OR", "XOR", "IMP", "EQV", 
                      "BOOLEAN", "INTEGER", "FLOAT", "STRING", "PATTERN", 
                      "UUID", "URL", "DATETIME", "PYTHON_BLOCK", "BLOCK_END", 
                      "VARNAME" ]

    RULE_script = 0
    RULE_statement = 1
    RULE_comments = 2
    RULE_exports = 3
    RULE_imports = 4
    RULE_commands = 5
    RULE_context = 6
    RULE_contexts = 7
    RULE_typeName = 8
    RULE_unquote_variable = 9
    RULE_variable = 10
    RULE_argumentProperty = 11
    RULE_argumentDeclaration = 12
    RULE_argumentDeclarations = 13
    RULE_inheritanceArgument = 14
    RULE_inheritanceArguments = 15
    RULE_inheritance = 16
    RULE_rename = 17
    RULE_renames = 18
    RULE_typeDeclaration = 19
    RULE_version = 20
    RULE_queryProjection = 21
    RULE_constant = 22
    RULE_code = 23
    RULE_codeExpression = 24
    RULE_argumentExpression = 25
    RULE_argumentExpressions = 26
    RULE_evaluationExpression = 27
    RULE_slicedExpression = 28
    RULE_arithmeticExpression = 29
    RULE_conditionExpression = 30
    RULE_oneLineExpression = 31
    RULE_contextualOneLineExpression = 32
    RULE_multiLineExpression = 33
    RULE_none = 34
    RULE_bool_c = 35
    RULE_integer_c = 36
    RULE_float_c = 37
    RULE_string_c = 38
    RULE_pattern = 39
    RULE_uuid = 40
    RULE_url = 41
    RULE_datetime = 42
    RULE_logicalOperator = 43
    RULE_spacedLogicalOperator = 44
    RULE_newlineLogicalOperator = 45
    RULE_conditionOperator = 46
    RULE_spacedConditionOperator = 47

    ruleNames =  [ "script", "statement", "comments", "exports", "imports", 
                   "commands", "context", "contexts", "typeName", "unquote_variable", 
                   "variable", "argumentProperty", "argumentDeclaration", 
                   "argumentDeclarations", "inheritanceArgument", "inheritanceArguments", 
                   "inheritance", "rename", "renames", "typeDeclaration", 
                   "version", "queryProjection", "constant", "code", "codeExpression", 
                   "argumentExpression", "argumentExpressions", "evaluationExpression", 
                   "slicedExpression", "arithmeticExpression", "conditionExpression", 
                   "oneLineExpression", "contextualOneLineExpression", "multiLineExpression", 
                   "none", "bool_c", "integer_c", "float_c", "string_c", 
                   "pattern", "uuid", "url", "datetime", "logicalOperator", 
                   "spacedLogicalOperator", "newlineLogicalOperator", "conditionOperator", 
                   "spacedConditionOperator" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    IMPL=6
    CEQ=7
    OEQ=8
    AEQ=9
    SINGLELINE=10
    MULTILINE=11
    SPACED_EXPORT=12
    EXPORT=13
    SPACED_IMPORT=14
    IMPORT=15
    SPACED_COMMAND=16
    COMMAND=17
    ARGOPT=18
    EXIST=19
    NEXIST=20
    WITH=21
    FOREACH=22
    FORANY=23
    WS=24
    NS=25
    LBR=26
    RBR=27
    LCBR=28
    RCBR=29
    LSBR=30
    RSBR=31
    NONE=32
    AS=33
    COLON=34
    SEMICOLON=35
    COMMA=36
    DOT=37
    DOTDOT=38
    IN=39
    NI=40
    EQ=41
    NE=42
    GE=43
    LE=44
    GT=45
    LT=46
    LK=47
    MINUS=48
    PLUS=49
    TIMES=50
    DIVIDE=51
    EXP=52
    MOD=53
    NOT=54
    AND=55
    OR=56
    XOR=57
    IMP=58
    EQV=59
    BOOLEAN=60
    INTEGER=61
    FLOAT=62
    STRING=63
    PATTERN=64
    UUID=65
    URL=66
    DATETIME=67
    PYTHON_BLOCK=68
    BLOCK_END=69
    VARNAME=70

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




    class ScriptContext(ParserRuleContext):

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

        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.StatementContext)
            else:
                return self.getTypedRuleContext(normParser.StatementContext,i)


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

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

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

        def getRuleIndex(self):
            return normParser.RULE_script

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

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




    def script(self):

        localctx = normParser.ScriptContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_script)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 96
            self.statement()
            self.state = 98
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.WS or _la==normParser.NS:
                self.state = 97
                _la = self._input.LA(1)
                if not(_la==normParser.WS or _la==normParser.NS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 100
            self.match(normParser.SEMICOLON)
            self.state = 115
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 104
                    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 = 101
                            _la = self._input.LA(1)
                            if not(_la==normParser.WS or _la==normParser.NS):
                                self._errHandler.recoverInline(self)
                            else:
                                self._errHandler.reportMatch(self)
                                self.consume() 
                        self.state = 106
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,1,self._ctx)

                    self.state = 107
                    self.statement()
                    self.state = 109
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS or _la==normParser.NS:
                        self.state = 108
                        _la = self._input.LA(1)
                        if not(_la==normParser.WS or _la==normParser.NS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()


                    self.state = 111
                    self.match(normParser.SEMICOLON) 
                self.state = 117
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,3,self._ctx)

            self.state = 119
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.WS or _la==normParser.NS:
                self.state = 118
                _la = self._input.LA(1)
                if not(_la==normParser.WS or _la==normParser.NS):
                    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 StatementContext(ParserRuleContext):

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

        def comments(self):
            return self.getTypedRuleContext(normParser.CommentsContext,0)


        def imports(self):
            return self.getTypedRuleContext(normParser.ImportsContext,0)


        def exports(self):
            return self.getTypedRuleContext(normParser.ExportsContext,0)


        def commands(self):
            return self.getTypedRuleContext(normParser.CommandsContext,0)


        def multiLineExpression(self):
            return self.getTypedRuleContext(normParser.MultiLineExpressionContext,0)


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

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

        def typeName(self):
            return self.getTypedRuleContext(normParser.TypeNameContext,0)


        def IMPL(self):
            return self.getToken(normParser.IMPL, 0)

        def LBR(self):
            return self.getToken(normParser.LBR, 0)

        def argumentDeclarations(self):
            return self.getTypedRuleContext(normParser.ArgumentDeclarationsContext,0)


        def RBR(self):
            return self.getToken(normParser.RBR, 0)

        def renames(self):
            return self.getTypedRuleContext(normParser.RenamesContext,0)


        def codeExpression(self):
            return self.getTypedRuleContext(normParser.CodeExpressionContext,0)


        def typeDeclaration(self):
            return self.getTypedRuleContext(normParser.TypeDeclarationContext,0)


        def getRuleIndex(self):
            return normParser.RULE_statement

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

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




    def statement(self):

        localctx = normParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_statement)
        self._la = 0 # Token type
        try:
            self.state = 210
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 121
                self.comments()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 123
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.SINGLELINE or _la==normParser.MULTILINE:
                    self.state = 122
                    self.comments()


                self.state = 125
                self.imports()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 127
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.SINGLELINE or _la==normParser.MULTILINE:
                    self.state = 126
                    self.comments()


                self.state = 129
                self.exports()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 131
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.SINGLELINE or _la==normParser.MULTILINE:
                    self.state = 130
                    self.comments()


                self.state = 133
                self.commands()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 135
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.SINGLELINE or _la==normParser.MULTILINE:
                    self.state = 134
                    self.comments()


                self.state = 138
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
                if la_ == 1:
                    self.state = 137
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 140
                self.multiLineExpression()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 142
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.SINGLELINE or _la==normParser.MULTILINE:
                    self.state = 141
                    self.comments()


                self.state = 145
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 144
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 147
                self.typeName()
                self.state = 149
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 148
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 151
                self.match(normParser.IMPL)
                self.state = 153
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 152
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 155
                self.match(normParser.LBR)
                self.state = 156
                self.argumentDeclarations()
                self.state = 157
                self.match(normParser.RBR)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 160
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.SINGLELINE or _la==normParser.MULTILINE:
                    self.state = 159
                    self.comments()


                self.state = 163
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 162
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 165
                self.typeName()
                self.state = 167
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 166
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 169
                self.match(normParser.IMPL)
                self.state = 171
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 170
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 173
                self.match(normParser.LBR)
                self.state = 174
                self.renames()
                self.state = 175
                self.match(normParser.RBR)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 178
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.SINGLELINE or _la==normParser.MULTILINE:
                    self.state = 177
                    self.comments()


                self.state = 181
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 180
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 183
                self.typeName()
                self.state = 185
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 184
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 187
                self.match(normParser.IMPL)
                self.state = 189
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 188
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 191
                self.codeExpression()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 194
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.SINGLELINE or _la==normParser.MULTILINE:
                    self.state = 193
                    self.comments()


                self.state = 197
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 196
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 199
                self.typeDeclaration()
                self.state = 208
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,26,self._ctx)
                if la_ == 1:
                    self.state = 201
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS or _la==normParser.NS:
                        self.state = 200
                        _la = self._input.LA(1)
                        if not(_la==normParser.WS or _la==normParser.NS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()


                    self.state = 203
                    self.match(normParser.IMPL)
                    self.state = 205
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
                    if la_ == 1:
                        self.state = 204
                        _la = self._input.LA(1)
                        if not(_la==normParser.WS or _la==normParser.NS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()


                    self.state = 207
                    self.multiLineExpression()


                pass


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


    class CommentsContext(ParserRuleContext):

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

        def MULTILINE(self):
            return self.getToken(normParser.MULTILINE, 0)

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

        def getRuleIndex(self):
            return normParser.RULE_comments

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

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




    def comments(self):

        localctx = normParser.CommentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_comments)
        self._la = 0 # Token type
        try:
            self.state = 220
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [normParser.MULTILINE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 212
                self.match(normParser.MULTILINE)
                pass
            elif token in [normParser.SINGLELINE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 213
                self.match(normParser.SINGLELINE)
                self.state = 217
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==normParser.SINGLELINE:
                    self.state = 214
                    self.match(normParser.SINGLELINE)
                    self.state = 219
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                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 ExportsContext(ParserRuleContext):

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

        def SPACED_EXPORT(self):
            return self.getToken(normParser.SPACED_EXPORT, 0)

        def typeName(self):
            return self.getTypedRuleContext(normParser.TypeNameContext,0)


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

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

        def AS(self):
            return self.getToken(normParser.AS, 0)

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

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

        def getRuleIndex(self):
            return normParser.RULE_exports

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

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




    def exports(self):

        localctx = normParser.ExportsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_exports)
        self._la = 0 # Token type
        try:
            self.state = 247
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 222
                self.match(normParser.SPACED_EXPORT)
                self.state = 223
                self.typeName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 224
                self.match(normParser.SPACED_EXPORT)
                self.state = 225
                self.typeName()
                self.state = 227
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 226
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 229
                self.match(normParser.VARNAME)
                self.state = 234
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==normParser.DOT:
                    self.state = 230
                    self.match(normParser.DOT)
                    self.state = 231
                    self.match(normParser.VARNAME)
                    self.state = 236
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 245
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
                if la_ == 1:
                    self.state = 238
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS or _la==normParser.NS:
                        self.state = 237
                        _la = self._input.LA(1)
                        if not(_la==normParser.WS or _la==normParser.NS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()


                    self.state = 240
                    self.match(normParser.AS)
                    self.state = 242
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS or _la==normParser.NS:
                        self.state = 241
                        _la = self._input.LA(1)
                        if not(_la==normParser.WS or _la==normParser.NS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()


                    self.state = 244
                    self.match(normParser.VARNAME)


                pass


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


    class ImportsContext(ParserRuleContext):

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

        def SPACED_IMPORT(self):
            return self.getToken(normParser.SPACED_IMPORT, 0)

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

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

        def TIMES(self):
            return self.getToken(normParser.TIMES, 0)

        def typeName(self):
            return self.getTypedRuleContext(normParser.TypeNameContext,0)


        def AS(self):
            return self.getToken(normParser.AS, 0)

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

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

        def getRuleIndex(self):
            return normParser.RULE_imports

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

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




    def imports(self):

        localctx = normParser.ImportsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_imports)
        self._la = 0 # Token type
        try:
            self.state = 281
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 249
                self.match(normParser.SPACED_IMPORT)
                self.state = 250
                self.match(normParser.VARNAME)
                self.state = 255
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,36,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 251
                        self.match(normParser.DOT)
                        self.state = 252
                        self.match(normParser.VARNAME) 
                    self.state = 257
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,36,self._ctx)

                self.state = 258
                self.match(normParser.DOT)
                self.state = 259
                self.match(normParser.TIMES)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 260
                self.match(normParser.SPACED_IMPORT)
                self.state = 261
                self.match(normParser.VARNAME)
                self.state = 266
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,37,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 262
                        self.match(normParser.DOT)
                        self.state = 263
                        self.match(normParser.VARNAME) 
                    self.state = 268
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,37,self._ctx)

                self.state = 269
                self.match(normParser.DOT)
                self.state = 270
                self.typeName()
                self.state = 279
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
                if la_ == 1:
                    self.state = 272
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS or _la==normParser.NS:
                        self.state = 271
                        _la = self._input.LA(1)
                        if not(_la==normParser.WS or _la==normParser.NS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()


                    self.state = 274
                    self.match(normParser.AS)
                    self.state = 276
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS or _la==normParser.NS:
                        self.state = 275
                        _la = self._input.LA(1)
                        if not(_la==normParser.WS or _la==normParser.NS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()


                    self.state = 278
                    self.match(normParser.VARNAME)


                pass


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


    class CommandsContext(ParserRuleContext):

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

        def SPACED_COMMAND(self):
            return self.getToken(normParser.SPACED_COMMAND, 0)

        def typeName(self):
            return self.getTypedRuleContext(normParser.TypeNameContext,0)


        def getRuleIndex(self):
            return normParser.RULE_commands

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

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




    def commands(self):

        localctx = normParser.CommandsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_commands)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 283
            self.match(normParser.SPACED_COMMAND)
            self.state = 284
            self.typeName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ContextContext(ParserRuleContext):

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

        def WITH(self):
            return self.getToken(normParser.WITH, 0)

        def LBR(self):
            return self.getToken(normParser.LBR, 0)

        def oneLineExpression(self):
            return self.getTypedRuleContext(normParser.OneLineExpressionContext,0)


        def RBR(self):
            return self.getToken(normParser.RBR, 0)

        def FORANY(self):
            return self.getToken(normParser.FORANY, 0)

        def variable(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.VariableContext)
            else:
                return self.getTypedRuleContext(normParser.VariableContext,i)


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

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

        def FOREACH(self):
            return self.getToken(normParser.FOREACH, 0)

        def EXIST(self):
            return self.getToken(normParser.EXIST, 0)

        def NEXIST(self):
            return self.getToken(normParser.NEXIST, 0)

        def getRuleIndex(self):
            return normParser.RULE_context

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

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




    def context(self):

        localctx = normParser.ContextContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_context)
        self._la = 0 # Token type
        try:
            self.state = 363
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [normParser.WITH]:
                self.enterOuterAlt(localctx, 1)
                self.state = 286
                self.match(normParser.WITH)
                self.state = 287
                self.match(normParser.LBR)
                self.state = 288
                self.oneLineExpression(0)
                self.state = 289
                self.match(normParser.RBR)
                pass
            elif token in [normParser.FORANY]:
                self.enterOuterAlt(localctx, 2)
                self.state = 291
                self.match(normParser.FORANY)
                self.state = 292
                self.match(normParser.LBR)

                self.state = 293
                self.variable(0)
                self.state = 304
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==normParser.WS or _la==normParser.COMMA:
                    self.state = 295
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 294
                        self.match(normParser.WS)


                    self.state = 297
                    self.match(normParser.COMMA)
                    self.state = 299
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 298
                        self.match(normParser.WS)


                    self.state = 301
                    self.variable(0)
                    self.state = 306
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 307
                self.match(normParser.RBR)
                pass
            elif token in [normParser.FOREACH]:
                self.enterOuterAlt(localctx, 3)
                self.state = 309
                self.match(normParser.FOREACH)
                self.state = 310
                self.match(normParser.LBR)

                self.state = 311
                self.variable(0)
                self.state = 322
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==normParser.WS or _la==normParser.COMMA:
                    self.state = 313
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 312
                        self.match(normParser.WS)


                    self.state = 315
                    self.match(normParser.COMMA)
                    self.state = 317
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 316
                        self.match(normParser.WS)


                    self.state = 319
                    self.variable(0)
                    self.state = 324
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 325
                self.match(normParser.RBR)
                pass
            elif token in [normParser.EXIST]:
                self.enterOuterAlt(localctx, 4)
                self.state = 327
                self.match(normParser.EXIST)
                self.state = 328
                self.match(normParser.LBR)

                self.state = 329
                self.variable(0)
                self.state = 340
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==normParser.WS or _la==normParser.COMMA:
                    self.state = 331
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 330
                        self.match(normParser.WS)


                    self.state = 333
                    self.match(normParser.COMMA)
                    self.state = 335
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 334
                        self.match(normParser.WS)


                    self.state = 337
                    self.variable(0)
                    self.state = 342
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 343
                self.match(normParser.RBR)
                pass
            elif token in [normParser.NEXIST]:
                self.enterOuterAlt(localctx, 5)
                self.state = 345
                self.match(normParser.NEXIST)
                self.state = 346
                self.match(normParser.LBR)

                self.state = 347
                self.variable(0)
                self.state = 358
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==normParser.WS or _la==normParser.COMMA:
                    self.state = 349
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 348
                        self.match(normParser.WS)


                    self.state = 351
                    self.match(normParser.COMMA)
                    self.state = 353
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 352
                        self.match(normParser.WS)


                    self.state = 355
                    self.variable(0)
                    self.state = 360
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 361
                self.match(normParser.RBR)
                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 ContextsContext(ParserRuleContext):

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

        def context(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.ContextContext)
            else:
                return self.getTypedRuleContext(normParser.ContextContext,i)


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

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

        def getRuleIndex(self):
            return normParser.RULE_contexts

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

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




    def contexts(self):

        localctx = normParser.ContextsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_contexts)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 365
            self.context()
            self.state = 376
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,57,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 367
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 366
                        self.match(normParser.WS)


                    self.state = 369
                    self.match(normParser.COMMA)
                    self.state = 371
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 370
                        self.match(normParser.WS)


                    self.state = 373
                    self.context() 
                self.state = 378
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,57,self._ctx)

            self.state = 380
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.WS:
                self.state = 379
                self.match(normParser.WS)


            self.state = 382
            self.match(normParser.COMMA)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeNameContext(ParserRuleContext):

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

        def VARNAME(self):
            return self.getToken(normParser.VARNAME, 0)

        def version(self):
            return self.getTypedRuleContext(normParser.VersionContext,0)


        def LSBR(self):
            return self.getToken(normParser.LSBR, 0)

        def typeName(self):
            return self.getTypedRuleContext(normParser.TypeNameContext,0)


        def RSBR(self):
            return self.getToken(normParser.RSBR, 0)

        def getRuleIndex(self):
            return normParser.RULE_typeName

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

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




    def typeName(self):

        localctx = normParser.TypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_typeName)
        self._la = 0 # Token type
        try:
            self.state = 392
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [normParser.VARNAME]:
                self.enterOuterAlt(localctx, 1)
                self.state = 384
                self.match(normParser.VARNAME)
                self.state = 386
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 3)) & ~0x3f) == 0 and ((1 << (_la - 3)) & ((1 << (normParser.T__2 - 3)) | (1 << (normParser.T__3 - 3)) | (1 << (normParser.UUID - 3)))) != 0):
                    self.state = 385
                    self.version()


                pass
            elif token in [normParser.LSBR]:
                self.enterOuterAlt(localctx, 2)
                self.state = 388
                self.match(normParser.LSBR)
                self.state = 389
                self.typeName()
                self.state = 390
                self.match(normParser.RSBR)
                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 Unquote_variableContext(ParserRuleContext):

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

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

        def variable(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.VariableContext)
            else:
                return self.getTypedRuleContext(normParser.VariableContext,i)


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

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

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

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

        def getRuleIndex(self):
            return normParser.RULE_unquote_variable

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

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




    def unquote_variable(self):

        localctx = normParser.Unquote_variableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_unquote_variable)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 395
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 17)) & ~0x3f) == 0 and ((1 << (_la - 17)) & ((1 << (normParser.COMMAND - 17)) | (1 << (normParser.ARGOPT - 17)) | (1 << (normParser.VARNAME - 17)))) != 0):
                self.state = 394
                _la = self._input.LA(1)
                if not(((((_la - 17)) & ~0x3f) == 0 and ((1 << (_la - 17)) & ((1 << (normParser.COMMAND - 17)) | (1 << (normParser.ARGOPT - 17)) | (1 << (normParser.VARNAME - 17)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 397
            self.match(normParser.LCBR)
            self.state = 398
            self.variable(0)
            self.state = 399
            self.match(normParser.RCBR)
            self.state = 409
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,63,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 401
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << normParser.T__0) | (1 << normParser.COMMAND) | (1 << normParser.ARGOPT))) != 0) or _la==normParser.VARNAME:
                        self.state = 400
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << normParser.T__0) | (1 << normParser.COMMAND) | (1 << normParser.ARGOPT))) != 0) or _la==normParser.VARNAME):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()


                    self.state = 403
                    self.match(normParser.LCBR)
                    self.state = 404
                    self.variable(0)
                    self.state = 405
                    self.match(normParser.RCBR) 
                self.state = 411
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,63,self._ctx)

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


    class VariableContext(ParserRuleContext):

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

        def VARNAME(self):
            return self.getToken(normParser.VARNAME, 0)

        def COMMAND(self):
            return self.getToken(normParser.COMMAND, 0)

        def ARGOPT(self):
            return self.getToken(normParser.ARGOPT, 0)

        def unquote_variable(self):
            return self.getTypedRuleContext(normParser.Unquote_variableContext,0)


        def variable(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.VariableContext)
            else:
                return self.getTypedRuleContext(normParser.VariableContext,i)


        def DOT(self):
            return self.getToken(normParser.DOT, 0)

        def getRuleIndex(self):
            return normParser.RULE_variable

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

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



    def variable(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = normParser.VariableContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 20
        self.enterRecursionRule(localctx, 20, self.RULE_variable, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 417
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,64,self._ctx)
            if la_ == 1:
                self.state = 413
                self.match(normParser.VARNAME)
                pass

            elif la_ == 2:
                self.state = 414
                self.match(normParser.COMMAND)
                pass

            elif la_ == 3:
                self.state = 415
                self.match(normParser.ARGOPT)
                pass

            elif la_ == 4:
                self.state = 416
                self.unquote_variable()
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 424
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,65,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = normParser.VariableContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_variable)
                    self.state = 419
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 420
                    self.match(normParser.DOT)
                    self.state = 421
                    self.variable(3) 
                self.state = 426
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,65,self._ctx)

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


    class ArgumentPropertyContext(ParserRuleContext):

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

        def COLON(self):
            return self.getToken(normParser.COLON, 0)

        def ARGOPT(self):
            return self.getToken(normParser.ARGOPT, 0)

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

        def LBR(self):
            return self.getToken(normParser.LBR, 0)

        def constant(self):
            return self.getTypedRuleContext(normParser.ConstantContext,0)


        def RBR(self):
            return self.getToken(normParser.RBR, 0)

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

        def getRuleIndex(self):
            return normParser.RULE_argumentProperty

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

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




    def argumentProperty(self):

        localctx = normParser.ArgumentPropertyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_argumentProperty)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 428
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.WS or _la==normParser.NS:
                self.state = 427
                _la = self._input.LA(1)
                if not(_la==normParser.WS or _la==normParser.NS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 430
            self.match(normParser.COLON)
            self.state = 432
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.WS or _la==normParser.NS:
                self.state = 431
                _la = self._input.LA(1)
                if not(_la==normParser.WS or _la==normParser.NS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 434
            self.match(normParser.ARGOPT)
            self.state = 436
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
            if la_ == 1:
                self.state = 435
                self.match(normParser.WS)


            self.state = 448
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.LBR:
                self.state = 438
                self.match(normParser.LBR)
                self.state = 440
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS:
                    self.state = 439
                    self.match(normParser.WS)


                self.state = 442
                self.constant()
                self.state = 444
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS:
                    self.state = 443
                    self.match(normParser.WS)


                self.state = 446
                self.match(normParser.RBR)


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


    class ArgumentDeclarationContext(ParserRuleContext):

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

        def variable(self):
            return self.getTypedRuleContext(normParser.VariableContext,0)


        def COLON(self):
            return self.getToken(normParser.COLON, 0)

        def typeName(self):
            return self.getTypedRuleContext(normParser.TypeNameContext,0)


        def argumentProperty(self):
            return self.getTypedRuleContext(normParser.ArgumentPropertyContext,0)


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

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

        def inheritance(self):
            return self.getTypedRuleContext(normParser.InheritanceContext,0)


        def getRuleIndex(self):
            return normParser.RULE_argumentDeclaration

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

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




    def argumentDeclaration(self):

        localctx = normParser.ArgumentDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_argumentDeclaration)
        self._la = 0 # Token type
        try:
            self.state = 463
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 450
                self.variable(0)
                self.state = 452
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 451
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 454
                self.match(normParser.COLON)
                self.state = 456
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 455
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 458
                self.typeName()
                self.state = 460
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
                if la_ == 1:
                    self.state = 459
                    self.argumentProperty()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 462
                self.inheritance()
                pass


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


    class ArgumentDeclarationsContext(ParserRuleContext):

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

        def argumentDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.ArgumentDeclarationContext)
            else:
                return self.getTypedRuleContext(normParser.ArgumentDeclarationContext,i)


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

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

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

        def getRuleIndex(self):
            return normParser.RULE_argumentDeclarations

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

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




    def argumentDeclarations(self):

        localctx = normParser.ArgumentDeclarationsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_argumentDeclarations)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 465
            self.argumentDeclaration()
            self.state = 476
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << normParser.WS) | (1 << normParser.NS) | (1 << normParser.COMMA))) != 0):
                self.state = 467
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 466
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 469
                self.match(normParser.COMMA)
                self.state = 471
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 470
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 473
                self.argumentDeclaration()
                self.state = 478
                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 InheritanceArgumentContext(ParserRuleContext):

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

        def arithmeticExpression(self):
            return self.getTypedRuleContext(normParser.ArithmeticExpressionContext,0)


        def variable(self):
            return self.getTypedRuleContext(normParser.VariableContext,0)


        def AS(self):
            return self.getToken(normParser.AS, 0)

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

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

        def getRuleIndex(self):
            return normParser.RULE_inheritanceArgument

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

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




    def inheritanceArgument(self):

        localctx = normParser.InheritanceArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_inheritanceArgument)
        self._la = 0 # Token type
        try:
            self.state = 490
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 479
                self.arithmeticExpression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 480
                self.variable(0)
                self.state = 482
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 481
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 484
                self.match(normParser.AS)
                self.state = 486
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 485
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 488
                self.arithmeticExpression(0)
                pass


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


    class InheritanceArgumentsContext(ParserRuleContext):

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

        def inheritanceArgument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.InheritanceArgumentContext)
            else:
                return self.getTypedRuleContext(normParser.InheritanceArgumentContext,i)


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

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

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

        def getRuleIndex(self):
            return normParser.RULE_inheritanceArguments

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

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




    def inheritanceArguments(self):

        localctx = normParser.InheritanceArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_inheritanceArguments)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 492
            self.inheritanceArgument()
            self.state = 503
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << normParser.WS) | (1 << normParser.NS) | (1 << normParser.COMMA))) != 0):
                self.state = 494
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 493
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 496
                self.match(normParser.COMMA)
                self.state = 498
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 497
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 500
                self.inheritanceArgument()
                self.state = 505
                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 InheritanceContext(ParserRuleContext):

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

        def typeName(self):
            return self.getTypedRuleContext(normParser.TypeNameContext,0)


        def LCBR(self):
            return self.getToken(normParser.LCBR, 0)

        def inheritanceArguments(self):
            return self.getTypedRuleContext(normParser.InheritanceArgumentsContext,0)


        def RCBR(self):
            return self.getToken(normParser.RCBR, 0)

        def WS(self):
            return self.getToken(normParser.WS, 0)

        def NS(self):
            return self.getToken(normParser.NS, 0)

        def getRuleIndex(self):
            return normParser.RULE_inheritance

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

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




    def inheritance(self):

        localctx = normParser.InheritanceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_inheritance)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 506
            self.typeName()
            self.state = 508
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
            if la_ == 1:
                self.state = 507
                _la = self._input.LA(1)
                if not(_la==normParser.WS or _la==normParser.NS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 514
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.LCBR:
                self.state = 510
                self.match(normParser.LCBR)
                self.state = 511
                self.inheritanceArguments()
                self.state = 512
                self.match(normParser.RCBR)


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


    class RenameContext(ParserRuleContext):

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

        def variable(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.VariableContext)
            else:
                return self.getTypedRuleContext(normParser.VariableContext,i)


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

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

        def getRuleIndex(self):
            return normParser.RULE_rename

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

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




    def rename(self):

        localctx = normParser.RenameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_rename)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 516
            self.variable(0)
            self.state = 518
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.WS or _la==normParser.NS:
                self.state = 517
                _la = self._input.LA(1)
                if not(_la==normParser.WS or _la==normParser.NS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 520
            self.match(normParser.T__1)
            self.state = 522
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.WS or _la==normParser.NS:
                self.state = 521
                _la = self._input.LA(1)
                if not(_la==normParser.WS or _la==normParser.NS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


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


    class RenamesContext(ParserRuleContext):

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

        def rename(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.RenameContext)
            else:
                return self.getTypedRuleContext(normParser.RenameContext,i)


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

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

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

        def getRuleIndex(self):
            return normParser.RULE_renames

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

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




    def renames(self):

        localctx = normParser.RenamesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_renames)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 526
            self.rename()
            self.state = 537
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << normParser.WS) | (1 << normParser.NS) | (1 << normParser.COMMA))) != 0):
                self.state = 528
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 527
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 530
                self.match(normParser.COMMA)
                self.state = 532
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 531
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 534
                self.rename()
                self.state = 539
                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 TypeDeclarationContext(ParserRuleContext):

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

        def typeName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.TypeNameContext)
            else:
                return self.getTypedRuleContext(normParser.TypeNameContext,i)


        def LBR(self):
            return self.getToken(normParser.LBR, 0)

        def argumentDeclarations(self):
            return self.getTypedRuleContext(normParser.ArgumentDeclarationsContext,0)


        def RBR(self):
            return self.getToken(normParser.RBR, 0)

        def COLON(self):
            return self.getToken(normParser.COLON, 0)

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

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

        def getRuleIndex(self):
            return normParser.RULE_typeDeclaration

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

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




    def typeDeclaration(self):

        localctx = normParser.TypeDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_typeDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 540
            self.typeName()
            self.state = 545
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.LBR:
                self.state = 541
                self.match(normParser.LBR)
                self.state = 542
                self.argumentDeclarations()
                self.state = 543
                self.match(normParser.RBR)


            self.state = 555
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,95,self._ctx)
            if la_ == 1:
                self.state = 548
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 547
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 550
                self.match(normParser.COLON)
                self.state = 552
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 551
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 554
                self.typeName()


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


    class VersionContext(ParserRuleContext):

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

        def UUID(self):
            return self.getToken(normParser.UUID, 0)

        def getRuleIndex(self):
            return normParser.RULE_version

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

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




    def version(self):

        localctx = normParser.VersionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_version)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 557
            _la = self._input.LA(1)
            if not(((((_la - 3)) & ~0x3f) == 0 and ((1 << (_la - 3)) & ((1 << (normParser.T__2 - 3)) | (1 << (normParser.T__3 - 3)) | (1 << (normParser.UUID - 3)))) != 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 QueryProjectionContext(ParserRuleContext):

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

        def variable(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.VariableContext)
            else:
                return self.getTypedRuleContext(normParser.VariableContext,i)


        def LBR(self):
            return self.getToken(normParser.LBR, 0)

        def RBR(self):
            return self.getToken(normParser.RBR, 0)

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

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

        def getRuleIndex(self):
            return normParser.RULE_queryProjection

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

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




    def queryProjection(self):

        localctx = normParser.QueryProjectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_queryProjection)
        self._la = 0 # Token type
        try:
            self.state = 581
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,100,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 559
                self.match(normParser.T__4)
                self.state = 561
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
                if la_ == 1:
                    self.state = 560
                    self.variable(0)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 563
                self.match(normParser.T__4)
                self.state = 564
                self.match(normParser.LBR)
                self.state = 565
                self.variable(0)
                self.state = 576
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==normParser.WS or _la==normParser.COMMA:
                    self.state = 567
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 566
                        self.match(normParser.WS)


                    self.state = 569
                    self.match(normParser.COMMA)
                    self.state = 571
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 570
                        self.match(normParser.WS)


                    self.state = 573
                    self.variable(0)
                    self.state = 578
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 579
                self.match(normParser.RBR)
                pass


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


    class ConstantContext(ParserRuleContext):

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

        def none(self):
            return self.getTypedRuleContext(normParser.NoneContext,0)


        def bool_c(self):
            return self.getTypedRuleContext(normParser.Bool_cContext,0)


        def integer_c(self):
            return self.getTypedRuleContext(normParser.Integer_cContext,0)


        def float_c(self):
            return self.getTypedRuleContext(normParser.Float_cContext,0)


        def string_c(self):
            return self.getTypedRuleContext(normParser.String_cContext,0)


        def pattern(self):
            return self.getTypedRuleContext(normParser.PatternContext,0)


        def uuid(self):
            return self.getTypedRuleContext(normParser.UuidContext,0)


        def url(self):
            return self.getTypedRuleContext(normParser.UrlContext,0)


        def datetime(self):
            return self.getTypedRuleContext(normParser.DatetimeContext,0)


        def LBR(self):
            return self.getToken(normParser.LBR, 0)

        def constant(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.ConstantContext)
            else:
                return self.getTypedRuleContext(normParser.ConstantContext,i)


        def RBR(self):
            return self.getToken(normParser.RBR, 0)

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

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

        def LSBR(self):
            return self.getToken(normParser.LSBR, 0)

        def RSBR(self):
            return self.getToken(normParser.RSBR, 0)

        def getRuleIndex(self):
            return normParser.RULE_constant

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

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




    def constant(self):

        localctx = normParser.ConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_constant)
        self._la = 0 # Token type
        try:
            self.state = 626
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [normParser.NONE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 583
                self.none()
                pass
            elif token in [normParser.BOOLEAN]:
                self.enterOuterAlt(localctx, 2)
                self.state = 584
                self.bool_c()
                pass
            elif token in [normParser.INTEGER]:
                self.enterOuterAlt(localctx, 3)
                self.state = 585
                self.integer_c()
                pass
            elif token in [normParser.FLOAT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 586
                self.float_c()
                pass
            elif token in [normParser.STRING]:
                self.enterOuterAlt(localctx, 5)
                self.state = 587
                self.string_c()
                pass
            elif token in [normParser.PATTERN]:
                self.enterOuterAlt(localctx, 6)
                self.state = 588
                self.pattern()
                pass
            elif token in [normParser.UUID]:
                self.enterOuterAlt(localctx, 7)
                self.state = 589
                self.uuid()
                pass
            elif token in [normParser.URL]:
                self.enterOuterAlt(localctx, 8)
                self.state = 590
                self.url()
                pass
            elif token in [normParser.DATETIME]:
                self.enterOuterAlt(localctx, 9)
                self.state = 591
                self.datetime()
                pass
            elif token in [normParser.LBR]:
                self.enterOuterAlt(localctx, 10)
                self.state = 592
                self.match(normParser.LBR)
                self.state = 593
                self.constant()
                self.state = 604
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==normParser.WS or _la==normParser.COMMA:
                    self.state = 595
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 594
                        self.match(normParser.WS)


                    self.state = 597
                    self.match(normParser.COMMA)
                    self.state = 599
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 598
                        self.match(normParser.WS)


                    self.state = 601
                    self.constant()
                    self.state = 606
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 607
                self.match(normParser.RBR)
                pass
            elif token in [normParser.LSBR]:
                self.enterOuterAlt(localctx, 11)
                self.state = 609
                self.match(normParser.LSBR)
                self.state = 610
                self.constant()
                self.state = 621
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==normParser.WS or _la==normParser.COMMA:
                    self.state = 612
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 611
                        self.match(normParser.WS)


                    self.state = 614
                    self.match(normParser.COMMA)
                    self.state = 616
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS:
                        self.state = 615
                        self.match(normParser.WS)


                    self.state = 618
                    self.constant()
                    self.state = 623
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 624
                self.match(normParser.RSBR)
                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 CodeContext(ParserRuleContext):

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

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

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

        def getRuleIndex(self):
            return normParser.RULE_code

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

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




    def code(self):

        localctx = normParser.CodeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_code)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 631
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << normParser.T__0) | (1 << normParser.T__1) | (1 << normParser.T__2) | (1 << normParser.T__3) | (1 << normParser.T__4) | (1 << normParser.IMPL) | (1 << normParser.CEQ) | (1 << normParser.OEQ) | (1 << normParser.AEQ) | (1 << normParser.SINGLELINE) | (1 << normParser.MULTILINE) | (1 << normParser.SPACED_EXPORT) | (1 << normParser.EXPORT) | (1 << normParser.SPACED_IMPORT) | (1 << normParser.IMPORT) | (1 << normParser.SPACED_COMMAND) | (1 << normParser.COMMAND) | (1 << normParser.ARGOPT) | (1 << normParser.EXIST) | (1 << normParser.NEXIST) | (1 << normParser.WITH) | (1 << normParser.FOREACH) | (1 << normParser.FORANY) | (1 << normParser.WS) | (1 << normParser.NS) | (1 << normParser.LBR) | (1 << normParser.RBR) | (1 << normParser.LCBR) | (1 << normParser.RCBR) | (1 << normParser.LSBR) | (1 << normParser.RSBR) | (1 << normParser.NONE) | (1 << normParser.AS) | (1 << normParser.COLON) | (1 << normParser.SEMICOLON) | (1 << normParser.COMMA) | (1 << normParser.DOT) | (1 << normParser.DOTDOT) | (1 << normParser.IN) | (1 << normParser.NI) | (1 << normParser.EQ) | (1 << normParser.NE) | (1 << normParser.GE) | (1 << normParser.LE) | (1 << normParser.GT) | (1 << normParser.LT) | (1 << normParser.LK) | (1 << normParser.MINUS) | (1 << normParser.PLUS) | (1 << normParser.TIMES) | (1 << normParser.DIVIDE) | (1 << normParser.EXP) | (1 << normParser.MOD) | (1 << normParser.NOT) | (1 << normParser.AND) | (1 << normParser.OR) | (1 << normParser.XOR) | (1 << normParser.IMP) | (1 << normParser.EQV) | (1 << normParser.BOOLEAN) | (1 << normParser.INTEGER) | (1 << normParser.FLOAT) | (1 << normParser.STRING))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (normParser.PATTERN - 64)) | (1 << (normParser.UUID - 64)) | (1 << (normParser.URL - 64)) | (1 << (normParser.DATETIME - 64)) | (1 << (normParser.VARNAME - 64)))) != 0):
                self.state = 628
                _la = self._input.LA(1)
                if _la <= 0 or _la==normParser.PYTHON_BLOCK or _la==normParser.BLOCK_END:
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 633
                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 CodeExpressionContext(ParserRuleContext):

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

        def PYTHON_BLOCK(self):
            return self.getToken(normParser.PYTHON_BLOCK, 0)

        def code(self):
            return self.getTypedRuleContext(normParser.CodeContext,0)


        def BLOCK_END(self):
            return self.getToken(normParser.BLOCK_END, 0)

        def getRuleIndex(self):
            return normParser.RULE_codeExpression

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

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




    def codeExpression(self):

        localctx = normParser.CodeExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_codeExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 634
            self.match(normParser.PYTHON_BLOCK)
            self.state = 635
            self.code()
            self.state = 636
            self.match(normParser.BLOCK_END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgumentExpressionContext(ParserRuleContext):

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

        def arithmeticExpression(self):
            return self.getTypedRuleContext(normParser.ArithmeticExpressionContext,0)


        def queryProjection(self):
            return self.getTypedRuleContext(normParser.QueryProjectionContext,0)


        def variable(self):
            return self.getTypedRuleContext(normParser.VariableContext,0)


        def AS(self):
            return self.getToken(normParser.AS, 0)

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

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

        def spacedConditionOperator(self):
            return self.getTypedRuleContext(normParser.SpacedConditionOperatorContext,0)


        def getRuleIndex(self):
            return normParser.RULE_argumentExpression

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

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




    def argumentExpression(self):

        localctx = normParser.ArgumentExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_argumentExpression)
        self._la = 0 # Token type
        try:
            self.state = 661
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,113,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 638
                self.arithmeticExpression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 639
                self.queryProjection()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 640
                self.variable(0)
                self.state = 641
                self.queryProjection()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 643
                self.variable(0)
                self.state = 645
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 644
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 647
                self.match(normParser.AS)
                self.state = 649
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 648
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 651
                self.arithmeticExpression(0)
                self.state = 653
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.T__4:
                    self.state = 652
                    self.queryProjection()


                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 655
                self.variable(0)
                self.state = 656
                self.spacedConditionOperator()
                self.state = 657
                self.arithmeticExpression(0)
                self.state = 659
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.T__4:
                    self.state = 658
                    self.queryProjection()


                pass


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


    class ArgumentExpressionsContext(ParserRuleContext):

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

        def LBR(self):
            return self.getToken(normParser.LBR, 0)

        def RBR(self):
            return self.getToken(normParser.RBR, 0)

        def argumentExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.ArgumentExpressionContext)
            else:
                return self.getTypedRuleContext(normParser.ArgumentExpressionContext,i)


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

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

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

        def getRuleIndex(self):
            return normParser.RULE_argumentExpressions

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

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




    def argumentExpressions(self):

        localctx = normParser.ArgumentExpressionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_argumentExpressions)
        self._la = 0 # Token type
        try:
            self.state = 682
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 663
                self.match(normParser.LBR)
                self.state = 664
                self.match(normParser.RBR)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 665
                self.match(normParser.LBR)
                self.state = 666
                self.argumentExpression()
                self.state = 677
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << normParser.WS) | (1 << normParser.NS) | (1 << normParser.COMMA))) != 0):
                    self.state = 668
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS or _la==normParser.NS:
                        self.state = 667
                        _la = self._input.LA(1)
                        if not(_la==normParser.WS or _la==normParser.NS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()


                    self.state = 670
                    self.match(normParser.COMMA)
                    self.state = 672
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS or _la==normParser.NS:
                        self.state = 671
                        _la = self._input.LA(1)
                        if not(_la==normParser.WS or _la==normParser.NS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()


                    self.state = 674
                    self.argumentExpression()
                    self.state = 679
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 680
                self.match(normParser.RBR)
                pass


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


    class EvaluationExpressionContext(ParserRuleContext):

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

        def constant(self):
            return self.getTypedRuleContext(normParser.ConstantContext,0)


        def variable(self):
            return self.getTypedRuleContext(normParser.VariableContext,0)


        def argumentExpressions(self):
            return self.getTypedRuleContext(normParser.ArgumentExpressionsContext,0)


        def evaluationExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.EvaluationExpressionContext)
            else:
                return self.getTypedRuleContext(normParser.EvaluationExpressionContext,i)


        def DOT(self):
            return self.getToken(normParser.DOT, 0)

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

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

        def getRuleIndex(self):
            return normParser.RULE_evaluationExpression

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

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



    def evaluationExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = normParser.EvaluationExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 54
        self.enterRecursionRule(localctx, 54, self.RULE_evaluationExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 691
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,118,self._ctx)
            if la_ == 1:
                self.state = 685
                self.constant()
                pass

            elif la_ == 2:
                self.state = 686
                self.variable(0)
                pass

            elif la_ == 3:
                self.state = 687
                self.argumentExpressions()
                pass

            elif la_ == 4:
                self.state = 688
                self.variable(0)
                self.state = 689
                self.argumentExpressions()
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 704
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,121,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = normParser.EvaluationExpressionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_evaluationExpression)
                    self.state = 693
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 695
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS or _la==normParser.NS:
                        self.state = 694
                        _la = self._input.LA(1)
                        if not(_la==normParser.WS or _la==normParser.NS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()


                    self.state = 697
                    self.match(normParser.DOT)
                    self.state = 699
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==normParser.WS or _la==normParser.NS:
                        self.state = 698
                        _la = self._input.LA(1)
                        if not(_la==normParser.WS or _la==normParser.NS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()


                    self.state = 701
                    self.evaluationExpression(2) 
                self.state = 706
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,121,self._ctx)

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


    class SlicedExpressionContext(ParserRuleContext):

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

        def evaluationExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.EvaluationExpressionContext)
            else:
                return self.getTypedRuleContext(normParser.EvaluationExpressionContext,i)


        def LSBR(self):
            return self.getToken(normParser.LSBR, 0)

        def RSBR(self):
            return self.getToken(normParser.RSBR, 0)

        def integer_c(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.Integer_cContext)
            else:
                return self.getTypedRuleContext(normParser.Integer_cContext,i)


        def COLON(self):
            return self.getToken(normParser.COLON, 0)

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

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

        def getRuleIndex(self):
            return normParser.RULE_slicedExpression

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

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




    def slicedExpression(self):

        localctx = normParser.SlicedExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_slicedExpression)
        self._la = 0 # Token type
        try:
            self.state = 732
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,127,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 707
                self.evaluationExpression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 708
                self.evaluationExpression(0)
                self.state = 709
                self.match(normParser.LSBR)
                self.state = 711
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
                if la_ == 1:
                    self.state = 710
                    self.integer_c()


                self.state = 714
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
                if la_ == 1:
                    self.state = 713
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 717
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.COLON:
                    self.state = 716
                    self.match(normParser.COLON)


                self.state = 720
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS or _la==normParser.NS:
                    self.state = 719
                    _la = self._input.LA(1)
                    if not(_la==normParser.WS or _la==normParser.NS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 723
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.INTEGER:
                    self.state = 722
                    self.integer_c()


                self.state = 725
                self.match(normParser.RSBR)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 727
                self.evaluationExpression(0)
                self.state = 728
                self.match(normParser.LSBR)
                self.state = 729
                self.evaluationExpression(0)
                self.state = 730
                self.match(normParser.RSBR)
                pass


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


    class ArithmeticExpressionContext(ParserRuleContext):

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

        def slicedExpression(self):
            return self.getTypedRuleContext(normParser.SlicedExpressionContext,0)


        def codeExpression(self):
            return self.getTypedRuleContext(normParser.CodeExpressionContext,0)


        def LBR(self):
            return self.getToken(normParser.LBR, 0)

        def arithmeticExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.ArithmeticExpressionContext)
            else:
                return self.getTypedRuleContext(normParser.ArithmeticExpressionContext,i)


        def RBR(self):
            return self.getToken(normParser.RBR, 0)

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

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

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

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

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

        def TIMES(self):
            return self.getToken(normParser.TIMES, 0)

        def DIVIDE(self):
            return self.getToken(normParser.DIVIDE, 0)

        def PLUS(self):
            return self.getToken(normParser.PLUS, 0)

        def getRuleIndex(self):
            return normParser.RULE_arithmeticExpression

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

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



    def arithmeticExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = normParser.ArithmeticExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 58
        self.enterRecursionRule(localctx, 58, self.RULE_arithmeticExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 743
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,128,self._ctx)
            if la_ == 1:
                self.state = 735
                self.slicedExpression()
                pass

            elif la_ == 2:
                self.state = 736
                self.codeExpression()
                pass

            elif la_ == 3:
                self.state = 737
                self.match(normParser.LBR)
                self.state = 738
                self.arithmeticExpression(0)
                self.state = 739
                self.match(normParser.RBR)
                pass

            elif la_ == 4:
                self.state = 741
                self.match(normParser.MINUS)
                self.state = 742
                self.arithmeticExpression(4)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 774
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,136,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 772
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
                    if la_ == 1:
                        localctx = normParser.ArithmeticExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_arithmeticExpression)
                        self.state = 745
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 747
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==normParser.WS or _la==normParser.NS:
                            self.state = 746
                            _la = self._input.LA(1)
                            if not(_la==normParser.WS or _la==normParser.NS):
                                self._errHandler.recoverInline(self)
                            else:
                                self._errHandler.reportMatch(self)
                                self.consume()


                        self.state = 749
                        _la = self._input.LA(1)
                        if not(_la==normParser.EXP or _la==normParser.MOD):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 751
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==normParser.WS or _la==normParser.NS:
                            self.state = 750
                            _la = self._input.LA(1)
                            if not(_la==normParser.WS or _la==normParser.NS):
                                self._errHandler.recoverInline(self)
                            else:
                                self._errHandler.reportMatch(self)
                                self.consume()


                        self.state = 753
                        self.arithmeticExpression(4)
                        pass

                    elif la_ == 2:
                        localctx = normParser.ArithmeticExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_arithmeticExpression)
                        self.state = 754
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 756
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==normParser.WS or _la==normParser.NS:
                            self.state = 755
                            _la = self._input.LA(1)
                            if not(_la==normParser.WS or _la==normParser.NS):
                                self._errHandler.recoverInline(self)
                            else:
                                self._errHandler.reportMatch(self)
                                self.consume()


                        self.state = 758
                        _la = self._input.LA(1)
                        if not(_la==normParser.TIMES or _la==normParser.DIVIDE):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 760
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==normParser.WS or _la==normParser.NS:
                            self.state = 759
                            _la = self._input.LA(1)
                            if not(_la==normParser.WS or _la==normParser.NS):
                                self._errHandler.recoverInline(self)
                            else:
                                self._errHandler.reportMatch(self)
                                self.consume()


                        self.state = 762
                        self.arithmeticExpression(3)
                        pass

                    elif la_ == 3:
                        localctx = normParser.ArithmeticExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_arithmeticExpression)
                        self.state = 763
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 765
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==normParser.WS or _la==normParser.NS:
                            self.state = 764
                            _la = self._input.LA(1)
                            if not(_la==normParser.WS or _la==normParser.NS):
                                self._errHandler.recoverInline(self)
                            else:
                                self._errHandler.reportMatch(self)
                                self.consume()


                        self.state = 767
                        _la = self._input.LA(1)
                        if not(_la==normParser.MINUS or _la==normParser.PLUS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 769
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==normParser.WS or _la==normParser.NS:
                            self.state = 768
                            _la = self._input.LA(1)
                            if not(_la==normParser.WS or _la==normParser.NS):
                                self._errHandler.recoverInline(self)
                            else:
                                self._errHandler.reportMatch(self)
                                self.consume()


                        self.state = 771
                        self.arithmeticExpression(2)
                        pass

             
                self.state = 776
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,136,self._ctx)

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


    class ConditionExpressionContext(ParserRuleContext):

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

        def arithmeticExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.ArithmeticExpressionContext)
            else:
                return self.getTypedRuleContext(normParser.ArithmeticExpressionContext,i)


        def spacedConditionOperator(self):
            return self.getTypedRuleContext(normParser.SpacedConditionOperatorContext,0)


        def getRuleIndex(self):
            return normParser.RULE_conditionExpression

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

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




    def conditionExpression(self):

        localctx = normParser.ConditionExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_conditionExpression)
        try:
            self.state = 782
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,137,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 777
                self.arithmeticExpression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 778
                self.arithmeticExpression(0)
                self.state = 779
                self.spacedConditionOperator()
                self.state = 780
                self.arithmeticExpression(0)
                pass


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


    class OneLineExpressionContext(ParserRuleContext):

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

        def conditionExpression(self):
            return self.getTypedRuleContext(normParser.ConditionExpressionContext,0)


        def WS(self):
            return self.getToken(normParser.WS, 0)

        def queryProjection(self):
            return self.getTypedRuleContext(normParser.QueryProjectionContext,0)


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

        def oneLineExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(normParser.OneLineExpressionContext)
            else:
                return self.getTypedRuleContext(normParser.OneLineExpressionContext,i)


        def spacedLogicalOperator(self):
            return self.getTypedRuleContext(normParser.SpacedLogicalOperatorContext,0)


        def getRuleIndex(self):
            return normParser.RULE_oneLineExpression

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

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



    def oneLineExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = normParser.OneLineExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 62
        self.enterRecursionRule(localctx, 62, self.RULE_oneLineExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 797
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [normParser.COMMAND, normParser.ARGOPT, normParser.LBR, normParser.LCBR, normParser.LSBR, normParser.NONE, normParser.MINUS, normParser.BOOLEAN, normParser.INTEGER, normParser.FLOAT, normParser.STRING, normParser.PATTERN, normParser.UUID, normParser.URL, normParser.DATETIME, normParser.PYTHON_BLOCK, normParser.VARNAME]:
                self.state = 785
                self.conditionExpression()
                self.state = 787
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,138,self._ctx)
                if la_ == 1:
                    self.state = 786
                    self.match(normParser.WS)


                self.state = 790
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,139,self._ctx)
                if la_ == 1:
                    self.state = 789
                    self.queryProjection()


                pass
            elif token in [normParser.NOT]:
                self.state = 792
                self.match(normParser.NOT)
                self.state = 794
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==normParser.WS:
                    self.state = 793
                    self.match(normParser.WS)


                self.state = 796
                self.oneLineExpression(2)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 805
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,142,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = normParser.OneLineExpressionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_oneLineExpression)
                    self.state = 799
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 800
                    self.spacedLogicalOperator()
                    self.state = 801
                    self.oneLineExpression(2) 
                self.state = 807
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,142,self._ctx)

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


    class ContextualOneLineExpressionContext(ParserRuleContext):

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

        def oneLineExpression(self):
            return self.getTypedRuleContext(normParser.OneLineExpressionContext,0)


        def contexts(self):
            return self.getTypedRuleContext(normParser.ContextsContext,0)


        def WS(self):
            return self.getToken(normParser.WS, 0)

        def NS(self):
            return self.getToken(normParser.NS, 0)

        def getRuleIndex(self):
            return normParser.RULE_contextualOneLineExpression

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

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




    def contextualOneLineExpression(self):

        localctx = normParser.ContextualOneLineExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_contextualOneLineExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 809
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << normParser.EXIST) | (1 << normParser.NEXIST) | (1 << normParser.WITH) | (1 << normParser.FOREACH) | (1 << normParser.FORANY))) != 0):
                self.state = 808
                self.contexts()


            self.state = 812
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.WS or _la==normParser.NS:
                self.state = 811
                _la = self._input.LA(1)
                if not(_la==normParser.WS or _la==normParser.NS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


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


    class MultiLineExpressionContext(ParserRuleContext):

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

        def contextualOneLineExpression(self):
            return self.getTypedRuleContext(normParser.ContextualOneLineExpressionContext,0)


        def newlineLogicalOperator(self):
            return self.getTypedRuleContext(normParser.NewlineLogicalOperatorContext,0)


        def multiLineExpression(self):
            return self.getTypedRuleContext(normParser.MultiLineExpressionContext,0)


        def contexts(self):
            return self.getTypedRuleContext(normParser.ContextsContext,0)


        def NS(self):
            return self.getToken(normParser.NS, 0)

        def getRuleIndex(self):
            return normParser.RULE_multiLineExpression

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

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




    def multiLineExpression(self):

        localctx = normParser.MultiLineExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_multiLineExpression)
        try:
            self.state = 825
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,145,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 816
                self.contextualOneLineExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 817
                self.contextualOneLineExpression()
                self.state = 818
                self.newlineLogicalOperator()
                self.state = 819
                self.multiLineExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 821
                self.contexts()
                self.state = 822
                self.match(normParser.NS)
                self.state = 823
                self.multiLineExpression()
                pass


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


    class NoneContext(ParserRuleContext):

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

        def NONE(self):
            return self.getToken(normParser.NONE, 0)

        def getRuleIndex(self):
            return normParser.RULE_none

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

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




    def none(self):

        localctx = normParser.NoneContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_none)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 827
            self.match(normParser.NONE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Bool_cContext(ParserRuleContext):

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

        def BOOLEAN(self):
            return self.getToken(normParser.BOOLEAN, 0)

        def getRuleIndex(self):
            return normParser.RULE_bool_c

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

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




    def bool_c(self):

        localctx = normParser.Bool_cContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_bool_c)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 829
            self.match(normParser.BOOLEAN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Integer_cContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return normParser.RULE_integer_c

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

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




    def integer_c(self):

        localctx = normParser.Integer_cContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_integer_c)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 831
            self.match(normParser.INTEGER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Float_cContext(ParserRuleContext):

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

        def FLOAT(self):
            return self.getToken(normParser.FLOAT, 0)

        def getRuleIndex(self):
            return normParser.RULE_float_c

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

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




    def float_c(self):

        localctx = normParser.Float_cContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_float_c)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 833
            self.match(normParser.FLOAT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class String_cContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return normParser.RULE_string_c

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

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




    def string_c(self):

        localctx = normParser.String_cContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_string_c)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 835
            self.match(normParser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PatternContext(ParserRuleContext):

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

        def PATTERN(self):
            return self.getToken(normParser.PATTERN, 0)

        def getRuleIndex(self):
            return normParser.RULE_pattern

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

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




    def pattern(self):

        localctx = normParser.PatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 837
            self.match(normParser.PATTERN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UuidContext(ParserRuleContext):

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

        def UUID(self):
            return self.getToken(normParser.UUID, 0)

        def getRuleIndex(self):
            return normParser.RULE_uuid

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

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




    def uuid(self):

        localctx = normParser.UuidContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_uuid)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 839
            self.match(normParser.UUID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UrlContext(ParserRuleContext):

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

        def URL(self):
            return self.getToken(normParser.URL, 0)

        def getRuleIndex(self):
            return normParser.RULE_url

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

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




    def url(self):

        localctx = normParser.UrlContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_url)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 841
            self.match(normParser.URL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DatetimeContext(ParserRuleContext):

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

        def DATETIME(self):
            return self.getToken(normParser.DATETIME, 0)

        def getRuleIndex(self):
            return normParser.RULE_datetime

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

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




    def datetime(self):

        localctx = normParser.DatetimeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_datetime)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 843
            self.match(normParser.DATETIME)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LogicalOperatorContext(ParserRuleContext):

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

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

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

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

        def XOR(self):
            return self.getToken(normParser.XOR, 0)

        def IMP(self):
            return self.getToken(normParser.IMP, 0)

        def EQV(self):
            return self.getToken(normParser.EQV, 0)

        def getRuleIndex(self):
            return normParser.RULE_logicalOperator

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

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




    def logicalOperator(self):

        localctx = normParser.LogicalOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_logicalOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 845
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << normParser.NOT) | (1 << normParser.AND) | (1 << normParser.OR) | (1 << normParser.XOR) | (1 << normParser.IMP) | (1 << normParser.EQV))) != 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 SpacedLogicalOperatorContext(ParserRuleContext):

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

        def logicalOperator(self):
            return self.getTypedRuleContext(normParser.LogicalOperatorContext,0)


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

        def getRuleIndex(self):
            return normParser.RULE_spacedLogicalOperator

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

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




    def spacedLogicalOperator(self):

        localctx = normParser.SpacedLogicalOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_spacedLogicalOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 848
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.WS:
                self.state = 847
                self.match(normParser.WS)


            self.state = 850
            self.logicalOperator()
            self.state = 852
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.WS:
                self.state = 851
                self.match(normParser.WS)


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


    class NewlineLogicalOperatorContext(ParserRuleContext):

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

        def NS(self):
            return self.getToken(normParser.NS, 0)

        def logicalOperator(self):
            return self.getTypedRuleContext(normParser.LogicalOperatorContext,0)


        def WS(self):
            return self.getToken(normParser.WS, 0)

        def getRuleIndex(self):
            return normParser.RULE_newlineLogicalOperator

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

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




    def newlineLogicalOperator(self):

        localctx = normParser.NewlineLogicalOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_newlineLogicalOperator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 854
            self.match(normParser.NS)
            self.state = 855
            self.logicalOperator()
            self.state = 857
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,148,self._ctx)
            if la_ == 1:
                self.state = 856
                self.match(normParser.WS)


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


    class ConditionOperatorContext(ParserRuleContext):

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

        def EQ(self):
            return self.getToken(normParser.EQ, 0)

        def NE(self):
            return self.getToken(normParser.NE, 0)

        def IN(self):
            return self.getToken(normParser.IN, 0)

        def NI(self):
            return self.getToken(normParser.NI, 0)

        def LT(self):
            return self.getToken(normParser.LT, 0)

        def LE(self):
            return self.getToken(normParser.LE, 0)

        def GT(self):
            return self.getToken(normParser.GT, 0)

        def GE(self):
            return self.getToken(normParser.GE, 0)

        def LK(self):
            return self.getToken(normParser.LK, 0)

        def getRuleIndex(self):
            return normParser.RULE_conditionOperator

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

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




    def conditionOperator(self):

        localctx = normParser.ConditionOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_conditionOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 859
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << normParser.IN) | (1 << normParser.NI) | (1 << normParser.EQ) | (1 << normParser.NE) | (1 << normParser.GE) | (1 << normParser.LE) | (1 << normParser.GT) | (1 << normParser.LT) | (1 << normParser.LK))) != 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 SpacedConditionOperatorContext(ParserRuleContext):

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

        def conditionOperator(self):
            return self.getTypedRuleContext(normParser.ConditionOperatorContext,0)


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

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

        def getRuleIndex(self):
            return normParser.RULE_spacedConditionOperator

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

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




    def spacedConditionOperator(self):

        localctx = normParser.SpacedConditionOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_spacedConditionOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 862
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.WS or _la==normParser.NS:
                self.state = 861
                _la = self._input.LA(1)
                if not(_la==normParser.WS or _la==normParser.NS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 864
            self.conditionOperator()
            self.state = 866
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==normParser.WS or _la==normParser.NS:
                self.state = 865
                _la = self._input.LA(1)
                if not(_la==normParser.WS or _la==normParser.NS):
                    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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[10] = self.variable_sempred
        self._predicates[27] = self.evaluationExpression_sempred
        self._predicates[29] = self.arithmeticExpression_sempred
        self._predicates[31] = self.oneLineExpression_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def variable_sempred(self, localctx:VariableContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 2)
         

    def evaluationExpression_sempred(self, localctx:EvaluationExpressionContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 1)
         

    def arithmeticExpression_sempred(self, localctx:ArithmeticExpressionContext, predIndex:int):
            if predIndex == 2:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 1)
         

    def oneLineExpression_sempred(self, localctx:OneLineExpressionContext, predIndex:int):
            if predIndex == 5:
                return self.precpred(self._ctx, 1)
         




