# Generated from java-escape by ANTLR 4.5
# encoding: utf-8
from antlr4 import *
from io import StringIO
package = globals().get("__package__", None)
ischild = len(package)>0 if package is not None else False
if ischild:
    from ..blendedParserListener import blendedParserListener
else:
    from blendedParserListener import blendedParserListener
def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3J")
        buf.write("\u01f3\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)\3\2\3\2\7\2U\n\2\f\2\16\2X\13\2")
        buf.write("\3\2\7\2[\n\2\f\2\16\2^\13\2\5\2`\n\2\3\2\3\2\3\3\3\3")
        buf.write("\5\3f\n\3\3\4\3\4\5\4j\n\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5")
        buf.write("\3\5\3\5\3\5\3\5\5\5w\n\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6")
        buf.write("\3\6\3\6\3\6\5\6\u0083\n\6\3\7\3\7\5\7\u0087\n\7\3\7\7")
        buf.write("\7\u008a\n\7\f\7\16\7\u008d\13\7\3\7\3\7\3\b\3\b\7\b\u0093")
        buf.write("\n\b\f\b\16\b\u0096\13\b\3\b\3\b\3\t\3\t\3\t\3\t\5\t\u009e")
        buf.write("\n\t\3\t\3\t\3\n\3\n\7\n\u00a4\n\n\f\n\16\n\u00a7\13\n")
        buf.write("\3\n\3\n\3\13\3\13\3\13\3\f\3\f\3\f\3\r\3\r\3\r\3\r\5")
        buf.write("\r\u00b5\n\r\3\r\5\r\u00b8\n\r\3\r\3\r\5\r\u00bc\n\r\3")
        buf.write("\r\5\r\u00bf\n\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\17")
        buf.write("\3\17\7\17\u00ca\n\17\f\17\16\17\u00cd\13\17\3\17\3\17")
        buf.write("\3\20\3\20\7\20\u00d3\n\20\f\20\16\20\u00d6\13\20\3\20")
        buf.write("\3\20\7\20\u00da\n\20\f\20\16\20\u00dd\13\20\5\20\u00df")
        buf.write("\n\20\3\20\3\20\3\21\3\21\3\21\3\21\5\21\u00e7\n\21\3")
        buf.write("\21\3\21\3\22\3\22\5\22\u00ed\n\22\3\22\7\22\u00f0\n\22")
        buf.write("\f\22\16\22\u00f3\13\22\3\22\3\22\7\22\u00f7\n\22\f\22")
        buf.write("\16\22\u00fa\13\22\5\22\u00fc\n\22\3\22\3\22\3\23\3\23")
        buf.write("\3\23\3\23\5\23\u0104\n\23\3\23\3\23\3\24\3\24\3\24\7")
        buf.write("\24\u010b\n\24\f\24\16\24\u010e\13\24\3\24\3\24\3\25\3")
        buf.write("\25\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26")
        buf.write("\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\27\3\27\3\27\3\27")
        buf.write("\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\32\3\32")
        buf.write("\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\7\33\u013d")
        buf.write("\n\33\f\33\16\33\u0140\13\33\5\33\u0142\n\33\3\33\3\33")
        buf.write("\3\33\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\36")
        buf.write("\3\36\3\36\3\36\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3!\3!")
        buf.write("\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u0168\n\"\3")
        buf.write("#\5#\u016b\n#\3#\3#\3#\7#\u0170\n#\f#\16#\u0173\13#\3")
        buf.write("#\3#\3#\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3")
        buf.write("%\3%\7%\u0189\n%\f%\16%\u018c\13%\3%\3%\3%\3%\3%\3%\3")
        buf.write("%\3%\3%\3%\3%\7%\u0199\n%\f%\16%\u019c\13%\3%\3%\3%\3")
        buf.write("%\5%\u01a2\n%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3")
        buf.write("%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\7%\u01be\n%\f%\16")
        buf.write("%\u01c1\13%\5%\u01c3\n%\3%\3%\3%\3%\3%\3%\3%\3%\3%\6%")
        buf.write("\u01ce\n%\r%\16%\u01cf\7%\u01d2\n%\f%\16%\u01d5\13%\3")
        buf.write("&\3&\3&\7&\u01da\n&\f&\16&\u01dd\13&\3\'\3\'\3\'\3\'\3")
        buf.write("\'\3\'\3\'\3\'\5\'\u01e7\n\'\3(\6(\u01ea\n(\r(\16(\u01eb")
        buf.write("\3)\6)\u01ef\n)\r)\16)\u01f0\3)\2\3H*\2\4\6\b\n\f\16\20")
        buf.write("\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJL")
        buf.write("NP\2\b\3\2)*\3\2?D\4\2GHJJ\3\2EF\3\2\n#\4\2\b\t++\u0214")
        buf.write("\2_\3\2\2\2\4e\3\2\2\2\6i\3\2\2\2\bv\3\2\2\2\n\u0082\3")
        buf.write("\2\2\2\f\u0084\3\2\2\2\16\u0090\3\2\2\2\20\u0099\3\2\2")
        buf.write("\2\22\u00a1\3\2\2\2\24\u00aa\3\2\2\2\26\u00ad\3\2\2\2")
        buf.write("\30\u00b0\3\2\2\2\32\u00c2\3\2\2\2\34\u00c7\3\2\2\2\36")
        buf.write("\u00d0\3\2\2\2 \u00e2\3\2\2\2\"\u00ec\3\2\2\2$\u00ff\3")
        buf.write("\2\2\2&\u0107\3\2\2\2(\u0111\3\2\2\2*\u0118\3\2\2\2,\u0124")
        buf.write("\3\2\2\2.\u0128\3\2\2\2\60\u012d\3\2\2\2\62\u0131\3\2")
        buf.write("\2\2\64\u0135\3\2\2\2\66\u0146\3\2\2\28\u014a\3\2\2\2")
        buf.write(":\u014f\3\2\2\2<\u0153\3\2\2\2>\u0157\3\2\2\2@\u015b\3")
        buf.write("\2\2\2B\u0167\3\2\2\2D\u016a\3\2\2\2F\u0177\3\2\2\2H\u01a1")
        buf.write("\3\2\2\2J\u01d6\3\2\2\2L\u01e6\3\2\2\2N\u01e9\3\2\2\2")
        buf.write("P\u01ee\3\2\2\2RV\5\20\t\2SU\5\f\7\2TS\3\2\2\2UX\3\2\2")
        buf.write("\2VT\3\2\2\2VW\3\2\2\2W`\3\2\2\2XV\3\2\2\2Y[\5\4\3\2Z")
        buf.write("Y\3\2\2\2[^\3\2\2\2\\Z\3\2\2\2\\]\3\2\2\2]`\3\2\2\2^\\")
        buf.write("\3\2\2\2_R\3\2\2\2_\\\3\2\2\2`a\3\2\2\2ab\7\2\2\3b\3\3")
        buf.write("\2\2\2cf\5\b\5\2df\5\16\b\2ec\3\2\2\2ed\3\2\2\2f\5\3\2")
        buf.write("\2\2gj\5\b\5\2hj\5\f\7\2ig\3\2\2\2ih\3\2\2\2j\7\3\2\2")
        buf.write("\2kw\5\30\r\2lw\5\32\16\2mw\5 \21\2nw\5\"\22\2ow\5\36")
        buf.write("\20\2pw\5\34\17\2qw\5$\23\2rw\5\26\f\2sw\5&\24\2tw\5\24")
        buf.write("\13\2uw\5\22\n\2vk\3\2\2\2vl\3\2\2\2vm\3\2\2\2vn\3\2\2")
        buf.write("\2vo\3\2\2\2vp\3\2\2\2vq\3\2\2\2vr\3\2\2\2vs\3\2\2\2v")
        buf.write("t\3\2\2\2vu\3\2\2\2w\t\3\2\2\2x\u0083\5\30\r\2y\u0083")
        buf.write("\5 \21\2z\u0083\5\"\22\2{\u0083\5\36\20\2|\u0083\5\34")
        buf.write("\17\2}\u0083\5$\23\2~\u0083\5\26\f\2\177\u0083\5&\24\2")
        buf.write("\u0080\u0083\5\24\13\2\u0081\u0083\5\22\n\2\u0082x\3\2")
        buf.write("\2\2\u0082y\3\2\2\2\u0082z\3\2\2\2\u0082{\3\2\2\2\u0082")
        buf.write("|\3\2\2\2\u0082}\3\2\2\2\u0082~\3\2\2\2\u0082\177\3\2")
        buf.write("\2\2\u0082\u0080\3\2\2\2\u0082\u0081\3\2\2\2\u0083\13")
        buf.write("\3\2\2\2\u0084\u0086\5.\30\2\u0085\u0087\5\62\32\2\u0086")
        buf.write("\u0085\3\2\2\2\u0086\u0087\3\2\2\2\u0087\u008b\3\2\2\2")
        buf.write("\u0088\u008a\5\6\4\2\u0089\u0088\3\2\2\2\u008a\u008d\3")
        buf.write("\2\2\2\u008b\u0089\3\2\2\2\u008b\u008c\3\2\2\2\u008c\u008e")
        buf.write("\3\2\2\2\u008d\u008b\3\2\2\2\u008e\u008f\5\60\31\2\u008f")
        buf.write("\r\3\2\2\2\u0090\u0094\5.\30\2\u0091\u0093\5\4\3\2\u0092")
        buf.write("\u0091\3\2\2\2\u0093\u0096\3\2\2\2\u0094\u0092\3\2\2\2")
        buf.write("\u0094\u0095\3\2\2\2\u0095\u0097\3\2\2\2\u0096\u0094\3")
        buf.write("\2\2\2\u0097\u0098\5\60\31\2\u0098\17\3\2\2\2\u0099\u009a")
        buf.write("\7\5\2\2\u009a\u009d\7\26\2\2\u009b\u009e\5J&\2\u009c")
        buf.write("\u009e\5B\"\2\u009d\u009b\3\2\2\2\u009d\u009c\3\2\2\2")
        buf.write("\u009e\u009f\3\2\2\2\u009f\u00a0\7+\2\2\u00a0\21\3\2\2")
        buf.write("\2\u00a1\u00a5\5> \2\u00a2\u00a4\5\6\4\2\u00a3\u00a2\3")
        buf.write("\2\2\2\u00a4\u00a7\3\2\2\2\u00a5\u00a3\3\2\2\2\u00a5\u00a6")
        buf.write("\3\2\2\2\u00a6\u00a8\3\2\2\2\u00a7\u00a5\3\2\2\2\u00a8")
        buf.write("\u00a9\5@!\2\u00a9\23\3\2\2\2\u00aa\u00ab\7\4\2\2\u00ab")
        buf.write("\u00ac\7(\2\2\u00ac\25\3\2\2\2\u00ad\u00ae\7\3\2\2\u00ae")
        buf.write("\u00af\7\'\2\2\u00af\27\3\2\2\2\u00b0\u00b1\7\5\2\2\u00b1")
        buf.write("\u00b4\7\25\2\2\u00b2\u00b5\5B\"\2\u00b3\u00b5\5J&\2\u00b4")
        buf.write("\u00b2\3\2\2\2\u00b4\u00b3\3\2\2\2\u00b5\u00b7\3\2\2\2")
        buf.write("\u00b6\u00b8\7\17\2\2\u00b7\u00b6\3\2\2\2\u00b7\u00b8")
        buf.write("\3\2\2\2\u00b8\u00bb\3\2\2\2\u00b9\u00ba\7\20\2\2\u00ba")
        buf.write("\u00bc\5H%\2\u00bb\u00b9\3\2\2\2\u00bb\u00bc\3\2\2\2\u00bc")
        buf.write("\u00be\3\2\2\2\u00bd\u00bf\7\21\2\2\u00be\u00bd\3\2\2")
        buf.write("\2\u00be\u00bf\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\u00c1")
        buf.write("\7+\2\2\u00c1\31\3\2\2\2\u00c2\u00c3\7\5\2\2\u00c3\u00c4")
        buf.write("\7\27\2\2\u00c4\u00c5\5F$\2\u00c5\u00c6\7+\2\2\u00c6\33")
        buf.write("\3\2\2\2\u00c7\u00cb\5\64\33\2\u00c8\u00ca\5\b\5\2\u00c9")
        buf.write("\u00c8\3\2\2\2\u00ca\u00cd\3\2\2\2\u00cb\u00c9\3\2\2\2")
        buf.write("\u00cb\u00cc\3\2\2\2\u00cc\u00ce\3\2\2\2\u00cd\u00cb\3")
        buf.write("\2\2\2\u00ce\u00cf\5\66\34\2\u00cf\35\3\2\2\2\u00d0\u00d4")
        buf.write("\58\35\2\u00d1\u00d3\5\4\3\2\u00d2\u00d1\3\2\2\2\u00d3")
        buf.write("\u00d6\3\2\2\2\u00d4\u00d2\3\2\2\2\u00d4\u00d5\3\2\2\2")
        buf.write("\u00d5\u00de\3\2\2\2\u00d6\u00d4\3\2\2\2\u00d7\u00db\5")
        buf.write(":\36\2\u00d8\u00da\5\4\3\2\u00d9\u00d8\3\2\2\2\u00da\u00dd")
        buf.write("\3\2\2\2\u00db\u00d9\3\2\2\2\u00db\u00dc\3\2\2\2\u00dc")
        buf.write("\u00df\3\2\2\2\u00dd\u00db\3\2\2\2\u00de\u00d7\3\2\2\2")
        buf.write("\u00de\u00df\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\u00e1\5")
        buf.write("<\37\2\u00e1\37\3\2\2\2\u00e2\u00e3\7\5\2\2\u00e3\u00e6")
        buf.write("\7\30\2\2\u00e4\u00e7\5F$\2\u00e5\u00e7\5H%\2\u00e6\u00e4")
        buf.write("\3\2\2\2\u00e6\u00e5\3\2\2\2\u00e7\u00e8\3\2\2\2\u00e8")
        buf.write("\u00e9\7+\2\2\u00e9!\3\2\2\2\u00ea\u00ed\5(\25\2\u00eb")
        buf.write("\u00ed\5*\26\2\u00ec\u00ea\3\2\2\2\u00ec\u00eb\3\2\2\2")
        buf.write("\u00ed\u00f1\3\2\2\2\u00ee\u00f0\5\n\6\2\u00ef\u00ee\3")
        buf.write("\2\2\2\u00f0\u00f3\3\2\2\2\u00f1\u00ef\3\2\2\2\u00f1\u00f2")
        buf.write("\3\2\2\2\u00f2\u00fb\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f4")
        buf.write("\u00f8\5:\36\2\u00f5\u00f7\5\n\6\2\u00f6\u00f5\3\2\2\2")
        buf.write("\u00f7\u00fa\3\2\2\2\u00f8\u00f6\3\2\2\2\u00f8\u00f9\3")
        buf.write("\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fb\u00f4")
        buf.write("\3\2\2\2\u00fb\u00fc\3\2\2\2\u00fc\u00fd\3\2\2\2\u00fd")
        buf.write("\u00fe\5,\27\2\u00fe#\3\2\2\2\u00ff\u0100\7\5\2\2\u0100")
        buf.write("\u0103\7\35\2\2\u0101\u0104\5F$\2\u0102\u0104\5H%\2\u0103")
        buf.write("\u0101\3\2\2\2\u0103\u0102\3\2\2\2\u0104\u0105\3\2\2\2")
        buf.write("\u0105\u0106\7+\2\2\u0106%\3\2\2\2\u0107\u0108\7\6\2\2")
        buf.write("\u0108\u010c\5J&\2\u0109\u010b\t\2\2\2\u010a\u0109\3\2")
        buf.write("\2\2\u010b\u010e\3\2\2\2\u010c\u010a\3\2\2\2\u010c\u010d")
        buf.write("\3\2\2\2\u010d\u010f\3\2\2\2\u010e\u010c\3\2\2\2\u010f")
        buf.write("\u0110\7\b\2\2\u0110\'\3\2\2\2\u0111\u0112\7\5\2\2\u0112")
        buf.write("\u0113\7\31\2\2\u0113\u0114\5N(\2\u0114\u0115\7\13\2\2")
        buf.write("\u0115\u0116\5H%\2\u0116\u0117\7+\2\2\u0117)\3\2\2\2\u0118")
        buf.write("\u0119\7\5\2\2\u0119\u011a\7\31\2\2\u011a\u011b\5N(\2")
        buf.write("\u011b\u011c\7\64\2\2\u011c\u011d\5N(\2\u011d\u011e\7")
        buf.write("\13\2\2\u011e\u011f\7!\2\2\u011f\u0120\7.\2\2\u0120\u0121")
        buf.write("\5H%\2\u0121\u0122\7/\2\2\u0122\u0123\7+\2\2\u0123+\3")
        buf.write("\2\2\2\u0124\u0125\7\5\2\2\u0125\u0126\7\32\2\2\u0126")
        buf.write("\u0127\7+\2\2\u0127-\3\2\2\2\u0128\u0129\7\5\2\2\u0129")
        buf.write("\u012a\7\22\2\2\u012a\u012b\5N(\2\u012b\u012c\7+\2\2\u012c")
        buf.write("/\3\2\2\2\u012d\u012e\7\5\2\2\u012e\u012f\7\24\2\2\u012f")
        buf.write("\u0130\7+\2\2\u0130\61\3\2\2\2\u0131\u0132\7\5\2\2\u0132")
        buf.write("\u0133\7\23\2\2\u0133\u0134\7+\2\2\u0134\63\3\2\2\2\u0135")
        buf.write("\u0136\7\5\2\2\u0136\u0137\7\33\2\2\u0137\u0138\5N(\2")
        buf.write("\u0138\u0141\7.\2\2\u0139\u013e\5N(\2\u013a\u013b\7\64")
        buf.write("\2\2\u013b\u013d\5N(\2\u013c\u013a\3\2\2\2\u013d\u0140")
        buf.write("\3\2\2\2\u013e\u013c\3\2\2\2\u013e\u013f\3\2\2\2\u013f")
        buf.write("\u0142\3\2\2\2\u0140\u013e\3\2\2\2\u0141\u0139\3\2\2\2")
        buf.write("\u0141\u0142\3\2\2\2\u0142\u0143\3\2\2\2\u0143\u0144\7")
        buf.write("/\2\2\u0144\u0145\7+\2\2\u0145\65\3\2\2\2\u0146\u0147")
        buf.write("\7\5\2\2\u0147\u0148\7\34\2\2\u0148\u0149\7+\2\2\u0149")
        buf.write("\67\3\2\2\2\u014a\u014b\7\5\2\2\u014b\u014c\7\36\2\2\u014c")
        buf.write("\u014d\5H%\2\u014d\u014e\7+\2\2\u014e9\3\2\2\2\u014f\u0150")
        buf.write("\7\5\2\2\u0150\u0151\7\37\2\2\u0151\u0152\7+\2\2\u0152")
        buf.write(";\3\2\2\2\u0153\u0154\7\5\2\2\u0154\u0155\7 \2\2\u0155")
        buf.write("\u0156\7+\2\2\u0156=\3\2\2\2\u0157\u0158\7\5\2\2\u0158")
        buf.write("\u0159\7\"\2\2\u0159\u015a\7+\2\2\u015a?\3\2\2\2\u015b")
        buf.write("\u015c\7\5\2\2\u015c\u015d\7#\2\2\u015d\u015e\7+\2\2\u015e")
        buf.write("A\3\2\2\2\u015f\u0160\7,\2\2\u0160\u0161\5D#\2\u0161\u0162")
        buf.write("\7,\2\2\u0162\u0168\3\2\2\2\u0163\u0164\7-\2\2\u0164\u0165")
        buf.write("\5D#\2\u0165\u0166\7-\2\2\u0166\u0168\3\2\2\2\u0167\u015f")
        buf.write("\3\2\2\2\u0167\u0163\3\2\2\2\u0168C\3\2\2\2\u0169\u016b")
        buf.write("\7\67\2\2\u016a\u0169\3\2\2\2\u016a\u016b\3\2\2\2\u016b")
        buf.write("\u016c\3\2\2\2\u016c\u0171\5N(\2\u016d\u016e\7\67\2\2")
        buf.write("\u016e\u0170\5N(\2\u016f\u016d\3\2\2\2\u0170\u0173\3\2")
        buf.write("\2\2\u0171\u016f\3\2\2\2\u0171\u0172\3\2\2\2\u0172\u0174")
        buf.write("\3\2\2\2\u0173\u0171\3\2\2\2\u0174\u0175\7\7\2\2\u0175")
        buf.write("\u0176\5N(\2\u0176E\3\2\2\2\u0177\u0178\5N(\2\u0178\u0179")
        buf.write("\7=\2\2\u0179\u017a\5H%\2\u017aG\3\2\2\2\u017b\u017c\b")
        buf.write("%\1\2\u017c\u017d\7\16\2\2\u017d\u01a2\5H%\6\u017e\u017f")
        buf.write("\7F\2\2\u017f\u01a2\5H%\5\u0180\u0181\7.\2\2\u0181\u0182")
        buf.write("\5H%\2\u0182\u0183\7/\2\2\u0183\u01a2\3\2\2\2\u0184\u0185")
        buf.write("\7\62\2\2\u0185\u018a\5H%\2\u0186\u0187\7\64\2\2\u0187")
        buf.write("\u0189\5H%\2\u0188\u0186\3\2\2\2\u0189\u018c\3\2\2\2\u018a")
        buf.write("\u0188\3\2\2\2\u018a\u018b\3\2\2\2\u018b\u018d\3\2\2\2")
        buf.write("\u018c\u018a\3\2\2\2\u018d\u018e\7\63\2\2\u018e\u01a2")
        buf.write("\3\2\2\2\u018f\u0190\7\60\2\2\u0190\u0191\5H%\2\u0191")
        buf.write("\u0192\7>\2\2\u0192\u019a\5H%\2\u0193\u0194\7\64\2\2\u0194")
        buf.write("\u0195\5H%\2\u0195\u0196\7>\2\2\u0196\u0197\5H%\2\u0197")
        buf.write("\u0199\3\2\2\2\u0198\u0193\3\2\2\2\u0199\u019c\3\2\2\2")
        buf.write("\u019a\u0198\3\2\2\2\u019a\u019b\3\2\2\2\u019b\u019d\3")
        buf.write("\2\2\2\u019c\u019a\3\2\2\2\u019d\u019e\7\61\2\2\u019e")
        buf.write("\u01a2\3\2\2\2\u019f\u01a2\5L\'\2\u01a0\u01a2\5N(\2\u01a1")
        buf.write("\u017b\3\2\2\2\u01a1\u017e\3\2\2\2\u01a1\u0180\3\2\2\2")
        buf.write("\u01a1\u0184\3\2\2\2\u01a1\u018f\3\2\2\2\u01a1\u019f\3")
        buf.write("\2\2\2\u01a1\u01a0\3\2\2\2\u01a2\u01d3\3\2\2\2\u01a3\u01a4")
        buf.write("\f\16\2\2\u01a4\u01a5\t\3\2\2\u01a5\u01d2\5H%\17\u01a6")
        buf.write("\u01a7\f\r\2\2\u01a7\u01a8\7\r\2\2\u01a8\u01d2\5H%\16")
        buf.write("\u01a9\u01aa\f\f\2\2\u01aa\u01ab\7\f\2\2\u01ab\u01d2\5")
        buf.write("H%\r\u01ac\u01ad\f\13\2\2\u01ad\u01ae\7\13\2\2\u01ae\u01d2")
        buf.write("\5H%\f\u01af\u01b0\f\t\2\2\u01b0\u01b1\7I\2\2\u01b1\u01d2")
        buf.write("\5H%\n\u01b2\u01b3\f\b\2\2\u01b3\u01b4\t\4\2\2\u01b4\u01d2")
        buf.write("\5H%\t\u01b5\u01b6\f\7\2\2\u01b6\u01b7\t\5\2\2\u01b7\u01d2")
        buf.write("\5H%\b\u01b8\u01b9\f\22\2\2\u01b9\u01c2\7.\2\2\u01ba\u01bf")
        buf.write("\5H%\2\u01bb\u01bc\7\64\2\2\u01bc\u01be\5H%\2\u01bd\u01bb")
        buf.write("\3\2\2\2\u01be\u01c1\3\2\2\2\u01bf\u01bd\3\2\2\2\u01bf")
        buf.write("\u01c0\3\2\2\2\u01c0\u01c3\3\2\2\2\u01c1\u01bf\3\2\2\2")
        buf.write("\u01c2\u01ba\3\2\2\2\u01c2\u01c3\3\2\2\2\u01c3\u01c4\3")
        buf.write("\2\2\2\u01c4\u01d2\7/\2\2\u01c5\u01c6\f\21\2\2\u01c6\u01c7")
        buf.write("\7\62\2\2\u01c7\u01c8\5H%\2\u01c8\u01c9\7\63\2\2\u01c9")
        buf.write("\u01d2\3\2\2\2\u01ca\u01cd\f\n\2\2\u01cb\u01cc\7\7\2\2")
        buf.write("\u01cc\u01ce\5N(\2\u01cd\u01cb\3\2\2\2\u01ce\u01cf\3\2")
        buf.write("\2\2\u01cf\u01cd\3\2\2\2\u01cf\u01d0\3\2\2\2\u01d0\u01d2")
        buf.write("\3\2\2\2\u01d1\u01a3\3\2\2\2\u01d1\u01a6\3\2\2\2\u01d1")
        buf.write("\u01a9\3\2\2\2\u01d1\u01ac\3\2\2\2\u01d1\u01af\3\2\2\2")
        buf.write("\u01d1\u01b2\3\2\2\2\u01d1\u01b5\3\2\2\2\u01d1\u01b8\3")
        buf.write("\2\2\2\u01d1\u01c5\3\2\2\2\u01d1\u01ca\3\2\2\2\u01d2\u01d5")
        buf.write("\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4")
        buf.write("I\3\2\2\2\u01d5\u01d3\3\2\2\2\u01d6\u01db\5N(\2\u01d7")
        buf.write("\u01d8\7\7\2\2\u01d8\u01da\5N(\2\u01d9\u01d7\3\2\2\2\u01da")
        buf.write("\u01dd\3\2\2\2\u01db\u01d9\3\2\2\2\u01db\u01dc\3\2\2\2")
        buf.write("\u01dcK\3\2\2\2\u01dd\u01db\3\2\2\2\u01de\u01df\7-\2\2")
        buf.write("\u01df\u01e0\5P)\2\u01e0\u01e1\7-\2\2\u01e1\u01e7\3\2")
        buf.write("\2\2\u01e2\u01e3\7,\2\2\u01e3\u01e4\5P)\2\u01e4\u01e5")
        buf.write("\7,\2\2\u01e5\u01e7\3\2\2\2\u01e6\u01de\3\2\2\2\u01e6")
        buf.write("\u01e2\3\2\2\2\u01e7M\3\2\2\2\u01e8\u01ea\t\6\2\2\u01e9")
        buf.write("\u01e8\3\2\2\2\u01ea\u01eb\3\2\2\2\u01eb\u01e9\3\2\2\2")
        buf.write("\u01eb\u01ec\3\2\2\2\u01ecO\3\2\2\2\u01ed\u01ef\n\7\2")
        buf.write("\2\u01ee\u01ed\3\2\2\2\u01ef\u01f0\3\2\2\2\u01f0\u01ee")
        buf.write("\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1Q\3\2\2\2.V\\_eiv\u0082")
        buf.write("\u0086\u008b\u0094\u009d\u00a5\u00b4\u00b7\u00bb\u00be")
        buf.write("\u00cb\u00d4\u00db\u00de\u00e6\u00ec\u00f1\u00f8\u00fb")
        buf.write("\u0103\u010c\u013e\u0141\u0167\u016a\u0171\u018a\u019a")
        buf.write("\u01a1\u01bf\u01c2\u01cf\u01d1\u01d3\u01db\u01e6\u01eb")
        buf.write("\u01f0")
        return buf.getvalue()


class blendedParser ( Parser ):

    grammarFileName = "java-escape"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ u"<INVALID>", u"'{% raw %}'", u"'{#'", u"'{%'", u"<INVALID>", 
                     u"'.'", u"'}}'", u"'#{'", u"<INVALID>", u"'in'", u"'and'", 
                     u"'or'", u"'not'", u"'ignore missing'", u"'with'", 
                     u"'only'", u"'block'", u"'parent'", u"'endblock'", 
                     u"'include'", u"'extends'", u"'set'", u"'print'", u"'for'", 
                     u"'endfor'", u"'macro'", u"'endmacro'", u"'do'", u"'if'", 
                     u"'else'", u"'endif'", u"'items'", u"'comment'", u"'endcomment'", 
                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"'{% endraw %}'", 
                     u"'#}'", u"'|e'", u"'|items'", u"'%}'", u"'\"'", u"'''", 
                     u"'('", u"')'", u"'{'", u"'}'", u"'['", u"']'", u"','", 
                     u"'&'", u"'\\'", u"<INVALID>", u"';'", u"'|'", u"'!'", 
                     u"'@'", u"'#'", u"'='", u"':'", u"'=='", u"'!='", u"'>'", 
                     u"'<'", u"'<='", u"'>='", u"'+'", u"'-'", u"'*'", u"<INVALID>", 
                     u"'^'", u"'%'" ]

    symbolicNames = [ u"<INVALID>", u"RAW", u"LCOM", u"LTAG", u"LREN", u"DOT", 
                      u"RREN", u"TWIG", u"ID", u"IN", u"AND", u"OR", u"NOT", 
                      u"IGNORE", u"WITH", u"ONLY", u"BLOCK", u"PARENT", 
                      u"ENDBLOCK", u"INCLUDE", u"EXTENDS", u"SET", u"PRINT", 
                      u"FOR", u"ENDFOR", u"MACRO", u"ENDMACRO", u"DO", u"IF", 
                      u"ELSE", u"ENDIF", u"ITEMS", u"COMMENT", u"ENDCOMMENT", 
                      u"TEXT", u"WS", u"NEWLINE", u"ENDRAW", u"RCOM", u"EFILTER", 
                      u"IFILTER", u"RTAG", u"QUOTE", u"APO", u"LPAREN", 
                      u"RPAREN", u"LBRACE", u"RBRACE", u"LBRACK", u"RBRACK", 
                      u"COMMA", u"AMP", u"BSLASH", u"FSLASH", u"SEMI", u"PIPE", 
                      u"EXCL", u"AT", u"POUND", u"ASSIGN", u"COLON", u"EQUAL", 
                      u"NOTEQUAL", u"GT", u"LT", u"LE", u"GE", u"ADD", u"SUB", 
                      u"MUL", u"DIV", u"CARET", u"MOD" ]

    RULE_start = 0
    RULE_blendedBlock = 1
    RULE_blendedBlockParent = 2
    RULE_blended = 3
    RULE_blendedNoSet = 4
    RULE_blockStatementWithParent = 5
    RULE_blockStatement = 6
    RULE_extendsStatement = 7
    RULE_commentStatement = 8
    RULE_comStatement = 9
    RULE_rawStatement = 10
    RULE_includeStatement = 11
    RULE_setStatement = 12
    RULE_macroStatement = 13
    RULE_ifStatement = 14
    RULE_printStatement = 15
    RULE_forStatement = 16
    RULE_doStatement = 17
    RULE_renderStatement = 18
    RULE_forTag = 19
    RULE_forItemsTag = 20
    RULE_endForTag = 21
    RULE_blockTag = 22
    RULE_endblockTag = 23
    RULE_parentTag = 24
    RULE_macroTag = 25
    RULE_endmacroTag = 26
    RULE_ifTag = 27
    RULE_elseTag = 28
    RULE_endifTag = 29
    RULE_commentTag = 30
    RULE_endcommentTag = 31
    RULE_pathString = 32
    RULE_path = 33
    RULE_setVar = 34
    RULE_expression = 35
    RULE_attributeVariable = 36
    RULE_stringVar = 37
    RULE_identifier = 38
    RULE_text = 39

    ruleNames =  [ "start", "blendedBlock", "blendedBlockParent", "blended", 
                   "blendedNoSet", "blockStatementWithParent", "blockStatement", 
                   "extendsStatement", "commentStatement", "comStatement", 
                   "rawStatement", "includeStatement", "setStatement", "macroStatement", 
                   "ifStatement", "printStatement", "forStatement", "doStatement", 
                   "renderStatement", "forTag", "forItemsTag", "endForTag", 
                   "blockTag", "endblockTag", "parentTag", "macroTag", "endmacroTag", 
                   "ifTag", "elseTag", "endifTag", "commentTag", "endcommentTag", 
                   "pathString", "path", "setVar", "expression", "attributeVariable", 
                   "stringVar", "identifier", "text" ]

    EOF = Token.EOF
    RAW=1
    LCOM=2
    LTAG=3
    LREN=4
    DOT=5
    RREN=6
    TWIG=7
    ID=8
    IN=9
    AND=10
    OR=11
    NOT=12
    IGNORE=13
    WITH=14
    ONLY=15
    BLOCK=16
    PARENT=17
    ENDBLOCK=18
    INCLUDE=19
    EXTENDS=20
    SET=21
    PRINT=22
    FOR=23
    ENDFOR=24
    MACRO=25
    ENDMACRO=26
    DO=27
    IF=28
    ELSE=29
    ENDIF=30
    ITEMS=31
    COMMENT=32
    ENDCOMMENT=33
    TEXT=34
    WS=35
    NEWLINE=36
    ENDRAW=37
    RCOM=38
    EFILTER=39
    IFILTER=40
    RTAG=41
    QUOTE=42
    APO=43
    LPAREN=44
    RPAREN=45
    LBRACE=46
    RBRACE=47
    LBRACK=48
    RBRACK=49
    COMMA=50
    AMP=51
    BSLASH=52
    FSLASH=53
    SEMI=54
    PIPE=55
    EXCL=56
    AT=57
    POUND=58
    ASSIGN=59
    COLON=60
    EQUAL=61
    NOTEQUAL=62
    GT=63
    LT=64
    LE=65
    GE=66
    ADD=67
    SUB=68
    MUL=69
    DIV=70
    CARET=71
    MOD=72

    def __init__(self, input:TokenStream):
        super().__init__(input)
        self.checkVersion("4.5")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None



    class StartContext(ParserRuleContext):

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

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

        def extendsStatement(self):
            return self.getTypedRuleContext(blendedParser.ExtendsStatementContext,0)


        def blendedBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(blendedParser.BlendedBlockContext)
            else:
                return self.getTypedRuleContext(blendedParser.BlendedBlockContext,i)


        def blockStatementWithParent(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(blendedParser.BlockStatementWithParentContext)
            else:
                return self.getTypedRuleContext(blendedParser.BlockStatementWithParentContext,i)


        def getRuleIndex(self):
            return blendedParser.RULE_start

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterStart(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitStart(self)




    def start(self):

        localctx = blendedParser.StartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_start)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 93
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.state = 80
                self.extendsStatement()
                self.state = 84
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==blendedParser.LTAG:
                    self.state = 81
                    self.blockStatementWithParent()
                    self.state = 86
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 90
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << blendedParser.RAW) | (1 << blendedParser.LCOM) | (1 << blendedParser.LTAG) | (1 << blendedParser.LREN))) != 0):
                    self.state = 87
                    self.blendedBlock()
                    self.state = 92
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


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

    class BlendedBlockContext(ParserRuleContext):

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

        def blended(self):
            return self.getTypedRuleContext(blendedParser.BlendedContext,0)


        def blockStatement(self):
            return self.getTypedRuleContext(blendedParser.BlockStatementContext,0)


        def getRuleIndex(self):
            return blendedParser.RULE_blendedBlock

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterBlendedBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitBlendedBlock(self)




    def blendedBlock(self):

        localctx = blendedParser.BlendedBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_blendedBlock)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 99
            la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
            if la_ == 1:
                self.state = 97
                self.blended()
                pass

            elif la_ == 2:
                self.state = 98
                self.blockStatement()
                pass


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

    class BlendedBlockParentContext(ParserRuleContext):

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

        def blended(self):
            return self.getTypedRuleContext(blendedParser.BlendedContext,0)


        def blockStatementWithParent(self):
            return self.getTypedRuleContext(blendedParser.BlockStatementWithParentContext,0)


        def getRuleIndex(self):
            return blendedParser.RULE_blendedBlockParent

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterBlendedBlockParent(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitBlendedBlockParent(self)




    def blendedBlockParent(self):

        localctx = blendedParser.BlendedBlockParentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_blendedBlockParent)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 103
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.state = 101
                self.blended()
                pass

            elif la_ == 2:
                self.state = 102
                self.blockStatementWithParent()
                pass


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

    class BlendedContext(ParserRuleContext):

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

        def includeStatement(self):
            return self.getTypedRuleContext(blendedParser.IncludeStatementContext,0)


        def setStatement(self):
            return self.getTypedRuleContext(blendedParser.SetStatementContext,0)


        def printStatement(self):
            return self.getTypedRuleContext(blendedParser.PrintStatementContext,0)


        def forStatement(self):
            return self.getTypedRuleContext(blendedParser.ForStatementContext,0)


        def ifStatement(self):
            return self.getTypedRuleContext(blendedParser.IfStatementContext,0)


        def macroStatement(self):
            return self.getTypedRuleContext(blendedParser.MacroStatementContext,0)


        def doStatement(self):
            return self.getTypedRuleContext(blendedParser.DoStatementContext,0)


        def rawStatement(self):
            return self.getTypedRuleContext(blendedParser.RawStatementContext,0)


        def renderStatement(self):
            return self.getTypedRuleContext(blendedParser.RenderStatementContext,0)


        def comStatement(self):
            return self.getTypedRuleContext(blendedParser.ComStatementContext,0)


        def commentStatement(self):
            return self.getTypedRuleContext(blendedParser.CommentStatementContext,0)


        def getRuleIndex(self):
            return blendedParser.RULE_blended

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterBlended(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitBlended(self)




    def blended(self):

        localctx = blendedParser.BlendedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_blended)
        try:
            self.state = 116
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 105
                self.includeStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 106
                self.setStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 107
                self.printStatement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 108
                self.forStatement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 109
                self.ifStatement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 110
                self.macroStatement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 111
                self.doStatement()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 112
                self.rawStatement()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 113
                self.renderStatement()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 114
                self.comStatement()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 115
                self.commentStatement()
                pass


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

    class BlendedNoSetContext(ParserRuleContext):

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

        def includeStatement(self):
            return self.getTypedRuleContext(blendedParser.IncludeStatementContext,0)


        def printStatement(self):
            return self.getTypedRuleContext(blendedParser.PrintStatementContext,0)


        def forStatement(self):
            return self.getTypedRuleContext(blendedParser.ForStatementContext,0)


        def ifStatement(self):
            return self.getTypedRuleContext(blendedParser.IfStatementContext,0)


        def macroStatement(self):
            return self.getTypedRuleContext(blendedParser.MacroStatementContext,0)


        def doStatement(self):
            return self.getTypedRuleContext(blendedParser.DoStatementContext,0)


        def rawStatement(self):
            return self.getTypedRuleContext(blendedParser.RawStatementContext,0)


        def renderStatement(self):
            return self.getTypedRuleContext(blendedParser.RenderStatementContext,0)


        def comStatement(self):
            return self.getTypedRuleContext(blendedParser.ComStatementContext,0)


        def commentStatement(self):
            return self.getTypedRuleContext(blendedParser.CommentStatementContext,0)


        def getRuleIndex(self):
            return blendedParser.RULE_blendedNoSet

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterBlendedNoSet(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitBlendedNoSet(self)




    def blendedNoSet(self):

        localctx = blendedParser.BlendedNoSetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_blendedNoSet)
        try:
            self.state = 128
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 118
                self.includeStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 119
                self.printStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 120
                self.forStatement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 121
                self.ifStatement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 122
                self.macroStatement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 123
                self.doStatement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 124
                self.rawStatement()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 125
                self.renderStatement()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 126
                self.comStatement()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 127
                self.commentStatement()
                pass


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

    class BlockStatementWithParentContext(ParserRuleContext):

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

        def blockTag(self):
            return self.getTypedRuleContext(blendedParser.BlockTagContext,0)


        def endblockTag(self):
            return self.getTypedRuleContext(blendedParser.EndblockTagContext,0)


        def parentTag(self):
            return self.getTypedRuleContext(blendedParser.ParentTagContext,0)


        def blendedBlockParent(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(blendedParser.BlendedBlockParentContext)
            else:
                return self.getTypedRuleContext(blendedParser.BlendedBlockParentContext,i)


        def getRuleIndex(self):
            return blendedParser.RULE_blockStatementWithParent

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterBlockStatementWithParent(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitBlockStatementWithParent(self)




    def blockStatementWithParent(self):

        localctx = blendedParser.BlockStatementWithParentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_blockStatementWithParent)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 130
            self.blockTag()
            self.state = 132
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.state = 131
                self.parentTag()


            self.state = 137
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,8,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 134
                    self.blendedBlockParent() 
                self.state = 139
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,8,self._ctx)

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

    class BlockStatementContext(ParserRuleContext):

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

        def blockTag(self):
            return self.getTypedRuleContext(blendedParser.BlockTagContext,0)


        def endblockTag(self):
            return self.getTypedRuleContext(blendedParser.EndblockTagContext,0)


        def blendedBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(blendedParser.BlendedBlockContext)
            else:
                return self.getTypedRuleContext(blendedParser.BlendedBlockContext,i)


        def getRuleIndex(self):
            return blendedParser.RULE_blockStatement

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterBlockStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitBlockStatement(self)




    def blockStatement(self):

        localctx = blendedParser.BlockStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_blockStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 142
            self.blockTag()
            self.state = 146
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,9,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 143
                    self.blendedBlock() 
                self.state = 148
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,9,self._ctx)

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

    class ExtendsStatementContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def EXTENDS(self):
            return self.getToken(blendedParser.EXTENDS, 0)

        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def attributeVariable(self):
            return self.getTypedRuleContext(blendedParser.AttributeVariableContext,0)


        def pathString(self):
            return self.getTypedRuleContext(blendedParser.PathStringContext,0)


        def getRuleIndex(self):
            return blendedParser.RULE_extendsStatement

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterExtendsStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitExtendsStatement(self)




    def extendsStatement(self):

        localctx = blendedParser.ExtendsStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_extendsStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 151
            self.match(blendedParser.LTAG)
            self.state = 152
            self.match(blendedParser.EXTENDS)
            self.state = 155
            token = self._input.LA(1)
            if token in [blendedParser.ID, blendedParser.IN, blendedParser.AND, blendedParser.OR, blendedParser.NOT, blendedParser.IGNORE, blendedParser.WITH, blendedParser.ONLY, blendedParser.BLOCK, blendedParser.PARENT, blendedParser.ENDBLOCK, blendedParser.INCLUDE, blendedParser.EXTENDS, blendedParser.SET, blendedParser.PRINT, blendedParser.FOR, blendedParser.ENDFOR, blendedParser.MACRO, blendedParser.ENDMACRO, blendedParser.DO, blendedParser.IF, blendedParser.ELSE, blendedParser.ENDIF, blendedParser.ITEMS, blendedParser.COMMENT, blendedParser.ENDCOMMENT]:
                self.state = 153
                self.attributeVariable()

            elif token in [blendedParser.QUOTE, blendedParser.APO]:
                self.state = 154
                self.pathString()

            else:
                raise NoViableAltException(self)

            self.state = 157
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CommentStatementContext(ParserRuleContext):

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

        def commentTag(self):
            return self.getTypedRuleContext(blendedParser.CommentTagContext,0)


        def endcommentTag(self):
            return self.getTypedRuleContext(blendedParser.EndcommentTagContext,0)


        def blendedBlockParent(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(blendedParser.BlendedBlockParentContext)
            else:
                return self.getTypedRuleContext(blendedParser.BlendedBlockParentContext,i)


        def getRuleIndex(self):
            return blendedParser.RULE_commentStatement

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterCommentStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitCommentStatement(self)




    def commentStatement(self):

        localctx = blendedParser.CommentStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_commentStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 159
            self.commentTag()
            self.state = 163
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,11,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 160
                    self.blendedBlockParent() 
                self.state = 165
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,11,self._ctx)

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

    class ComStatementContext(ParserRuleContext):

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

        def LCOM(self):
            return self.getToken(blendedParser.LCOM, 0)

        def RCOM(self):
            return self.getToken(blendedParser.RCOM, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_comStatement

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterComStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitComStatement(self)




    def comStatement(self):

        localctx = blendedParser.ComStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_comStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 168
            self.match(blendedParser.LCOM)
            self.state = 169
            self.match(blendedParser.RCOM)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class RawStatementContext(ParserRuleContext):

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

        def RAW(self):
            return self.getToken(blendedParser.RAW, 0)

        def ENDRAW(self):
            return self.getToken(blendedParser.ENDRAW, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_rawStatement

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterRawStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitRawStatement(self)




    def rawStatement(self):

        localctx = blendedParser.RawStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_rawStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 171
            self.match(blendedParser.RAW)
            self.state = 172
            self.match(blendedParser.ENDRAW)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class IncludeStatementContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def INCLUDE(self):
            return self.getToken(blendedParser.INCLUDE, 0)

        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def pathString(self):
            return self.getTypedRuleContext(blendedParser.PathStringContext,0)


        def attributeVariable(self):
            return self.getTypedRuleContext(blendedParser.AttributeVariableContext,0)


        def IGNORE(self):
            return self.getToken(blendedParser.IGNORE, 0)

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

        def expression(self):
            return self.getTypedRuleContext(blendedParser.ExpressionContext,0)


        def ONLY(self):
            return self.getToken(blendedParser.ONLY, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_includeStatement

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterIncludeStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitIncludeStatement(self)




    def includeStatement(self):

        localctx = blendedParser.IncludeStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_includeStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 174
            self.match(blendedParser.LTAG)
            self.state = 175
            self.match(blendedParser.INCLUDE)
            self.state = 178
            token = self._input.LA(1)
            if token in [blendedParser.QUOTE, blendedParser.APO]:
                self.state = 176
                self.pathString()

            elif token in [blendedParser.ID, blendedParser.IN, blendedParser.AND, blendedParser.OR, blendedParser.NOT, blendedParser.IGNORE, blendedParser.WITH, blendedParser.ONLY, blendedParser.BLOCK, blendedParser.PARENT, blendedParser.ENDBLOCK, blendedParser.INCLUDE, blendedParser.EXTENDS, blendedParser.SET, blendedParser.PRINT, blendedParser.FOR, blendedParser.ENDFOR, blendedParser.MACRO, blendedParser.ENDMACRO, blendedParser.DO, blendedParser.IF, blendedParser.ELSE, blendedParser.ENDIF, blendedParser.ITEMS, blendedParser.COMMENT, blendedParser.ENDCOMMENT]:
                self.state = 177
                self.attributeVariable()

            else:
                raise NoViableAltException(self)

            self.state = 181
            _la = self._input.LA(1)
            if _la==blendedParser.IGNORE:
                self.state = 180
                self.match(blendedParser.IGNORE)


            self.state = 185
            _la = self._input.LA(1)
            if _la==blendedParser.WITH:
                self.state = 183
                self.match(blendedParser.WITH)
                self.state = 184
                self.expression(0)


            self.state = 188
            _la = self._input.LA(1)
            if _la==blendedParser.ONLY:
                self.state = 187
                self.match(blendedParser.ONLY)


            self.state = 190
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SetStatementContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def SET(self):
            return self.getToken(blendedParser.SET, 0)

        def setVar(self):
            return self.getTypedRuleContext(blendedParser.SetVarContext,0)


        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_setStatement

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterSetStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitSetStatement(self)




    def setStatement(self):

        localctx = blendedParser.SetStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_setStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 192
            self.match(blendedParser.LTAG)
            self.state = 193
            self.match(blendedParser.SET)
            self.state = 194
            self.setVar()
            self.state = 195
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class MacroStatementContext(ParserRuleContext):

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

        def macroTag(self):
            return self.getTypedRuleContext(blendedParser.MacroTagContext,0)


        def endmacroTag(self):
            return self.getTypedRuleContext(blendedParser.EndmacroTagContext,0)


        def blended(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(blendedParser.BlendedContext)
            else:
                return self.getTypedRuleContext(blendedParser.BlendedContext,i)


        def getRuleIndex(self):
            return blendedParser.RULE_macroStatement

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterMacroStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitMacroStatement(self)




    def macroStatement(self):

        localctx = blendedParser.MacroStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_macroStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 197
            self.macroTag()
            self.state = 201
            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 = 198
                    self.blended() 
                self.state = 203
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,16,self._ctx)

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

    class IfStatementContext(ParserRuleContext):

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

        def ifTag(self):
            return self.getTypedRuleContext(blendedParser.IfTagContext,0)


        def endifTag(self):
            return self.getTypedRuleContext(blendedParser.EndifTagContext,0)


        def blendedBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(blendedParser.BlendedBlockContext)
            else:
                return self.getTypedRuleContext(blendedParser.BlendedBlockContext,i)


        def elseTag(self):
            return self.getTypedRuleContext(blendedParser.ElseTagContext,0)


        def getRuleIndex(self):
            return blendedParser.RULE_ifStatement

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterIfStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitIfStatement(self)




    def ifStatement(self):

        localctx = blendedParser.IfStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_ifStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 206
            self.ifTag()
            self.state = 210
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,17,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 207
                    self.blendedBlock() 
                self.state = 212
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,17,self._ctx)

            self.state = 220
            la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
            if la_ == 1:
                self.state = 213
                self.elseTag()
                self.state = 217
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,18,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 214
                        self.blendedBlock() 
                    self.state = 219
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,18,self._ctx)



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

    class PrintStatementContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def PRINT(self):
            return self.getToken(blendedParser.PRINT, 0)

        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def setVar(self):
            return self.getTypedRuleContext(blendedParser.SetVarContext,0)


        def expression(self):
            return self.getTypedRuleContext(blendedParser.ExpressionContext,0)


        def getRuleIndex(self):
            return blendedParser.RULE_printStatement

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterPrintStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitPrintStatement(self)




    def printStatement(self):

        localctx = blendedParser.PrintStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_printStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 224
            self.match(blendedParser.LTAG)
            self.state = 225
            self.match(blendedParser.PRINT)
            self.state = 228
            la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
            if la_ == 1:
                self.state = 226
                self.setVar()
                pass

            elif la_ == 2:
                self.state = 227
                self.expression(0)
                pass


            self.state = 230
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ForStatementContext(ParserRuleContext):

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

        def endForTag(self):
            return self.getTypedRuleContext(blendedParser.EndForTagContext,0)


        def forTag(self):
            return self.getTypedRuleContext(blendedParser.ForTagContext,0)


        def forItemsTag(self):
            return self.getTypedRuleContext(blendedParser.ForItemsTagContext,0)


        def blendedNoSet(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(blendedParser.BlendedNoSetContext)
            else:
                return self.getTypedRuleContext(blendedParser.BlendedNoSetContext,i)


        def elseTag(self):
            return self.getTypedRuleContext(blendedParser.ElseTagContext,0)


        def getRuleIndex(self):
            return blendedParser.RULE_forStatement

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterForStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitForStatement(self)




    def forStatement(self):

        localctx = blendedParser.ForStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_forStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 234
            la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
            if la_ == 1:
                self.state = 232
                self.forTag()
                pass

            elif la_ == 2:
                self.state = 233
                self.forItemsTag()
                pass


            self.state = 239
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 236
                    self.blendedNoSet() 
                self.state = 241
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,22,self._ctx)

            self.state = 249
            la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
            if la_ == 1:
                self.state = 242
                self.elseTag()
                self.state = 246
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,23,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 243
                        self.blendedNoSet() 
                    self.state = 248
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,23,self._ctx)



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

    class DoStatementContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def DO(self):
            return self.getToken(blendedParser.DO, 0)

        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def setVar(self):
            return self.getTypedRuleContext(blendedParser.SetVarContext,0)


        def expression(self):
            return self.getTypedRuleContext(blendedParser.ExpressionContext,0)


        def getRuleIndex(self):
            return blendedParser.RULE_doStatement

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterDoStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitDoStatement(self)




    def doStatement(self):

        localctx = blendedParser.DoStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_doStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 253
            self.match(blendedParser.LTAG)
            self.state = 254
            self.match(blendedParser.DO)
            self.state = 257
            la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
            if la_ == 1:
                self.state = 255
                self.setVar()
                pass

            elif la_ == 2:
                self.state = 256
                self.expression(0)
                pass


            self.state = 259
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class RenderStatementContext(ParserRuleContext):

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

        def LREN(self):
            return self.getToken(blendedParser.LREN, 0)

        def attributeVariable(self):
            return self.getTypedRuleContext(blendedParser.AttributeVariableContext,0)


        def RREN(self):
            return self.getToken(blendedParser.RREN, 0)

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

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

        def getRuleIndex(self):
            return blendedParser.RULE_renderStatement

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterRenderStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitRenderStatement(self)




    def renderStatement(self):

        localctx = blendedParser.RenderStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_renderStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 261
            self.match(blendedParser.LREN)
            self.state = 262
            self.attributeVariable()
            self.state = 266
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==blendedParser.EFILTER or _la==blendedParser.IFILTER:
                self.state = 263
                _la = self._input.LA(1)
                if not(_la==blendedParser.EFILTER or _la==blendedParser.IFILTER):
                    self._errHandler.recoverInline(self)
                else:
                    self.consume()
                self.state = 268
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 269
            self.match(blendedParser.RREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ForTagContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def FOR(self):
            return self.getToken(blendedParser.FOR, 0)

        def identifier(self):
            return self.getTypedRuleContext(blendedParser.IdentifierContext,0)


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

        def expression(self):
            return self.getTypedRuleContext(blendedParser.ExpressionContext,0)


        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_forTag

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterForTag(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitForTag(self)




    def forTag(self):

        localctx = blendedParser.ForTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_forTag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 271
            self.match(blendedParser.LTAG)
            self.state = 272
            self.match(blendedParser.FOR)
            self.state = 273
            self.identifier()
            self.state = 274
            self.match(blendedParser.IN)
            self.state = 275
            self.expression(0)
            self.state = 276
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ForItemsTagContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def FOR(self):
            return self.getToken(blendedParser.FOR, 0)

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(blendedParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(blendedParser.IdentifierContext,i)


        def COMMA(self):
            return self.getToken(blendedParser.COMMA, 0)

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

        def ITEMS(self):
            return self.getToken(blendedParser.ITEMS, 0)

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

        def expression(self):
            return self.getTypedRuleContext(blendedParser.ExpressionContext,0)


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

        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_forItemsTag

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterForItemsTag(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitForItemsTag(self)




    def forItemsTag(self):

        localctx = blendedParser.ForItemsTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_forItemsTag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 278
            self.match(blendedParser.LTAG)
            self.state = 279
            self.match(blendedParser.FOR)
            self.state = 280
            self.identifier()
            self.state = 281
            self.match(blendedParser.COMMA)
            self.state = 282
            self.identifier()
            self.state = 283
            self.match(blendedParser.IN)
            self.state = 284
            self.match(blendedParser.ITEMS)
            self.state = 285
            self.match(blendedParser.LPAREN)
            self.state = 286
            self.expression(0)
            self.state = 287
            self.match(blendedParser.RPAREN)
            self.state = 288
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EndForTagContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def ENDFOR(self):
            return self.getToken(blendedParser.ENDFOR, 0)

        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_endForTag

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterEndForTag(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitEndForTag(self)




    def endForTag(self):

        localctx = blendedParser.EndForTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_endForTag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 290
            self.match(blendedParser.LTAG)
            self.state = 291
            self.match(blendedParser.ENDFOR)
            self.state = 292
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BlockTagContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def BLOCK(self):
            return self.getToken(blendedParser.BLOCK, 0)

        def identifier(self):
            return self.getTypedRuleContext(blendedParser.IdentifierContext,0)


        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_blockTag

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterBlockTag(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitBlockTag(self)




    def blockTag(self):

        localctx = blendedParser.BlockTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_blockTag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 294
            self.match(blendedParser.LTAG)
            self.state = 295
            self.match(blendedParser.BLOCK)
            self.state = 296
            self.identifier()
            self.state = 297
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EndblockTagContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def ENDBLOCK(self):
            return self.getToken(blendedParser.ENDBLOCK, 0)

        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_endblockTag

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterEndblockTag(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitEndblockTag(self)




    def endblockTag(self):

        localctx = blendedParser.EndblockTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_endblockTag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 299
            self.match(blendedParser.LTAG)
            self.state = 300
            self.match(blendedParser.ENDBLOCK)
            self.state = 301
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ParentTagContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def PARENT(self):
            return self.getToken(blendedParser.PARENT, 0)

        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_parentTag

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterParentTag(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitParentTag(self)




    def parentTag(self):

        localctx = blendedParser.ParentTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_parentTag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 303
            self.match(blendedParser.LTAG)
            self.state = 304
            self.match(blendedParser.PARENT)
            self.state = 305
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class MacroTagContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def MACRO(self):
            return self.getToken(blendedParser.MACRO, 0)

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(blendedParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(blendedParser.IdentifierContext,i)


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

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

        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

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

        def getRuleIndex(self):
            return blendedParser.RULE_macroTag

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterMacroTag(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitMacroTag(self)




    def macroTag(self):

        localctx = blendedParser.MacroTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_macroTag)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 307
            self.match(blendedParser.LTAG)
            self.state = 308
            self.match(blendedParser.MACRO)
            self.state = 309
            self.identifier()
            self.state = 310
            self.match(blendedParser.LPAREN)
            self.state = 319
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << blendedParser.ID) | (1 << blendedParser.IN) | (1 << blendedParser.AND) | (1 << blendedParser.OR) | (1 << blendedParser.NOT) | (1 << blendedParser.IGNORE) | (1 << blendedParser.WITH) | (1 << blendedParser.ONLY) | (1 << blendedParser.BLOCK) | (1 << blendedParser.PARENT) | (1 << blendedParser.ENDBLOCK) | (1 << blendedParser.INCLUDE) | (1 << blendedParser.EXTENDS) | (1 << blendedParser.SET) | (1 << blendedParser.PRINT) | (1 << blendedParser.FOR) | (1 << blendedParser.ENDFOR) | (1 << blendedParser.MACRO) | (1 << blendedParser.ENDMACRO) | (1 << blendedParser.DO) | (1 << blendedParser.IF) | (1 << blendedParser.ELSE) | (1 << blendedParser.ENDIF) | (1 << blendedParser.ITEMS) | (1 << blendedParser.COMMENT) | (1 << blendedParser.ENDCOMMENT))) != 0):
                self.state = 311
                self.identifier()
                self.state = 316
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==blendedParser.COMMA:
                    self.state = 312
                    self.match(blendedParser.COMMA)
                    self.state = 313
                    self.identifier()
                    self.state = 318
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 321
            self.match(blendedParser.RPAREN)
            self.state = 322
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EndmacroTagContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def ENDMACRO(self):
            return self.getToken(blendedParser.ENDMACRO, 0)

        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_endmacroTag

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterEndmacroTag(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitEndmacroTag(self)




    def endmacroTag(self):

        localctx = blendedParser.EndmacroTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_endmacroTag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 324
            self.match(blendedParser.LTAG)
            self.state = 325
            self.match(blendedParser.ENDMACRO)
            self.state = 326
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class IfTagContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

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

        def expression(self):
            return self.getTypedRuleContext(blendedParser.ExpressionContext,0)


        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_ifTag

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterIfTag(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitIfTag(self)




    def ifTag(self):

        localctx = blendedParser.IfTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_ifTag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 328
            self.match(blendedParser.LTAG)
            self.state = 329
            self.match(blendedParser.IF)
            self.state = 330
            self.expression(0)
            self.state = 331
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ElseTagContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

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

        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_elseTag

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterElseTag(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitElseTag(self)




    def elseTag(self):

        localctx = blendedParser.ElseTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_elseTag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 333
            self.match(blendedParser.LTAG)
            self.state = 334
            self.match(blendedParser.ELSE)
            self.state = 335
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EndifTagContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def ENDIF(self):
            return self.getToken(blendedParser.ENDIF, 0)

        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_endifTag

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterEndifTag(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitEndifTag(self)




    def endifTag(self):

        localctx = blendedParser.EndifTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_endifTag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 337
            self.match(blendedParser.LTAG)
            self.state = 338
            self.match(blendedParser.ENDIF)
            self.state = 339
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CommentTagContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def COMMENT(self):
            return self.getToken(blendedParser.COMMENT, 0)

        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_commentTag

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterCommentTag(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitCommentTag(self)




    def commentTag(self):

        localctx = blendedParser.CommentTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_commentTag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 341
            self.match(blendedParser.LTAG)
            self.state = 342
            self.match(blendedParser.COMMENT)
            self.state = 343
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EndcommentTagContext(ParserRuleContext):

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

        def LTAG(self):
            return self.getToken(blendedParser.LTAG, 0)

        def ENDCOMMENT(self):
            return self.getToken(blendedParser.ENDCOMMENT, 0)

        def RTAG(self):
            return self.getToken(blendedParser.RTAG, 0)

        def getRuleIndex(self):
            return blendedParser.RULE_endcommentTag

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterEndcommentTag(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitEndcommentTag(self)




    def endcommentTag(self):

        localctx = blendedParser.EndcommentTagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_endcommentTag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 345
            self.match(blendedParser.LTAG)
            self.state = 346
            self.match(blendedParser.ENDCOMMENT)
            self.state = 347
            self.match(blendedParser.RTAG)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PathStringContext(ParserRuleContext):

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

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

        def path(self):
            return self.getTypedRuleContext(blendedParser.PathContext,0)


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

        def getRuleIndex(self):
            return blendedParser.RULE_pathString

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterPathString(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitPathString(self)




    def pathString(self):

        localctx = blendedParser.PathStringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_pathString)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 357
            token = self._input.LA(1)
            if token in [blendedParser.QUOTE]:
                self.state = 349
                self.match(blendedParser.QUOTE)
                self.state = 350
                self.path()
                self.state = 351
                self.match(blendedParser.QUOTE)

            elif token in [blendedParser.APO]:
                self.state = 353
                self.match(blendedParser.APO)
                self.state = 354
                self.path()
                self.state = 355
                self.match(blendedParser.APO)

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

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(blendedParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(blendedParser.IdentifierContext,i)


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

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

        def getRuleIndex(self):
            return blendedParser.RULE_path

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterPath(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitPath(self)




    def path(self):

        localctx = blendedParser.PathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_path)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 360
            _la = self._input.LA(1)
            if _la==blendedParser.FSLASH:
                self.state = 359
                self.match(blendedParser.FSLASH)


            self.state = 362
            self.identifier()
            self.state = 367
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==blendedParser.FSLASH:
                self.state = 363
                self.match(blendedParser.FSLASH)
                self.state = 364
                self.identifier()
                self.state = 369
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 370
            self.match(blendedParser.DOT)
            self.state = 371
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SetVarContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(blendedParser.IdentifierContext,0)


        def ASSIGN(self):
            return self.getToken(blendedParser.ASSIGN, 0)

        def expression(self):
            return self.getTypedRuleContext(blendedParser.ExpressionContext,0)


        def getRuleIndex(self):
            return blendedParser.RULE_setVar

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterSetVar(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitSetVar(self)




    def setVar(self):

        localctx = blendedParser.SetVarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_setVar)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 373
            self.identifier()
            self.state = 374
            self.match(blendedParser.ASSIGN)
            self.state = 375
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ExpressionContext(ParserRuleContext):

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

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(blendedParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(blendedParser.ExpressionContext,i)


        def SUB(self):
            return self.getToken(blendedParser.SUB, 0)

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

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

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

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

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

        def LBRACE(self):
            return self.getToken(blendedParser.LBRACE, 0)

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

        def RBRACE(self):
            return self.getToken(blendedParser.RBRACE, 0)

        def stringVar(self):
            return self.getTypedRuleContext(blendedParser.StringVarContext,0)


        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(blendedParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(blendedParser.IdentifierContext,i)


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

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

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

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

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

        def NOTEQUAL(self):
            return self.getToken(blendedParser.NOTEQUAL, 0)

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

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

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

        def CARET(self):
            return self.getToken(blendedParser.CARET, 0)

        def MUL(self):
            return self.getToken(blendedParser.MUL, 0)

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

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

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

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

        def getRuleIndex(self):
            return blendedParser.RULE_expression

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitExpression(self)



    def expression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = blendedParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 70
        self.enterRecursionRule(localctx, 70, self.RULE_expression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 415
            la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
            if la_ == 1:
                self.state = 378
                self.match(blendedParser.NOT)
                self.state = 379
                self.expression(4)
                pass

            elif la_ == 2:
                self.state = 380
                self.match(blendedParser.SUB)
                self.state = 381
                self.expression(3)
                pass

            elif la_ == 3:
                self.state = 382
                self.match(blendedParser.LPAREN)
                self.state = 383
                self.expression(0)
                self.state = 384
                self.match(blendedParser.RPAREN)
                pass

            elif la_ == 4:
                self.state = 386
                self.match(blendedParser.LBRACK)
                self.state = 387
                self.expression(0)
                self.state = 392
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==blendedParser.COMMA:
                    self.state = 388
                    self.match(blendedParser.COMMA)
                    self.state = 389
                    self.expression(0)
                    self.state = 394
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 395
                self.match(blendedParser.RBRACK)
                pass

            elif la_ == 5:
                self.state = 397
                self.match(blendedParser.LBRACE)
                self.state = 398
                self.expression(0)
                self.state = 399
                self.match(blendedParser.COLON)
                self.state = 400
                self.expression(0)
                self.state = 408
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==blendedParser.COMMA:
                    self.state = 401
                    self.match(blendedParser.COMMA)
                    self.state = 402
                    self.expression(0)
                    self.state = 403
                    self.match(blendedParser.COLON)
                    self.state = 404
                    self.expression(0)
                    self.state = 410
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 411
                self.match(blendedParser.RBRACE)
                pass

            elif la_ == 6:
                self.state = 413
                self.stringVar()
                pass

            elif la_ == 7:
                self.state = 414
                self.identifier()
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 465
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,39,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 463
                    la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
                    if la_ == 1:
                        localctx = blendedParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 417
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 418
                        _la = self._input.LA(1)
                        if not(((((_la - 61)) & ~0x3f) == 0 and ((1 << (_la - 61)) & ((1 << (blendedParser.EQUAL - 61)) | (1 << (blendedParser.NOTEQUAL - 61)) | (1 << (blendedParser.GT - 61)) | (1 << (blendedParser.LT - 61)) | (1 << (blendedParser.LE - 61)) | (1 << (blendedParser.GE - 61)))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self.consume()
                        self.state = 419
                        self.expression(13)
                        pass

                    elif la_ == 2:
                        localctx = blendedParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 420
                        if not self.precpred(self._ctx, 11):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        self.state = 421
                        self.match(blendedParser.OR)
                        self.state = 422
                        self.expression(12)
                        pass

                    elif la_ == 3:
                        localctx = blendedParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 423
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 424
                        self.match(blendedParser.AND)
                        self.state = 425
                        self.expression(11)
                        pass

                    elif la_ == 4:
                        localctx = blendedParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 426
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 427
                        self.match(blendedParser.IN)
                        self.state = 428
                        self.expression(10)
                        pass

                    elif la_ == 5:
                        localctx = blendedParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 429
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 430
                        self.match(blendedParser.CARET)
                        self.state = 431
                        self.expression(8)
                        pass

                    elif la_ == 6:
                        localctx = blendedParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 432
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 433
                        _la = self._input.LA(1)
                        if not(((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (blendedParser.MUL - 69)) | (1 << (blendedParser.DIV - 69)) | (1 << (blendedParser.MOD - 69)))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self.consume()
                        self.state = 434
                        self.expression(7)
                        pass

                    elif la_ == 7:
                        localctx = blendedParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 435
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 436
                        _la = self._input.LA(1)
                        if not(_la==blendedParser.ADD or _la==blendedParser.SUB):
                            self._errHandler.recoverInline(self)
                        else:
                            self.consume()
                        self.state = 437
                        self.expression(6)
                        pass

                    elif la_ == 8:
                        localctx = blendedParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 438
                        if not self.precpred(self._ctx, 16):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
                        self.state = 439
                        self.match(blendedParser.LPAREN)
                        self.state = 448
                        _la = self._input.LA(1)
                        if ((((_la - 8)) & ~0x3f) == 0 and ((1 << (_la - 8)) & ((1 << (blendedParser.ID - 8)) | (1 << (blendedParser.IN - 8)) | (1 << (blendedParser.AND - 8)) | (1 << (blendedParser.OR - 8)) | (1 << (blendedParser.NOT - 8)) | (1 << (blendedParser.IGNORE - 8)) | (1 << (blendedParser.WITH - 8)) | (1 << (blendedParser.ONLY - 8)) | (1 << (blendedParser.BLOCK - 8)) | (1 << (blendedParser.PARENT - 8)) | (1 << (blendedParser.ENDBLOCK - 8)) | (1 << (blendedParser.INCLUDE - 8)) | (1 << (blendedParser.EXTENDS - 8)) | (1 << (blendedParser.SET - 8)) | (1 << (blendedParser.PRINT - 8)) | (1 << (blendedParser.FOR - 8)) | (1 << (blendedParser.ENDFOR - 8)) | (1 << (blendedParser.MACRO - 8)) | (1 << (blendedParser.ENDMACRO - 8)) | (1 << (blendedParser.DO - 8)) | (1 << (blendedParser.IF - 8)) | (1 << (blendedParser.ELSE - 8)) | (1 << (blendedParser.ENDIF - 8)) | (1 << (blendedParser.ITEMS - 8)) | (1 << (blendedParser.COMMENT - 8)) | (1 << (blendedParser.ENDCOMMENT - 8)) | (1 << (blendedParser.QUOTE - 8)) | (1 << (blendedParser.APO - 8)) | (1 << (blendedParser.LPAREN - 8)) | (1 << (blendedParser.LBRACE - 8)) | (1 << (blendedParser.LBRACK - 8)) | (1 << (blendedParser.SUB - 8)))) != 0):
                            self.state = 440
                            self.expression(0)
                            self.state = 445
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            while _la==blendedParser.COMMA:
                                self.state = 441
                                self.match(blendedParser.COMMA)
                                self.state = 442
                                self.expression(0)
                                self.state = 447
                                self._errHandler.sync(self)
                                _la = self._input.LA(1)



                        self.state = 450
                        self.match(blendedParser.RPAREN)
                        pass

                    elif la_ == 9:
                        localctx = blendedParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 451
                        if not self.precpred(self._ctx, 15):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 15)")
                        self.state = 452
                        self.match(blendedParser.LBRACK)
                        self.state = 453
                        self.expression(0)
                        self.state = 454
                        self.match(blendedParser.RBRACK)
                        pass

                    elif la_ == 10:
                        localctx = blendedParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 456
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 459 
                        self._errHandler.sync(self)
                        _alt = 1
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt == 1:
                                self.state = 457
                                self.match(blendedParser.DOT)
                                self.state = 458
                                self.identifier()

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

                        pass

             
                self.state = 467
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,39,self._ctx)

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

    class AttributeVariableContext(ParserRuleContext):

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(blendedParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(blendedParser.IdentifierContext,i)


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

        def getRuleIndex(self):
            return blendedParser.RULE_attributeVariable

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterAttributeVariable(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitAttributeVariable(self)




    def attributeVariable(self):

        localctx = blendedParser.AttributeVariableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_attributeVariable)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 468
            self.identifier()
            self.state = 473
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==blendedParser.DOT:
                self.state = 469
                self.match(blendedParser.DOT)
                self.state = 470
                self.identifier()
                self.state = 475
                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 StringVarContext(ParserRuleContext):

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

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

        def text(self):
            return self.getTypedRuleContext(blendedParser.TextContext,0)


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

        def getRuleIndex(self):
            return blendedParser.RULE_stringVar

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterStringVar(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitStringVar(self)




    def stringVar(self):

        localctx = blendedParser.StringVarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_stringVar)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 484
            token = self._input.LA(1)
            if token in [blendedParser.APO]:
                self.state = 476
                self.match(blendedParser.APO)
                self.state = 477
                self.text()
                self.state = 478
                self.match(blendedParser.APO)

            elif token in [blendedParser.QUOTE]:
                self.state = 480
                self.match(blendedParser.QUOTE)
                self.state = 481
                self.text()
                self.state = 482
                self.match(blendedParser.QUOTE)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return blendedParser.RULE_identifier

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterIdentifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitIdentifier(self)




    def identifier(self):

        localctx = blendedParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_identifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 487 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 486
                    _la = self._input.LA(1)
                    if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << blendedParser.ID) | (1 << blendedParser.IN) | (1 << blendedParser.AND) | (1 << blendedParser.OR) | (1 << blendedParser.NOT) | (1 << blendedParser.IGNORE) | (1 << blendedParser.WITH) | (1 << blendedParser.ONLY) | (1 << blendedParser.BLOCK) | (1 << blendedParser.PARENT) | (1 << blendedParser.ENDBLOCK) | (1 << blendedParser.INCLUDE) | (1 << blendedParser.EXTENDS) | (1 << blendedParser.SET) | (1 << blendedParser.PRINT) | (1 << blendedParser.FOR) | (1 << blendedParser.ENDFOR) | (1 << blendedParser.MACRO) | (1 << blendedParser.ENDMACRO) | (1 << blendedParser.DO) | (1 << blendedParser.IF) | (1 << blendedParser.ELSE) | (1 << blendedParser.ENDIF) | (1 << blendedParser.ITEMS) | (1 << blendedParser.COMMENT) | (1 << blendedParser.ENDCOMMENT))) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self.consume()

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

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

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

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

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

        def getRuleIndex(self):
            return blendedParser.RULE_text

        def enterRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.enterText(self)

        def exitRule(self, listener:ParseTreeListener):
            if isinstance( listener, blendedParserListener ):
                listener.exitText(self)




    def text(self):

        localctx = blendedParser.TextContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_text)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 492 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 491
                    _la = self._input.LA(1)
                    if _la <= 0 or (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << blendedParser.RREN) | (1 << blendedParser.TWIG) | (1 << blendedParser.RTAG))) != 0):
                        self._errHandler.recoverInline(self)
                    else:
                        self.consume()

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

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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[35] = self.expression_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def expression_sempred(self, localctx:ExpressionContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 12)
         

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

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

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

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

            if predIndex == 5:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 6:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 16)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 15)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 8)
         



