# Generated from tools/antlr/GnosisEPL.g4 by ANTLR 4.8
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\65")
        buf.write("\u0203\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/\3\2\6\2`\n\2\r\2\16\2a\3\3\3\3\3\4\6\4g\n\4\r\4\16")
        buf.write("\4h\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3")
        buf.write("\5\3\5\3\5\3\5\3\5\5\5|\n\5\3\5\3\5\3\5\3\5\3\5\3\5\3")
        buf.write("\5\3\5\3\5\3\5\3\5\5\5\u0089\n\5\3\5\3\5\3\5\3\5\3\5\5")
        buf.write("\5\u0090\n\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3")
        buf.write("\5\3\5\3\5\5\5\u009f\n\5\3\5\3\5\3\5\3\5\3\6\3\6\3\7\3")
        buf.write("\7\3\7\3\7\5\7\u00ab\n\7\3\7\7\7\u00ae\n\7\f\7\16\7\u00b1")
        buf.write("\13\7\3\b\3\b\3\t\6\t\u00b6\n\t\r\t\16\t\u00b7\3\n\3\n")
        buf.write("\3\n\6\n\u00bd\n\n\r\n\16\n\u00be\3\13\3\13\3\f\3\f\7")
        buf.write("\f\u00c5\n\f\f\f\16\f\u00c8\13\f\3\f\3\f\3\f\7\f\u00cd")
        buf.write("\n\f\f\f\16\f\u00d0\13\f\3\f\7\f\u00d3\n\f\f\f\16\f\u00d6")
        buf.write("\13\f\3\f\3\f\7\f\u00da\n\f\f\f\16\f\u00dd\13\f\5\f\u00df")
        buf.write("\n\f\3\f\7\f\u00e2\n\f\f\f\16\f\u00e5\13\f\3\r\3\r\3\r")
        buf.write("\3\r\5\r\u00eb\n\r\3\16\3\16\5\16\u00ef\n\16\3\16\3\16")
        buf.write("\3\16\5\16\u00f4\n\16\3\16\3\16\3\16\5\16\u00f9\n\16\3")
        buf.write("\16\5\16\u00fc\n\16\3\17\3\17\5\17\u0100\n\17\3\17\3\17")
        buf.write("\3\17\7\17\u0105\n\17\f\17\16\17\u0108\13\17\3\17\5\17")
        buf.write("\u010b\n\17\3\17\3\17\3\20\3\20\3\21\3\21\3\22\3\22\3")
        buf.write("\23\3\23\5\23\u0117\n\23\3\23\3\23\5\23\u011b\n\23\3\23")
        buf.write("\7\23\u011e\n\23\f\23\16\23\u0121\13\23\3\23\5\23\u0124")
        buf.write("\n\23\3\23\3\23\3\24\3\24\3\25\3\25\3\26\3\26\7\26\u012e")
        buf.write("\n\26\f\26\16\26\u0131\13\26\3\26\3\26\3\26\3\26\7\26")
        buf.write("\u0137\n\26\f\26\16\26\u013a\13\26\5\26\u013c\n\26\3\26")
        buf.write("\7\26\u013f\n\26\f\26\16\26\u0142\13\26\3\26\7\26\u0145")
        buf.write("\n\26\f\26\16\26\u0148\13\26\3\26\3\26\3\27\3\27\3\27")
        buf.write("\3\27\3\30\3\30\3\31\3\31\5\31\u0154\n\31\3\32\3\32\7")
        buf.write("\32\u0158\n\32\f\32\16\32\u015b\13\32\3\32\3\32\3\33\3")
        buf.write("\33\5\33\u0161\n\33\3\34\6\34\u0164\n\34\r\34\16\34\u0165")
        buf.write("\3\35\3\35\3\36\5\36\u016b\n\36\3\36\3\36\7\36\u016f\n")
        buf.write("\36\f\36\16\36\u0172\13\36\3\36\3\36\7\36\u0176\n\36\f")
        buf.write("\36\16\36\u0179\13\36\3\36\3\36\7\36\u017d\n\36\f\36\16")
        buf.write("\36\u0180\13\36\3\37\3\37\3\37\3\37\3\37\3\37\5\37\u0188")
        buf.write("\n\37\3 \3 \3 \3 \3!\3!\3!\6!\u0191\n!\r!\16!\u0192\3")
        buf.write("!\3!\6!\u0197\n!\r!\16!\u0198\3\"\3\"\3\"\3\"\5\"\u019f")
        buf.write("\n\"\3\"\7\"\u01a2\n\"\f\"\16\"\u01a5\13\"\3#\3#\6#\u01a9")
        buf.write("\n#\r#\16#\u01aa\3$\3$\3$\3$\3$\3%\3%\3&\3&\3&\3&\5&\u01b8")
        buf.write("\n&\3&\7&\u01bb\n&\f&\16&\u01be\13&\3\'\3\'\3(\3(\3(\3")
        buf.write("(\5(\u01c6\n(\3(\7(\u01c9\n(\f(\16(\u01cc\13(\3)\3)\3")
        buf.write(")\3)\3)\3)\3*\3*\3+\3+\3,\3,\3-\3-\3-\3-\5-\u01de\n-\3")
        buf.write("-\7-\u01e1\n-\f-\16-\u01e4\13-\3.\3.\3.\5.\u01e9\n.\3")
        buf.write(".\3.\6.\u01ed\n.\r.\16.\u01ee\3.\3.\6.\u01f3\n.\r.\16")
        buf.write(".\u01f4\5.\u01f7\n.\3/\3/\3/\3/\6/\u01fd\n/\r/\16/\u01fe")
        buf.write("\3/\3/\3/\2\2\60\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36")
        buf.write(" \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\\2\7\3\2\61\62")
        buf.write("\3\2\30\35\3\2\63\64\3\2\6\7\3\2)*\2\u0219\2_\3\2\2\2")
        buf.write("\4c\3\2\2\2\6f\3\2\2\2\bl\3\2\2\2\n\u00a4\3\2\2\2\f\u00a6")
        buf.write("\3\2\2\2\16\u00b2\3\2\2\2\20\u00b5\3\2\2\2\22\u00bc\3")
        buf.write("\2\2\2\24\u00c0\3\2\2\2\26\u00c2\3\2\2\2\30\u00e6\3\2")
        buf.write("\2\2\32\u00fb\3\2\2\2\34\u00fd\3\2\2\2\36\u010e\3\2\2")
        buf.write("\2 \u0110\3\2\2\2\"\u0112\3\2\2\2$\u0114\3\2\2\2&\u0127")
        buf.write("\3\2\2\2(\u0129\3\2\2\2*\u012b\3\2\2\2,\u014b\3\2\2\2")
        buf.write(".\u014f\3\2\2\2\60\u0153\3\2\2\2\62\u0155\3\2\2\2\64\u0160")
        buf.write("\3\2\2\2\66\u0163\3\2\2\28\u0167\3\2\2\2:\u016a\3\2\2")
        buf.write("\2<\u0181\3\2\2\2>\u0189\3\2\2\2@\u0196\3\2\2\2B\u019a")
        buf.write("\3\2\2\2D\u01a8\3\2\2\2F\u01ac\3\2\2\2H\u01b1\3\2\2\2")
        buf.write("J\u01b3\3\2\2\2L\u01bf\3\2\2\2N\u01c1\3\2\2\2P\u01cd\3")
        buf.write("\2\2\2R\u01d3\3\2\2\2T\u01d5\3\2\2\2V\u01d7\3\2\2\2X\u01d9")
        buf.write("\3\2\2\2Z\u01ec\3\2\2\2\\\u01f8\3\2\2\2^`\t\2\2\2_^\3")
        buf.write("\2\2\2`a\3\2\2\2a_\3\2\2\2ab\3\2\2\2b\3\3\2\2\2cd\t\3")
        buf.write("\2\2d\5\3\2\2\2eg\5\b\5\2fe\3\2\2\2gh\3\2\2\2hf\3\2\2")
        buf.write("\2hi\3\2\2\2ij\3\2\2\2jk\7\2\2\3k\7\3\2\2\2lm\7\37\2\2")
        buf.write("mn\7\63\2\2no\7 \2\2op\7\63\2\2pq\5\n\6\2qr\5\20\t\2r")
        buf.write("s\7!\2\2st\7\63\2\2tu\5\f\7\2u{\5\20\t\2vw\7\"\2\2wx\7")
        buf.write("\63\2\2xy\5\22\n\2yz\5\20\t\2z|\3\2\2\2{v\3\2\2\2{|\3")
        buf.write("\2\2\2|}\3\2\2\2}~\7$\2\2~\177\7\63\2\2\177\u0080\5\26")
        buf.write("\f\2\u0080\u0088\5\20\t\2\u0081\u0082\7\60\2\2\u0082\u0083")
        buf.write("\7\63\2\2\u0083\u0084\7$\2\2\u0084\u0085\7\63\2\2\u0085")
        buf.write("\u0086\5\26\f\2\u0086\u0087\5\20\t\2\u0087\u0089\3\2\2")
        buf.write("\2\u0088\u0081\3\2\2\2\u0088\u0089\3\2\2\2\u0089\u008f")
        buf.write("\3\2\2\2\u008a\u008b\7,\2\2\u008b\u008c\7\63\2\2\u008c")
        buf.write("\u008d\5:\36\2\u008d\u008e\5\20\t\2\u008e\u0090\3\2\2")
        buf.write("\2\u008f\u008a\3\2\2\2\u008f\u0090\3\2\2\2\u0090\u0091")
        buf.write("\3\2\2\2\u0091\u0092\7+\2\2\u0092\u0093\7\63\2\2\u0093")
        buf.write("\u0094\5B\"\2\u0094\u0095\5\20\t\2\u0095\u0096\7-\2\2")
        buf.write("\u0096\u0097\7\63\2\2\u0097\u0098\5F$\2\u0098\u009e\5")
        buf.write("\20\t\2\u0099\u009a\7.\2\2\u009a\u009b\7\63\2\2\u009b")
        buf.write("\u009c\5N(\2\u009c\u009d\5\20\t\2\u009d\u009f\3\2\2\2")
        buf.write("\u009e\u0099\3\2\2\2\u009e\u009f\3\2\2\2\u009f\u00a0\3")
        buf.write("\2\2\2\u00a0\u00a1\7/\2\2\u00a1\u00a2\7\63\2\2\u00a2\u00a3")
        buf.write("\5V,\2\u00a3\t\3\2\2\2\u00a4\u00a5\5\2\2\2\u00a5\13\3")
        buf.write("\2\2\2\u00a6\u00af\5\16\b\2\u00a7\u00ab\7\13\2\2\u00a8")
        buf.write("\u00a9\7\13\2\2\u00a9\u00ab\7\63\2\2\u00aa\u00a7\3\2\2")
        buf.write("\2\u00aa\u00a8\3\2\2\2\u00ab\u00ac\3\2\2\2\u00ac\u00ae")
        buf.write("\5\16\b\2\u00ad\u00aa\3\2\2\2\u00ae\u00b1\3\2\2\2\u00af")
        buf.write("\u00ad\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\r\3\2\2\2\u00b1")
        buf.write("\u00af\3\2\2\2\u00b2\u00b3\5\2\2\2\u00b3\17\3\2\2\2\u00b4")
        buf.write("\u00b6\t\4\2\2\u00b5\u00b4\3\2\2\2\u00b6\u00b7\3\2\2\2")
        buf.write("\u00b7\u00b5\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\21\3\2")
        buf.write("\2\2\u00b9\u00bd\5\24\13\2\u00ba\u00bd\7\13\2\2\u00bb")
        buf.write("\u00bd\7\63\2\2\u00bc\u00b9\3\2\2\2\u00bc\u00ba\3\2\2")
        buf.write("\2\u00bc\u00bb\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00bc")
        buf.write("\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf\23\3\2\2\2\u00c0\u00c1")
        buf.write("\7\62\2\2\u00c1\25\3\2\2\2\u00c2\u00e3\5\30\r\2\u00c3")
        buf.write("\u00c5\7\63\2\2\u00c4\u00c3\3\2\2\2\u00c5\u00c8\3\2\2")
        buf.write("\2\u00c6\u00c4\3\2\2\2\u00c6\u00c7\3\2\2\2\u00c7\u00c9")
        buf.write("\3\2\2\2\u00c8\u00c6\3\2\2\2\u00c9\u00df\7\13\2\2\u00ca")
        buf.write("\u00ce\7\13\2\2\u00cb\u00cd\7\63\2\2\u00cc\u00cb\3\2\2")
        buf.write("\2\u00cd\u00d0\3\2\2\2\u00ce\u00cc\3\2\2\2\u00ce\u00cf")
        buf.write("\3\2\2\2\u00cf\u00df\3\2\2\2\u00d0\u00ce\3\2\2\2\u00d1")
        buf.write("\u00d3\7\63\2\2\u00d2\u00d1\3\2\2\2\u00d3\u00d6\3\2\2")
        buf.write("\2\u00d4\u00d2\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5\u00d7")
        buf.write("\3\2\2\2\u00d6\u00d4\3\2\2\2\u00d7\u00db\7\13\2\2\u00d8")
        buf.write("\u00da\7\63\2\2\u00d9\u00d8\3\2\2\2\u00da\u00dd\3\2\2")
        buf.write("\2\u00db\u00d9\3\2\2\2\u00db\u00dc\3\2\2\2\u00dc\u00df")
        buf.write("\3\2\2\2\u00dd\u00db\3\2\2\2\u00de\u00c6\3\2\2\2\u00de")
        buf.write("\u00ca\3\2\2\2\u00de\u00d4\3\2\2\2\u00df\u00e0\3\2\2\2")
        buf.write("\u00e0\u00e2\5\30\r\2\u00e1\u00de\3\2\2\2\u00e2\u00e5")
        buf.write("\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4")
        buf.write("\27\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e6\u00ea\5 \21\2\u00e7")
        buf.write("\u00e8\5\32\16\2\u00e8\u00e9\5\30\r\2\u00e9\u00eb\3\2")
        buf.write("\2\2\u00ea\u00e7\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb\31")
        buf.write("\3\2\2\2\u00ec\u00ee\7\3\2\2\u00ed\u00ef\5\34\17\2\u00ee")
        buf.write("\u00ed\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f0\3\2\2\2")
        buf.write("\u00f0\u00fc\7\4\2\2\u00f1\u00f3\7\3\2\2\u00f2\u00f4\5")
        buf.write("\34\17\2\u00f3\u00f2\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4")
        buf.write("\u00f5\3\2\2\2\u00f5\u00fc\7\3\2\2\u00f6\u00f8\7\5\2\2")
        buf.write("\u00f7\u00f9\5\34\17\2\u00f8\u00f7\3\2\2\2\u00f8\u00f9")
        buf.write("\3\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fc\7\3\2\2\u00fb")
        buf.write("\u00ec\3\2\2\2\u00fb\u00f1\3\2\2\2\u00fb\u00f6\3\2\2\2")
        buf.write("\u00fc\33\3\2\2\2\u00fd\u00ff\7\20\2\2\u00fe\u0100\5(")
        buf.write("\25\2\u00ff\u00fe\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0101")
        buf.write("\3\2\2\2\u0101\u0102\7\t\2\2\u0102\u010a\5\36\20\2\u0103")
        buf.write("\u0105\7\63\2\2\u0104\u0103\3\2\2\2\u0105\u0108\3\2\2")
        buf.write("\2\u0106\u0104\3\2\2\2\u0106\u0107\3\2\2\2\u0107\u0109")
        buf.write("\3\2\2\2\u0108\u0106\3\2\2\2\u0109\u010b\5*\26\2\u010a")
        buf.write("\u0106\3\2\2\2\u010a\u010b\3\2\2\2\u010b\u010c\3\2\2\2")
        buf.write("\u010c\u010d\7\17\2\2\u010d\35\3\2\2\2\u010e\u010f\5\2")
        buf.write("\2\2\u010f\37\3\2\2\2\u0110\u0111\5$\23\2\u0111!\3\2\2")
        buf.write("\2\u0112\u0113\5$\23\2\u0113#\3\2\2\2\u0114\u0116\7\16")
        buf.write("\2\2\u0115\u0117\5(\25\2\u0116\u0115\3\2\2\2\u0116\u0117")
        buf.write("\3\2\2\2\u0117\u011a\3\2\2\2\u0118\u0119\7\t\2\2\u0119")
        buf.write("\u011b\5&\24\2\u011a\u0118\3\2\2\2\u011a\u011b\3\2\2\2")
        buf.write("\u011b\u0123\3\2\2\2\u011c\u011e\7\63\2\2\u011d\u011c")
        buf.write("\3\2\2\2\u011e\u0121\3\2\2\2\u011f\u011d\3\2\2\2\u011f")
        buf.write("\u0120\3\2\2\2\u0120\u0122\3\2\2\2\u0121\u011f\3\2\2\2")
        buf.write("\u0122\u0124\5*\26\2\u0123\u011f\3\2\2\2\u0123\u0124\3")
        buf.write("\2\2\2\u0124\u0125\3\2\2\2\u0125\u0126\7\r\2\2\u0126%")
        buf.write("\3\2\2\2\u0127\u0128\5\2\2\2\u0128\'\3\2\2\2\u0129\u012a")
        buf.write("\5\2\2\2\u012a)\3\2\2\2\u012b\u012f\7\22\2\2\u012c\u012e")
        buf.write("\7\63\2\2\u012d\u012c\3\2\2\2\u012e\u0131\3\2\2\2\u012f")
        buf.write("\u012d\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u0132\3\2\2\2")
        buf.write("\u0131\u012f\3\2\2\2\u0132\u0140\5,\27\2\u0133\u013c\7")
        buf.write("\13\2\2\u0134\u0138\7\13\2\2\u0135\u0137\7\63\2\2\u0136")
        buf.write("\u0135\3\2\2\2\u0137\u013a\3\2\2\2\u0138\u0136\3\2\2\2")
        buf.write("\u0138\u0139\3\2\2\2\u0139\u013c\3\2\2\2\u013a\u0138\3")
        buf.write("\2\2\2\u013b\u0133\3\2\2\2\u013b\u0134\3\2\2\2\u013c\u013d")
        buf.write("\3\2\2\2\u013d\u013f\5,\27\2\u013e\u013b\3\2\2\2\u013f")
        buf.write("\u0142\3\2\2\2\u0140\u013e\3\2\2\2\u0140\u0141\3\2\2\2")
        buf.write("\u0141\u0146\3\2\2\2\u0142\u0140\3\2\2\2\u0143\u0145\7")
        buf.write("\63\2\2\u0144\u0143\3\2\2\2\u0145\u0148\3\2\2\2\u0146")
        buf.write("\u0144\3\2\2\2\u0146\u0147\3\2\2\2\u0147\u0149\3\2\2\2")
        buf.write("\u0148\u0146\3\2\2\2\u0149\u014a\7\21\2\2\u014a+\3\2\2")
        buf.write("\2\u014b\u014c\5.\30\2\u014c\u014d\7\t\2\2\u014d\u014e")
        buf.write("\5\60\31\2\u014e-\3\2\2\2\u014f\u0150\5\2\2\2\u0150/\3")
        buf.write("\2\2\2\u0151\u0154\5\62\32\2\u0152\u0154\5\66\34\2\u0153")
        buf.write("\u0151\3\2\2\2\u0153\u0152\3\2\2\2\u0154\61\3\2\2\2\u0155")
        buf.write("\u0159\t\5\2\2\u0156\u0158\5\64\33\2\u0157\u0156\3\2\2")
        buf.write("\2\u0158\u015b\3\2\2\2\u0159\u0157\3\2\2\2\u0159\u015a")
        buf.write("\3\2\2\2\u015a\u015c\3\2\2\2\u015b\u0159\3\2\2\2\u015c")
        buf.write("\u015d\t\5\2\2\u015d\63\3\2\2\2\u015e\u0161\5\2\2\2\u015f")
        buf.write("\u0161\7\63\2\2\u0160\u015e\3\2\2\2\u0160\u015f\3\2\2")
        buf.write("\2\u0161\65\3\2\2\2\u0162\u0164\7\61\2\2\u0163\u0162\3")
        buf.write("\2\2\2\u0164\u0165\3\2\2\2\u0165\u0163\3\2\2\2\u0165\u0166")
        buf.write("\3\2\2\2\u0166\67\3\2\2\2\u0167\u0168\t\6\2\2\u01689\3")
        buf.write("\2\2\2\u0169\u016b\58\35\2\u016a\u0169\3\2\2\2\u016a\u016b")
        buf.write("\3\2\2\2\u016b\u016c\3\2\2\2\u016c\u017e\5<\37\2\u016d")
        buf.write("\u016f\7\63\2\2\u016e\u016d\3\2\2\2\u016f\u0172\3\2\2")
        buf.write("\2\u0170\u016e\3\2\2\2\u0170\u0171\3\2\2\2\u0171\u0173")
        buf.write("\3\2\2\2\u0172\u0170\3\2\2\2\u0173\u0177\58\35\2\u0174")
        buf.write("\u0176\7\63\2\2\u0175\u0174\3\2\2\2\u0176\u0179\3\2\2")
        buf.write("\2\u0177\u0175\3\2\2\2\u0177\u0178\3\2\2\2\u0178\u017a")
        buf.write("\3\2\2\2\u0179\u0177\3\2\2\2\u017a\u017b\5<\37\2\u017b")
        buf.write("\u017d\3\2\2\2\u017c\u0170\3\2\2\2\u017d\u0180\3\2\2\2")
        buf.write("\u017e\u017c\3\2\2\2\u017e\u017f\3\2\2\2\u017f;\3\2\2")
        buf.write("\2\u0180\u017e\3\2\2\2\u0181\u0182\5> \2\u0182\u0183\7")
        buf.write("\63\2\2\u0183\u0184\5\4\3\2\u0184\u0187\7\63\2\2\u0185")
        buf.write("\u0188\5\60\31\2\u0186\u0188\5> \2\u0187\u0185\3\2\2\2")
        buf.write("\u0187\u0186\3\2\2\2\u0188=\3\2\2\2\u0189\u018a\5&\24")
        buf.write("\2\u018a\u018b\7\n\2\2\u018b\u018c\5@!\2\u018c?\3\2\2")
        buf.write("\2\u018d\u0197\5\2\2\2\u018e\u0190\7\20\2\2\u018f\u0191")
        buf.write("\7\61\2\2\u0190\u018f\3\2\2\2\u0191\u0192\3\2\2\2\u0192")
        buf.write("\u0190\3\2\2\2\u0192\u0193\3\2\2\2\u0193\u0194\3\2\2\2")
        buf.write("\u0194\u0197\7\17\2\2\u0195\u0197\7\n\2\2\u0196\u018d")
        buf.write("\3\2\2\2\u0196\u018e\3\2\2\2\u0196\u0195\3\2\2\2\u0197")
        buf.write("\u0198\3\2\2\2\u0198\u0196\3\2\2\2\u0198\u0199\3\2\2\2")
        buf.write("\u0199A\3\2\2\2\u019a\u01a3\5D#\2\u019b\u019f\7\13\2\2")
        buf.write("\u019c\u019d\7\13\2\2\u019d\u019f\7\63\2\2\u019e\u019b")
        buf.write("\3\2\2\2\u019e\u019c\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0")
        buf.write("\u01a2\5D#\2\u01a1\u019e\3\2\2\2\u01a2\u01a5\3\2\2\2\u01a3")
        buf.write("\u01a1\3\2\2\2\u01a3\u01a4\3\2\2\2\u01a4C\3\2\2\2\u01a5")
        buf.write("\u01a3\3\2\2\2\u01a6\u01a9\5\2\2\2\u01a7\u01a9\7\f\2\2")
        buf.write("\u01a8\u01a6\3\2\2\2\u01a8\u01a7\3\2\2\2\u01a9\u01aa\3")
        buf.write("\2\2\2\u01aa\u01a8\3\2\2\2\u01aa\u01ab\3\2\2\2\u01abE")
        buf.write("\3\2\2\2\u01ac\u01ad\5H%\2\u01ad\u01ae\7\16\2\2\u01ae")
        buf.write("\u01af\5J&\2\u01af\u01b0\7\r\2\2\u01b0G\3\2\2\2\u01b1")
        buf.write("\u01b2\7\62\2\2\u01b2I\3\2\2\2\u01b3\u01bc\5L\'\2\u01b4")
        buf.write("\u01b8\7\13\2\2\u01b5\u01b6\7\13\2\2\u01b6\u01b8\7\63")
        buf.write("\2\2\u01b7\u01b4\3\2\2\2\u01b7\u01b5\3\2\2\2\u01b8\u01b9")
        buf.write("\3\2\2\2\u01b9\u01bb\5L\'\2\u01ba\u01b7\3\2\2\2\u01bb")
        buf.write("\u01be\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bc\u01bd\3\2\2\2")
        buf.write("\u01bdK\3\2\2\2\u01be\u01bc\3\2\2\2\u01bf\u01c0\5\2\2")
        buf.write("\2\u01c0M\3\2\2\2\u01c1\u01ca\5P)\2\u01c2\u01c6\7\13\2")
        buf.write("\2\u01c3\u01c4\7\13\2\2\u01c4\u01c6\7\63\2\2\u01c5\u01c2")
        buf.write("\3\2\2\2\u01c5\u01c3\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7")
        buf.write("\u01c9\5P)\2\u01c8\u01c5\3\2\2\2\u01c9\u01cc\3\2\2\2\u01ca")
        buf.write("\u01c8\3\2\2\2\u01ca\u01cb\3\2\2\2\u01cbO\3\2\2\2\u01cc")
        buf.write("\u01ca\3\2\2\2\u01cd\u01ce\5R*\2\u01ce\u01cf\7\63\2\2")
        buf.write("\u01cf\u01d0\5\4\3\2\u01d0\u01d1\7\63\2\2\u01d1\u01d2")
        buf.write("\5T+\2\u01d2Q\3\2\2\2\u01d3\u01d4\7\62\2\2\u01d4S\3\2")
        buf.write("\2\2\u01d5\u01d6\5\60\31\2\u01d6U\3\2\2\2\u01d7\u01d8")
        buf.write("\5X-\2\u01d8W\3\2\2\2\u01d9\u01e2\5Z.\2\u01da\u01de\7")
        buf.write("\13\2\2\u01db\u01dc\7\13\2\2\u01dc\u01de\7\63\2\2\u01dd")
        buf.write("\u01da\3\2\2\2\u01dd\u01db\3\2\2\2\u01de\u01df\3\2\2\2")
        buf.write("\u01df\u01e1\5Z.\2\u01e0\u01dd\3\2\2\2\u01e1\u01e4\3\2")
        buf.write("\2\2\u01e2\u01e0\3\2\2\2\u01e2\u01e3\3\2\2\2\u01e3Y\3")
        buf.write("\2\2\2\u01e4\u01e2\3\2\2\2\u01e5\u01e8\5\2\2\2\u01e6\u01e7")
        buf.write("\7\n\2\2\u01e7\u01e9\5\2\2\2\u01e8\u01e6\3\2\2\2\u01e8")
        buf.write("\u01e9\3\2\2\2\u01e9\u01ed\3\2\2\2\u01ea\u01ed\7\f\2\2")
        buf.write("\u01eb\u01ed\5\\/\2\u01ec\u01e5\3\2\2\2\u01ec\u01ea\3")
        buf.write("\2\2\2\u01ec\u01eb\3\2\2\2\u01ed\u01ee\3\2\2\2\u01ee\u01ec")
        buf.write("\3\2\2\2\u01ee\u01ef\3\2\2\2\u01ef\u01f6\3\2\2\2\u01f0")
        buf.write("\u01f3\5\2\2\2\u01f1\u01f3\7\63\2\2\u01f2\u01f0\3\2\2")
        buf.write("\2\u01f2\u01f1\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4\u01f2")
        buf.write("\3\2\2\2\u01f4\u01f5\3\2\2\2\u01f5\u01f7\3\2\2\2\u01f6")
        buf.write("\u01f2\3\2\2\2\u01f6\u01f7\3\2\2\2\u01f7[\3\2\2\2\u01f8")
        buf.write("\u01f9\5\2\2\2\u01f9\u01fc\7\16\2\2\u01fa\u01fd\5Z.\2")
        buf.write("\u01fb\u01fd\7\63\2\2\u01fc\u01fa\3\2\2\2\u01fc\u01fb")
        buf.write("\3\2\2\2\u01fd\u01fe\3\2\2\2\u01fe\u01fc\3\2\2\2\u01fe")
        buf.write("\u01ff\3\2\2\2\u01ff\u0200\3\2\2\2\u0200\u0201\7\r\2\2")
        buf.write("\u0201]\3\2\2\2Bah{\u0088\u008f\u009e\u00aa\u00af\u00b7")
        buf.write("\u00bc\u00be\u00c6\u00ce\u00d4\u00db\u00de\u00e3\u00ea")
        buf.write("\u00ee\u00f3\u00f8\u00fb\u00ff\u0106\u010a\u0116\u011a")
        buf.write("\u011f\u0123\u012f\u0138\u013b\u0140\u0146\u0153\u0159")
        buf.write("\u0160\u0165\u016a\u0170\u0177\u017e\u0187\u0192\u0196")
        buf.write("\u0198\u019e\u01a3\u01a8\u01aa\u01b7\u01bc\u01c5\u01ca")
        buf.write("\u01dd\u01e2\u01e8\u01ec\u01ee\u01f2\u01f4\u01f6\u01fc")
        buf.write("\u01fe")
        return buf.getvalue()


class GnosisEPLParser ( Parser ):

    grammarFileName = "GnosisEPL.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<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>", "SEMI", "COLON", "DOT", 
                      "COMMA", "ASTERISK", "RPAREN", "LPAREN", "RBRACK", 
                      "LBRACK", "RCURLY", "LCURLY", "PLUS", "NEGATION", 
                      "VERTBAR", "BITAND", "POWER_OP", "GTH", "GTHE", "LTH", 
                      "LTHE", "EQUAL", "DIFFERENT", "UNDERSCORE", "REGISTER", 
                      "QUERY", "OUTPUT", "CONTENT", "SELECT", "MATCH", "LEFT", 
                      "RIGHT", "BACK", "FRONT", "AND", "OR", "FROM", "WHERE", 
                      "WITHIN", "WITH_QOS", "RETURN", "OPTIONAL", "NUMBER", 
                      "WORD", "WHITESPACE", "NEWLINE", "EVERYTHING" ]

    RULE_alphanumeric = 0
    RULE_comparison_operator = 1
    RULE_query = 2
    RULE_subcription = 3
    RULE_query_name = 4
    RULE_output_list = 5
    RULE_output = 6
    RULE_separator = 7
    RULE_content = 8
    RULE_content_service = 9
    RULE_match_clause = 10
    RULE_relationship = 11
    RULE_relationship_ref_with_class = 12
    RULE_relationship_ref_middle = 13
    RULE_relationship_type = 14
    RULE_left_object = 15
    RULE_right_object = 16
    RULE_object_ref_with_class = 17
    RULE_object_class = 18
    RULE_object_ref = 19
    RULE_attributes = 20
    RULE_attribute = 21
    RULE_attribute_name = 22
    RULE_attribute_value = 23
    RULE_attribute_value_str = 24
    RULE_attribute_value_str_inner = 25
    RULE_attribute_value_num = 26
    RULE_logical_operator = 27
    RULE_where_clause = 28
    RULE_where_logical_op_set = 29
    RULE_where_attribute = 30
    RULE_where_attribute_name = 31
    RULE_publisher_list = 32
    RULE_publisher = 33
    RULE_window = 34
    RULE_window_type = 35
    RULE_window_arg_list = 36
    RULE_window_arg = 37
    RULE_qos_metric_list = 38
    RULE_qos_metric = 39
    RULE_qos_metric_name = 40
    RULE_qos_metric_value = 41
    RULE_return_clause = 42
    RULE_node_list = 43
    RULE_node = 44
    RULE_aggregator = 45

    ruleNames =  [ "alphanumeric", "comparison_operator", "query", "subcription", 
                   "query_name", "output_list", "output", "separator", "content", 
                   "content_service", "match_clause", "relationship", "relationship_ref_with_class", 
                   "relationship_ref_middle", "relationship_type", "left_object", 
                   "right_object", "object_ref_with_class", "object_class", 
                   "object_ref", "attributes", "attribute", "attribute_name", 
                   "attribute_value", "attribute_value_str", "attribute_value_str_inner", 
                   "attribute_value_num", "logical_operator", "where_clause", 
                   "where_logical_op_set", "where_attribute", "where_attribute_name", 
                   "publisher_list", "publisher", "window", "window_type", 
                   "window_arg_list", "window_arg", "qos_metric_list", "qos_metric", 
                   "qos_metric_name", "qos_metric_value", "return_clause", 
                   "node_list", "node", "aggregator" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    SEMI=6
    COLON=7
    DOT=8
    COMMA=9
    ASTERISK=10
    RPAREN=11
    LPAREN=12
    RBRACK=13
    LBRACK=14
    RCURLY=15
    LCURLY=16
    PLUS=17
    NEGATION=18
    VERTBAR=19
    BITAND=20
    POWER_OP=21
    GTH=22
    GTHE=23
    LTH=24
    LTHE=25
    EQUAL=26
    DIFFERENT=27
    UNDERSCORE=28
    REGISTER=29
    QUERY=30
    OUTPUT=31
    CONTENT=32
    SELECT=33
    MATCH=34
    LEFT=35
    RIGHT=36
    BACK=37
    FRONT=38
    AND=39
    OR=40
    FROM=41
    WHERE=42
    WITHIN=43
    WITH_QOS=44
    RETURN=45
    OPTIONAL=46
    NUMBER=47
    WORD=48
    WHITESPACE=49
    NEWLINE=50
    EVERYTHING=51

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




    class AlphanumericContext(ParserRuleContext):

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

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

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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_alphanumeric

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

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




    def alphanumeric(self):

        localctx = GnosisEPLParser.AlphanumericContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_alphanumeric)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 93 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 92
                    _la = self._input.LA(1)
                    if not(_la==GnosisEPLParser.NUMBER or _la==GnosisEPLParser.WORD):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()

                else:
                    raise NoViableAltException(self)
                self.state = 95 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,0,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 Comparison_operatorContext(ParserRuleContext):

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

        def EQUAL(self):
            return self.getToken(GnosisEPLParser.EQUAL, 0)

        def DIFFERENT(self):
            return self.getToken(GnosisEPLParser.DIFFERENT, 0)

        def GTH(self):
            return self.getToken(GnosisEPLParser.GTH, 0)

        def GTHE(self):
            return self.getToken(GnosisEPLParser.GTHE, 0)

        def LTH(self):
            return self.getToken(GnosisEPLParser.LTH, 0)

        def LTHE(self):
            return self.getToken(GnosisEPLParser.LTHE, 0)

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_comparison_operator

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

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




    def comparison_operator(self):

        localctx = GnosisEPLParser.Comparison_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_comparison_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 97
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GnosisEPLParser.GTH) | (1 << GnosisEPLParser.GTHE) | (1 << GnosisEPLParser.LTH) | (1 << GnosisEPLParser.LTHE) | (1 << GnosisEPLParser.EQUAL) | (1 << GnosisEPLParser.DIFFERENT))) != 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 QueryContext(ParserRuleContext):

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

        def EOF(self):
            return self.getToken(GnosisEPLParser.EOF, 0)

        def subcription(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.SubcriptionContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.SubcriptionContext,i)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_query

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

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




    def query(self):

        localctx = GnosisEPLParser.QueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_query)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 100 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 99
                self.subcription()
                self.state = 102 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==GnosisEPLParser.REGISTER):
                    break

            self.state = 104
            self.match(GnosisEPLParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SubcriptionContext(ParserRuleContext):

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

        def REGISTER(self):
            return self.getToken(GnosisEPLParser.REGISTER, 0)

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

        def QUERY(self):
            return self.getToken(GnosisEPLParser.QUERY, 0)

        def query_name(self):
            return self.getTypedRuleContext(GnosisEPLParser.Query_nameContext,0)


        def separator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.SeparatorContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.SeparatorContext,i)


        def OUTPUT(self):
            return self.getToken(GnosisEPLParser.OUTPUT, 0)

        def output_list(self):
            return self.getTypedRuleContext(GnosisEPLParser.Output_listContext,0)


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

        def match_clause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.Match_clauseContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.Match_clauseContext,i)


        def FROM(self):
            return self.getToken(GnosisEPLParser.FROM, 0)

        def publisher_list(self):
            return self.getTypedRuleContext(GnosisEPLParser.Publisher_listContext,0)


        def WITHIN(self):
            return self.getToken(GnosisEPLParser.WITHIN, 0)

        def window(self):
            return self.getTypedRuleContext(GnosisEPLParser.WindowContext,0)


        def RETURN(self):
            return self.getToken(GnosisEPLParser.RETURN, 0)

        def return_clause(self):
            return self.getTypedRuleContext(GnosisEPLParser.Return_clauseContext,0)


        def CONTENT(self):
            return self.getToken(GnosisEPLParser.CONTENT, 0)

        def content(self):
            return self.getTypedRuleContext(GnosisEPLParser.ContentContext,0)


        def OPTIONAL(self):
            return self.getToken(GnosisEPLParser.OPTIONAL, 0)

        def WHERE(self):
            return self.getToken(GnosisEPLParser.WHERE, 0)

        def where_clause(self):
            return self.getTypedRuleContext(GnosisEPLParser.Where_clauseContext,0)


        def WITH_QOS(self):
            return self.getToken(GnosisEPLParser.WITH_QOS, 0)

        def qos_metric_list(self):
            return self.getTypedRuleContext(GnosisEPLParser.Qos_metric_listContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_subcription

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

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




    def subcription(self):

        localctx = GnosisEPLParser.SubcriptionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_subcription)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 106
            self.match(GnosisEPLParser.REGISTER)
            self.state = 107
            self.match(GnosisEPLParser.WHITESPACE)
            self.state = 108
            self.match(GnosisEPLParser.QUERY)
            self.state = 109
            self.match(GnosisEPLParser.WHITESPACE)
            self.state = 110
            self.query_name()
            self.state = 111
            self.separator()
            self.state = 112
            self.match(GnosisEPLParser.OUTPUT)
            self.state = 113
            self.match(GnosisEPLParser.WHITESPACE)
            self.state = 114
            self.output_list()
            self.state = 115
            self.separator()
            self.state = 121
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GnosisEPLParser.CONTENT:
                self.state = 116
                self.match(GnosisEPLParser.CONTENT)
                self.state = 117
                self.match(GnosisEPLParser.WHITESPACE)
                self.state = 118
                self.content()
                self.state = 119
                self.separator()


            self.state = 123
            self.match(GnosisEPLParser.MATCH)
            self.state = 124
            self.match(GnosisEPLParser.WHITESPACE)
            self.state = 125
            self.match_clause()
            self.state = 126
            self.separator()
            self.state = 134
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GnosisEPLParser.OPTIONAL:
                self.state = 127
                self.match(GnosisEPLParser.OPTIONAL)
                self.state = 128
                self.match(GnosisEPLParser.WHITESPACE)
                self.state = 129
                self.match(GnosisEPLParser.MATCH)
                self.state = 130
                self.match(GnosisEPLParser.WHITESPACE)
                self.state = 131
                self.match_clause()
                self.state = 132
                self.separator()


            self.state = 141
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GnosisEPLParser.WHERE:
                self.state = 136
                self.match(GnosisEPLParser.WHERE)
                self.state = 137
                self.match(GnosisEPLParser.WHITESPACE)
                self.state = 138
                self.where_clause()
                self.state = 139
                self.separator()


            self.state = 143
            self.match(GnosisEPLParser.FROM)
            self.state = 144
            self.match(GnosisEPLParser.WHITESPACE)
            self.state = 145
            self.publisher_list()
            self.state = 146
            self.separator()
            self.state = 147
            self.match(GnosisEPLParser.WITHIN)
            self.state = 148
            self.match(GnosisEPLParser.WHITESPACE)
            self.state = 149
            self.window()
            self.state = 150
            self.separator()
            self.state = 156
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GnosisEPLParser.WITH_QOS:
                self.state = 151
                self.match(GnosisEPLParser.WITH_QOS)
                self.state = 152
                self.match(GnosisEPLParser.WHITESPACE)
                self.state = 153
                self.qos_metric_list()
                self.state = 154
                self.separator()


            self.state = 158
            self.match(GnosisEPLParser.RETURN)
            self.state = 159
            self.match(GnosisEPLParser.WHITESPACE)
            self.state = 160
            self.return_clause()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Query_nameContext(ParserRuleContext):

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

        def alphanumeric(self):
            return self.getTypedRuleContext(GnosisEPLParser.AlphanumericContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_query_name

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

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




    def query_name(self):

        localctx = GnosisEPLParser.Query_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_query_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 162
            self.alphanumeric()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Output_listContext(ParserRuleContext):

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

        def output(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.OutputContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.OutputContext,i)


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

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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_output_list

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

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




    def output_list(self):

        localctx = GnosisEPLParser.Output_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_output_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 164
            self.output()
            self.state = 173
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GnosisEPLParser.COMMA:
                self.state = 168
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
                if la_ == 1:
                    self.state = 165
                    self.match(GnosisEPLParser.COMMA)
                    pass

                elif la_ == 2:
                    self.state = 166
                    self.match(GnosisEPLParser.COMMA)
                    self.state = 167
                    self.match(GnosisEPLParser.WHITESPACE)
                    pass


                self.state = 170
                self.output()
                self.state = 175
                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 OutputContext(ParserRuleContext):

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

        def alphanumeric(self):
            return self.getTypedRuleContext(GnosisEPLParser.AlphanumericContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_output

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

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




    def output(self):

        localctx = GnosisEPLParser.OutputContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_output)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 176
            self.alphanumeric()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SeparatorContext(ParserRuleContext):

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

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

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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_separator

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

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




    def separator(self):

        localctx = GnosisEPLParser.SeparatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_separator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 179 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 178
                _la = self._input.LA(1)
                if not(_la==GnosisEPLParser.WHITESPACE or _la==GnosisEPLParser.NEWLINE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 181 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==GnosisEPLParser.WHITESPACE or _la==GnosisEPLParser.NEWLINE):
                    break

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


    class ContentContext(ParserRuleContext):

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

        def content_service(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.Content_serviceContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.Content_serviceContext,i)


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

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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_content

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

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




    def content(self):

        localctx = GnosisEPLParser.ContentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_content)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 186 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 186
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [GnosisEPLParser.WORD]:
                        self.state = 183
                        self.content_service()
                        pass
                    elif token in [GnosisEPLParser.COMMA]:
                        self.state = 184
                        self.match(GnosisEPLParser.COMMA)
                        pass
                    elif token in [GnosisEPLParser.WHITESPACE]:
                        self.state = 185
                        self.match(GnosisEPLParser.WHITESPACE)
                        pass
                    else:
                        raise NoViableAltException(self)


                else:
                    raise NoViableAltException(self)
                self.state = 188 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,10,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 Content_serviceContext(ParserRuleContext):

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

        def WORD(self):
            return self.getToken(GnosisEPLParser.WORD, 0)

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_content_service

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

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




    def content_service(self):

        localctx = GnosisEPLParser.Content_serviceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_content_service)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 190
            self.match(GnosisEPLParser.WORD)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Match_clauseContext(ParserRuleContext):

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

        def relationship(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.RelationshipContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.RelationshipContext,i)


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

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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_match_clause

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

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




    def match_clause(self):

        localctx = GnosisEPLParser.Match_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_match_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 192
            self.relationship()
            self.state = 225
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,16,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 220
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
                    if la_ == 1:
                        self.state = 196
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==GnosisEPLParser.WHITESPACE:
                            self.state = 193
                            self.match(GnosisEPLParser.WHITESPACE)
                            self.state = 198
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 199
                        self.match(GnosisEPLParser.COMMA)
                        pass

                    elif la_ == 2:
                        self.state = 200
                        self.match(GnosisEPLParser.COMMA)
                        self.state = 204
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==GnosisEPLParser.WHITESPACE:
                            self.state = 201
                            self.match(GnosisEPLParser.WHITESPACE)
                            self.state = 206
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        pass

                    elif la_ == 3:
                        self.state = 210
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==GnosisEPLParser.WHITESPACE:
                            self.state = 207
                            self.match(GnosisEPLParser.WHITESPACE)
                            self.state = 212
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 213
                        self.match(GnosisEPLParser.COMMA)
                        self.state = 217
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==GnosisEPLParser.WHITESPACE:
                            self.state = 214
                            self.match(GnosisEPLParser.WHITESPACE)
                            self.state = 219
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        pass


                    self.state = 222
                    self.relationship() 
                self.state = 227
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,16,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 RelationshipContext(ParserRuleContext):

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

        def left_object(self):
            return self.getTypedRuleContext(GnosisEPLParser.Left_objectContext,0)


        def relationship_ref_with_class(self):
            return self.getTypedRuleContext(GnosisEPLParser.Relationship_ref_with_classContext,0)


        def relationship(self):
            return self.getTypedRuleContext(GnosisEPLParser.RelationshipContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_relationship

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

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




    def relationship(self):

        localctx = GnosisEPLParser.RelationshipContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_relationship)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 228
            self.left_object()
            self.state = 232
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GnosisEPLParser.T__0 or _la==GnosisEPLParser.T__2:
                self.state = 229
                self.relationship_ref_with_class()
                self.state = 230
                self.relationship()


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


    class Relationship_ref_with_classContext(ParserRuleContext):

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

        def relationship_ref_middle(self):
            return self.getTypedRuleContext(GnosisEPLParser.Relationship_ref_middleContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_relationship_ref_with_class

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

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




    def relationship_ref_with_class(self):

        localctx = GnosisEPLParser.Relationship_ref_with_classContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_relationship_ref_with_class)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 249
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
            if la_ == 1:
                self.state = 234
                self.match(GnosisEPLParser.T__0)
                self.state = 236
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GnosisEPLParser.LBRACK:
                    self.state = 235
                    self.relationship_ref_middle()


                self.state = 238
                self.match(GnosisEPLParser.T__1)
                pass

            elif la_ == 2:
                self.state = 239
                self.match(GnosisEPLParser.T__0)
                self.state = 241
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GnosisEPLParser.LBRACK:
                    self.state = 240
                    self.relationship_ref_middle()


                self.state = 243
                self.match(GnosisEPLParser.T__0)
                pass

            elif la_ == 3:
                self.state = 244
                self.match(GnosisEPLParser.T__2)
                self.state = 246
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GnosisEPLParser.LBRACK:
                    self.state = 245
                    self.relationship_ref_middle()


                self.state = 248
                self.match(GnosisEPLParser.T__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 Relationship_ref_middleContext(ParserRuleContext):

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

        def LBRACK(self):
            return self.getToken(GnosisEPLParser.LBRACK, 0)

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

        def relationship_type(self):
            return self.getTypedRuleContext(GnosisEPLParser.Relationship_typeContext,0)


        def RBRACK(self):
            return self.getToken(GnosisEPLParser.RBRACK, 0)

        def object_ref(self):
            return self.getTypedRuleContext(GnosisEPLParser.Object_refContext,0)


        def attributes(self):
            return self.getTypedRuleContext(GnosisEPLParser.AttributesContext,0)


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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_relationship_ref_middle

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

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




    def relationship_ref_middle(self):

        localctx = GnosisEPLParser.Relationship_ref_middleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_relationship_ref_middle)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 251
            self.match(GnosisEPLParser.LBRACK)
            self.state = 253
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GnosisEPLParser.NUMBER or _la==GnosisEPLParser.WORD:
                self.state = 252
                self.object_ref()


            self.state = 255
            self.match(GnosisEPLParser.COLON)
            self.state = 256
            self.relationship_type()
            self.state = 264
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GnosisEPLParser.LCURLY or _la==GnosisEPLParser.WHITESPACE:
                self.state = 260
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==GnosisEPLParser.WHITESPACE:
                    self.state = 257
                    self.match(GnosisEPLParser.WHITESPACE)
                    self.state = 262
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 263
                self.attributes()


            self.state = 266
            self.match(GnosisEPLParser.RBRACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Relationship_typeContext(ParserRuleContext):

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

        def alphanumeric(self):
            return self.getTypedRuleContext(GnosisEPLParser.AlphanumericContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_relationship_type

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

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




    def relationship_type(self):

        localctx = GnosisEPLParser.Relationship_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_relationship_type)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 268
            self.alphanumeric()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Left_objectContext(ParserRuleContext):

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

        def object_ref_with_class(self):
            return self.getTypedRuleContext(GnosisEPLParser.Object_ref_with_classContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_left_object

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

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




    def left_object(self):

        localctx = GnosisEPLParser.Left_objectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_left_object)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 270
            self.object_ref_with_class()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Right_objectContext(ParserRuleContext):

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

        def object_ref_with_class(self):
            return self.getTypedRuleContext(GnosisEPLParser.Object_ref_with_classContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_right_object

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

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




    def right_object(self):

        localctx = GnosisEPLParser.Right_objectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_right_object)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 272
            self.object_ref_with_class()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Object_ref_with_classContext(ParserRuleContext):

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

        def LPAREN(self):
            return self.getToken(GnosisEPLParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(GnosisEPLParser.RPAREN, 0)

        def object_ref(self):
            return self.getTypedRuleContext(GnosisEPLParser.Object_refContext,0)


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

        def object_class(self):
            return self.getTypedRuleContext(GnosisEPLParser.Object_classContext,0)


        def attributes(self):
            return self.getTypedRuleContext(GnosisEPLParser.AttributesContext,0)


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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_object_ref_with_class

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

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




    def object_ref_with_class(self):

        localctx = GnosisEPLParser.Object_ref_with_classContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_object_ref_with_class)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 274
            self.match(GnosisEPLParser.LPAREN)
            self.state = 276
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GnosisEPLParser.NUMBER or _la==GnosisEPLParser.WORD:
                self.state = 275
                self.object_ref()


            self.state = 280
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GnosisEPLParser.COLON:
                self.state = 278
                self.match(GnosisEPLParser.COLON)
                self.state = 279
                self.object_class()


            self.state = 289
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GnosisEPLParser.LCURLY or _la==GnosisEPLParser.WHITESPACE:
                self.state = 285
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==GnosisEPLParser.WHITESPACE:
                    self.state = 282
                    self.match(GnosisEPLParser.WHITESPACE)
                    self.state = 287
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 288
                self.attributes()


            self.state = 291
            self.match(GnosisEPLParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Object_classContext(ParserRuleContext):

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

        def alphanumeric(self):
            return self.getTypedRuleContext(GnosisEPLParser.AlphanumericContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_object_class

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

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




    def object_class(self):

        localctx = GnosisEPLParser.Object_classContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_object_class)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 293
            self.alphanumeric()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Object_refContext(ParserRuleContext):

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

        def alphanumeric(self):
            return self.getTypedRuleContext(GnosisEPLParser.AlphanumericContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_object_ref

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

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




    def object_ref(self):

        localctx = GnosisEPLParser.Object_refContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_object_ref)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 295
            self.alphanumeric()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributesContext(ParserRuleContext):

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

        def LCURLY(self):
            return self.getToken(GnosisEPLParser.LCURLY, 0)

        def attribute(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.AttributeContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.AttributeContext,i)


        def RCURLY(self):
            return self.getToken(GnosisEPLParser.RCURLY, 0)

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

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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_attributes

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

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




    def attributes(self):

        localctx = GnosisEPLParser.AttributesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_attributes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 297
            self.match(GnosisEPLParser.LCURLY)
            self.state = 301
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GnosisEPLParser.WHITESPACE:
                self.state = 298
                self.match(GnosisEPLParser.WHITESPACE)
                self.state = 303
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 304
            self.attribute()
            self.state = 318
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GnosisEPLParser.COMMA:
                self.state = 313
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
                if la_ == 1:
                    self.state = 305
                    self.match(GnosisEPLParser.COMMA)
                    pass

                elif la_ == 2:
                    self.state = 306
                    self.match(GnosisEPLParser.COMMA)
                    self.state = 310
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==GnosisEPLParser.WHITESPACE:
                        self.state = 307
                        self.match(GnosisEPLParser.WHITESPACE)
                        self.state = 312
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass


                self.state = 315
                self.attribute()
                self.state = 320
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 324
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GnosisEPLParser.WHITESPACE:
                self.state = 321
                self.match(GnosisEPLParser.WHITESPACE)
                self.state = 326
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 327
            self.match(GnosisEPLParser.RCURLY)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeContext(ParserRuleContext):

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

        def attribute_name(self):
            return self.getTypedRuleContext(GnosisEPLParser.Attribute_nameContext,0)


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

        def attribute_value(self):
            return self.getTypedRuleContext(GnosisEPLParser.Attribute_valueContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_attribute

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

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




    def attribute(self):

        localctx = GnosisEPLParser.AttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_attribute)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 329
            self.attribute_name()
            self.state = 330
            self.match(GnosisEPLParser.COLON)
            self.state = 331
            self.attribute_value()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Attribute_nameContext(ParserRuleContext):

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

        def alphanumeric(self):
            return self.getTypedRuleContext(GnosisEPLParser.AlphanumericContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_attribute_name

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

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




    def attribute_name(self):

        localctx = GnosisEPLParser.Attribute_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_attribute_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 333
            self.alphanumeric()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Attribute_valueContext(ParserRuleContext):

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

        def attribute_value_str(self):
            return self.getTypedRuleContext(GnosisEPLParser.Attribute_value_strContext,0)


        def attribute_value_num(self):
            return self.getTypedRuleContext(GnosisEPLParser.Attribute_value_numContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_attribute_value

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

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




    def attribute_value(self):

        localctx = GnosisEPLParser.Attribute_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_attribute_value)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 337
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [GnosisEPLParser.T__3, GnosisEPLParser.T__4]:
                self.state = 335
                self.attribute_value_str()
                pass
            elif token in [GnosisEPLParser.NUMBER]:
                self.state = 336
                self.attribute_value_num()
                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 Attribute_value_strContext(ParserRuleContext):

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

        def attribute_value_str_inner(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.Attribute_value_str_innerContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.Attribute_value_str_innerContext,i)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_attribute_value_str

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

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




    def attribute_value_str(self):

        localctx = GnosisEPLParser.Attribute_value_strContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_attribute_value_str)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 339
            _la = self._input.LA(1)
            if not(_la==GnosisEPLParser.T__3 or _la==GnosisEPLParser.T__4):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 343
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GnosisEPLParser.NUMBER) | (1 << GnosisEPLParser.WORD) | (1 << GnosisEPLParser.WHITESPACE))) != 0):
                self.state = 340
                self.attribute_value_str_inner()
                self.state = 345
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 346
            _la = self._input.LA(1)
            if not(_la==GnosisEPLParser.T__3 or _la==GnosisEPLParser.T__4):
                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 Attribute_value_str_innerContext(ParserRuleContext):

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

        def alphanumeric(self):
            return self.getTypedRuleContext(GnosisEPLParser.AlphanumericContext,0)


        def WHITESPACE(self):
            return self.getToken(GnosisEPLParser.WHITESPACE, 0)

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_attribute_value_str_inner

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

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




    def attribute_value_str_inner(self):

        localctx = GnosisEPLParser.Attribute_value_str_innerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_attribute_value_str_inner)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 350
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [GnosisEPLParser.NUMBER, GnosisEPLParser.WORD]:
                self.state = 348
                self.alphanumeric()
                pass
            elif token in [GnosisEPLParser.WHITESPACE]:
                self.state = 349
                self.match(GnosisEPLParser.WHITESPACE)
                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 Attribute_value_numContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_attribute_value_num

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

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




    def attribute_value_num(self):

        localctx = GnosisEPLParser.Attribute_value_numContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_attribute_value_num)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 353 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 352
                self.match(GnosisEPLParser.NUMBER)
                self.state = 355 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==GnosisEPLParser.NUMBER):
                    break

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


    class Logical_operatorContext(ParserRuleContext):

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

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

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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_logical_operator

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

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




    def logical_operator(self):

        localctx = GnosisEPLParser.Logical_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_logical_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 357
            _la = self._input.LA(1)
            if not(_la==GnosisEPLParser.AND or _la==GnosisEPLParser.OR):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Where_clauseContext(ParserRuleContext):

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

        def where_logical_op_set(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.Where_logical_op_setContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.Where_logical_op_setContext,i)


        def logical_operator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.Logical_operatorContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.Logical_operatorContext,i)


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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_where_clause

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

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




    def where_clause(self):

        localctx = GnosisEPLParser.Where_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_where_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 360
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GnosisEPLParser.AND or _la==GnosisEPLParser.OR:
                self.state = 359
                self.logical_operator()


            self.state = 362
            self.where_logical_op_set()
            self.state = 380
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,41,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 366
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==GnosisEPLParser.WHITESPACE:
                        self.state = 363
                        self.match(GnosisEPLParser.WHITESPACE)
                        self.state = 368
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 369
                    self.logical_operator()
                    self.state = 373
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==GnosisEPLParser.WHITESPACE:
                        self.state = 370
                        self.match(GnosisEPLParser.WHITESPACE)
                        self.state = 375
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 376
                    self.where_logical_op_set() 
                self.state = 382
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,41,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 Where_logical_op_setContext(ParserRuleContext):

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

        def where_attribute(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.Where_attributeContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.Where_attributeContext,i)


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

        def comparison_operator(self):
            return self.getTypedRuleContext(GnosisEPLParser.Comparison_operatorContext,0)


        def attribute_value(self):
            return self.getTypedRuleContext(GnosisEPLParser.Attribute_valueContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_where_logical_op_set

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

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




    def where_logical_op_set(self):

        localctx = GnosisEPLParser.Where_logical_op_setContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_where_logical_op_set)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 383
            self.where_attribute()
            self.state = 384
            self.match(GnosisEPLParser.WHITESPACE)
            self.state = 385
            self.comparison_operator()
            self.state = 386
            self.match(GnosisEPLParser.WHITESPACE)
            self.state = 389
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
            if la_ == 1:
                self.state = 387
                self.attribute_value()
                pass

            elif la_ == 2:
                self.state = 388
                self.where_attribute()
                pass


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


    class Where_attributeContext(ParserRuleContext):

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

        def object_class(self):
            return self.getTypedRuleContext(GnosisEPLParser.Object_classContext,0)


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

        def where_attribute_name(self):
            return self.getTypedRuleContext(GnosisEPLParser.Where_attribute_nameContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_where_attribute

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

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




    def where_attribute(self):

        localctx = GnosisEPLParser.Where_attributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_where_attribute)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 391
            self.object_class()
            self.state = 392
            self.match(GnosisEPLParser.DOT)
            self.state = 393
            self.where_attribute_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Where_attribute_nameContext(ParserRuleContext):

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

        def alphanumeric(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.AlphanumericContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.AlphanumericContext,i)


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

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

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

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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_where_attribute_name

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

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




    def where_attribute_name(self):

        localctx = GnosisEPLParser.Where_attribute_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_where_attribute_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 404 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 404
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [GnosisEPLParser.NUMBER, GnosisEPLParser.WORD]:
                    self.state = 395
                    self.alphanumeric()
                    pass
                elif token in [GnosisEPLParser.LBRACK]:
                    self.state = 396
                    self.match(GnosisEPLParser.LBRACK)
                    self.state = 398 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 397
                        self.match(GnosisEPLParser.NUMBER)
                        self.state = 400 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not (_la==GnosisEPLParser.NUMBER):
                            break

                    self.state = 402
                    self.match(GnosisEPLParser.RBRACK)
                    pass
                elif token in [GnosisEPLParser.DOT]:
                    self.state = 403
                    self.match(GnosisEPLParser.DOT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 406 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GnosisEPLParser.DOT) | (1 << GnosisEPLParser.LBRACK) | (1 << GnosisEPLParser.NUMBER) | (1 << GnosisEPLParser.WORD))) != 0)):
                    break

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


    class Publisher_listContext(ParserRuleContext):

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

        def publisher(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.PublisherContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.PublisherContext,i)


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

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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_publisher_list

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

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




    def publisher_list(self):

        localctx = GnosisEPLParser.Publisher_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_publisher_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 408
            self.publisher()
            self.state = 417
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GnosisEPLParser.COMMA:
                self.state = 412
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
                if la_ == 1:
                    self.state = 409
                    self.match(GnosisEPLParser.COMMA)
                    pass

                elif la_ == 2:
                    self.state = 410
                    self.match(GnosisEPLParser.COMMA)
                    self.state = 411
                    self.match(GnosisEPLParser.WHITESPACE)
                    pass


                self.state = 414
                self.publisher()
                self.state = 419
                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 PublisherContext(ParserRuleContext):

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

        def alphanumeric(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.AlphanumericContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.AlphanumericContext,i)


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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_publisher

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

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




    def publisher(self):

        localctx = GnosisEPLParser.PublisherContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_publisher)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 422 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 422
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [GnosisEPLParser.NUMBER, GnosisEPLParser.WORD]:
                    self.state = 420
                    self.alphanumeric()
                    pass
                elif token in [GnosisEPLParser.ASTERISK]:
                    self.state = 421
                    self.match(GnosisEPLParser.ASTERISK)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 424 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GnosisEPLParser.ASTERISK) | (1 << GnosisEPLParser.NUMBER) | (1 << GnosisEPLParser.WORD))) != 0)):
                    break

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


    class WindowContext(ParserRuleContext):

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

        def window_type(self):
            return self.getTypedRuleContext(GnosisEPLParser.Window_typeContext,0)


        def LPAREN(self):
            return self.getToken(GnosisEPLParser.LPAREN, 0)

        def window_arg_list(self):
            return self.getTypedRuleContext(GnosisEPLParser.Window_arg_listContext,0)


        def RPAREN(self):
            return self.getToken(GnosisEPLParser.RPAREN, 0)

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_window

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

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




    def window(self):

        localctx = GnosisEPLParser.WindowContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_window)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 426
            self.window_type()
            self.state = 427
            self.match(GnosisEPLParser.LPAREN)
            self.state = 428
            self.window_arg_list()
            self.state = 429
            self.match(GnosisEPLParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Window_typeContext(ParserRuleContext):

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

        def WORD(self):
            return self.getToken(GnosisEPLParser.WORD, 0)

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_window_type

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

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




    def window_type(self):

        localctx = GnosisEPLParser.Window_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_window_type)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 431
            self.match(GnosisEPLParser.WORD)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Window_arg_listContext(ParserRuleContext):

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

        def window_arg(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.Window_argContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.Window_argContext,i)


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

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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_window_arg_list

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

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




    def window_arg_list(self):

        localctx = GnosisEPLParser.Window_arg_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_window_arg_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 433
            self.window_arg()
            self.state = 442
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GnosisEPLParser.COMMA:
                self.state = 437
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
                if la_ == 1:
                    self.state = 434
                    self.match(GnosisEPLParser.COMMA)
                    pass

                elif la_ == 2:
                    self.state = 435
                    self.match(GnosisEPLParser.COMMA)
                    self.state = 436
                    self.match(GnosisEPLParser.WHITESPACE)
                    pass


                self.state = 439
                self.window_arg()
                self.state = 444
                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 Window_argContext(ParserRuleContext):

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

        def alphanumeric(self):
            return self.getTypedRuleContext(GnosisEPLParser.AlphanumericContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_window_arg

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

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




    def window_arg(self):

        localctx = GnosisEPLParser.Window_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_window_arg)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 445
            self.alphanumeric()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Qos_metric_listContext(ParserRuleContext):

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

        def qos_metric(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.Qos_metricContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.Qos_metricContext,i)


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

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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_qos_metric_list

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

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




    def qos_metric_list(self):

        localctx = GnosisEPLParser.Qos_metric_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_qos_metric_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 447
            self.qos_metric()
            self.state = 456
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GnosisEPLParser.COMMA:
                self.state = 451
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
                if la_ == 1:
                    self.state = 448
                    self.match(GnosisEPLParser.COMMA)
                    pass

                elif la_ == 2:
                    self.state = 449
                    self.match(GnosisEPLParser.COMMA)
                    self.state = 450
                    self.match(GnosisEPLParser.WHITESPACE)
                    pass


                self.state = 453
                self.qos_metric()
                self.state = 458
                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 Qos_metricContext(ParserRuleContext):

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

        def qos_metric_name(self):
            return self.getTypedRuleContext(GnosisEPLParser.Qos_metric_nameContext,0)


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

        def comparison_operator(self):
            return self.getTypedRuleContext(GnosisEPLParser.Comparison_operatorContext,0)


        def qos_metric_value(self):
            return self.getTypedRuleContext(GnosisEPLParser.Qos_metric_valueContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_qos_metric

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

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




    def qos_metric(self):

        localctx = GnosisEPLParser.Qos_metricContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_qos_metric)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 459
            self.qos_metric_name()
            self.state = 460
            self.match(GnosisEPLParser.WHITESPACE)
            self.state = 461
            self.comparison_operator()
            self.state = 462
            self.match(GnosisEPLParser.WHITESPACE)
            self.state = 463
            self.qos_metric_value()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Qos_metric_nameContext(ParserRuleContext):

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

        def WORD(self):
            return self.getToken(GnosisEPLParser.WORD, 0)

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_qos_metric_name

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

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




    def qos_metric_name(self):

        localctx = GnosisEPLParser.Qos_metric_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_qos_metric_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 465
            self.match(GnosisEPLParser.WORD)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Qos_metric_valueContext(ParserRuleContext):

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

        def attribute_value(self):
            return self.getTypedRuleContext(GnosisEPLParser.Attribute_valueContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_qos_metric_value

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

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




    def qos_metric_value(self):

        localctx = GnosisEPLParser.Qos_metric_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_qos_metric_value)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 467
            self.attribute_value()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Return_clauseContext(ParserRuleContext):

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

        def node_list(self):
            return self.getTypedRuleContext(GnosisEPLParser.Node_listContext,0)


        def getRuleIndex(self):
            return GnosisEPLParser.RULE_return_clause

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

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




    def return_clause(self):

        localctx = GnosisEPLParser.Return_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_return_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 469
            self.node_list()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Node_listContext(ParserRuleContext):

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

        def node(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.NodeContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.NodeContext,i)


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

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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_node_list

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

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




    def node_list(self):

        localctx = GnosisEPLParser.Node_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_node_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 471
            self.node()
            self.state = 480
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GnosisEPLParser.COMMA:
                self.state = 475
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
                if la_ == 1:
                    self.state = 472
                    self.match(GnosisEPLParser.COMMA)
                    pass

                elif la_ == 2:
                    self.state = 473
                    self.match(GnosisEPLParser.COMMA)
                    self.state = 474
                    self.match(GnosisEPLParser.WHITESPACE)
                    pass


                self.state = 477
                self.node()
                self.state = 482
                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 NodeContext(ParserRuleContext):

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

        def alphanumeric(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.AlphanumericContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.AlphanumericContext,i)


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

        def aggregator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.AggregatorContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.AggregatorContext,i)


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

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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_node

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

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




    def node(self):

        localctx = GnosisEPLParser.NodeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_node)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 490 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 490
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
                    if la_ == 1:
                        self.state = 483
                        self.alphanumeric()
                        self.state = 486
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==GnosisEPLParser.DOT:
                            self.state = 484
                            self.match(GnosisEPLParser.DOT)
                            self.state = 485
                            self.alphanumeric()


                        pass

                    elif la_ == 2:
                        self.state = 488
                        self.match(GnosisEPLParser.ASTERISK)
                        pass

                    elif la_ == 3:
                        self.state = 489
                        self.aggregator()
                        pass



                else:
                    raise NoViableAltException(self)
                self.state = 492 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,58,self._ctx)

            self.state = 500
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
            if la_ == 1:
                self.state = 496 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 496
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [GnosisEPLParser.NUMBER, GnosisEPLParser.WORD]:
                            self.state = 494
                            self.alphanumeric()
                            pass
                        elif token in [GnosisEPLParser.WHITESPACE]:
                            self.state = 495
                            self.match(GnosisEPLParser.WHITESPACE)
                            pass
                        else:
                            raise NoViableAltException(self)


                    else:
                        raise NoViableAltException(self)
                    self.state = 498 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,60,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 AggregatorContext(ParserRuleContext):

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

        def alphanumeric(self):
            return self.getTypedRuleContext(GnosisEPLParser.AlphanumericContext,0)


        def LPAREN(self):
            return self.getToken(GnosisEPLParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(GnosisEPLParser.RPAREN, 0)

        def node(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GnosisEPLParser.NodeContext)
            else:
                return self.getTypedRuleContext(GnosisEPLParser.NodeContext,i)


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

        def getRuleIndex(self):
            return GnosisEPLParser.RULE_aggregator

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

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




    def aggregator(self):

        localctx = GnosisEPLParser.AggregatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_aggregator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 502
            self.alphanumeric()
            self.state = 503
            self.match(GnosisEPLParser.LPAREN)
            self.state = 506 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 506
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [GnosisEPLParser.ASTERISK, GnosisEPLParser.NUMBER, GnosisEPLParser.WORD]:
                    self.state = 504
                    self.node()
                    pass
                elif token in [GnosisEPLParser.WHITESPACE]:
                    self.state = 505
                    self.match(GnosisEPLParser.WHITESPACE)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 508 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GnosisEPLParser.ASTERISK) | (1 << GnosisEPLParser.NUMBER) | (1 << GnosisEPLParser.WORD) | (1 << GnosisEPLParser.WHITESPACE))) != 0)):
                    break

            self.state = 510
            self.match(GnosisEPLParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





