# Generated from D:/Documents/pycharm_workspace/Qrogue/qrogue/game/world/dungeon_generator\QrogueDungeon.g4 by ANTLR 4.9.2
# encoding: utf-8
from __future__ import print_function
from antlr4 import *
from io import StringIO
import sys


def serializedATN():
    with StringIO() as buf:
        buf.write(u"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3")
        buf.write(u"Q\u01b7\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t")
        buf.write(u"\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
        buf.write(u"\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4")
        buf.write(u"\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30")
        buf.write(u"\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t")
        buf.write(u"\35\4\36\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$")
        buf.write(u"\t$\4%\t%\4&\t&\4\'\t\'\3\2\3\2\3\2\3\2\5\2S\n\2\3\2")
        buf.write(u"\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\4\5\4a\n\4")
        buf.write(u"\3\4\3\4\3\4\5\4f\n\4\3\4\3\4\5\4j\n\4\5\4l\n\4\3\5\3")
        buf.write(u"\5\3\5\3\5\3\5\3\5\3\5\7\5u\n\5\f\5\16\5x\13\5\3\5\3")
        buf.write(u"\5\3\6\3\6\7\6~\n\6\f\6\16\6\u0081\13\6\3\6\3\6\3\6\3")
        buf.write(u"\6\7\6\u0087\n\6\f\6\16\6\u008a\13\6\3\6\7\6\u008d\n")
        buf.write(u"\6\f\6\16\6\u0090\13\6\3\7\3\7\3\7\3\7\7\7\u0096\n\7")
        buf.write(u"\f\7\16\7\u0099\13\7\3\7\3\7\3\b\3\b\6\b\u009f\n\b\r")
        buf.write(u"\b\16\b\u00a0\3\b\3\b\3\t\3\t\7\t\u00a7\n\t\f\t\16\t")
        buf.write(u"\u00aa\13\t\3\n\3\n\3\n\3\n\7\n\u00b0\n\n\f\n\16\n\u00b3")
        buf.write(u"\13\n\3\n\6\n\u00b6\n\n\r\n\16\n\u00b7\3\n\7\n\u00bb")
        buf.write(u"\n\n\f\n\16\n\u00be\13\n\3\n\7\n\u00c1\n\n\f\n\16\n\u00c4")
        buf.write(u"\13\n\3\13\3\13\3\13\3\13\3\13\3\f\5\f\u00cc\n\f\3\r")
        buf.write(u"\3\r\3\16\3\16\6\16\u00d2\n\16\r\16\16\16\u00d3\3\16")
        buf.write(u"\3\16\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\5")
        buf.write(u"\20\u00e1\n\20\3\20\3\20\5\20\u00e5\n\20\3\20\3\20\5")
        buf.write(u"\20\u00e9\n\20\3\21\3\21\3\21\3\22\3\22\5\22\u00f0\n")
        buf.write(u"\22\3\22\3\22\3\23\3\23\3\23\5\23\u00f7\n\23\3\24\3\24")
        buf.write(u"\3\24\5\24\u00fc\n\24\3\25\3\25\3\25\3\26\3\26\3\26\5")
        buf.write(u"\26\u0104\n\26\3\26\3\26\5\26\u0108\n\26\3\27\3\27\3")
        buf.write(u"\27\5\27\u010d\n\27\3\27\3\27\3\30\3\30\7\30\u0113\n")
        buf.write(u"\30\f\30\16\30\u0116\13\30\3\31\3\31\3\31\3\32\3\32\3")
        buf.write(u"\32\3\32\3\32\3\32\5\32\u0121\n\32\3\32\3\32\3\32\5\32")
        buf.write(u"\u0126\n\32\5\32\u0128\n\32\3\32\3\32\3\32\3\32\3\32")
        buf.write(u"\7\32\u012f\n\32\f\32\16\32\u0132\13\32\3\32\5\32\u0135")
        buf.write(u"\n\32\3\32\3\32\3\32\5\32\u013a\n\32\3\32\3\32\5\32\u013e")
        buf.write(u"\n\32\3\33\3\33\3\34\3\34\3\34\6\34\u0145\n\34\r\34\16")
        buf.write(u"\34\u0146\5\34\u0149\n\34\3\34\3\34\3\34\3\35\3\35\5")
        buf.write(u"\35\u0150\n\35\3\35\5\35\u0153\n\35\3\36\3\36\5\36\u0157")
        buf.write(u"\n\36\3\36\3\36\3\36\3\36\3\36\5\36\u015e\n\36\3\37\3")
        buf.write(u"\37\3\37\3\37\7\37\u0164\n\37\f\37\16\37\u0167\13\37")
        buf.write(u"\3\37\3\37\3 \3 \3 \3 \7 \u016f\n \f \16 \u0172\13 \3")
        buf.write(u" \3 \3!\3!\3!\6!\u0179\n!\r!\16!\u017a\5!\u017d\n!\3")
        buf.write(u"!\3!\3!\3\"\3\"\5\"\u0184\n\"\3\"\5\"\u0187\n\"\3#\3")
        buf.write(u"#\5#\u018b\n#\3#\3#\3$\3$\3$\3$\7$\u0193\n$\f$\16$\u0196")
        buf.write(u"\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\5%\u01a4\n%")
        buf.write(u"\5%\u01a6\n%\3&\3&\7&\u01aa\n&\f&\16&\u01ad\13&\3\'\3")
        buf.write(u"\'\3\'\3\'\3\'\3\'\5\'\u01b5\n\'\3\'\2\2(\2\4\6\b\n\f")
        buf.write(u"\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>")
        buf.write(u"@BDFHJL\2\t\4\2\27\30LL\4\2GGKK\4\2FFLL\3\2 !\3\2\'-")
        buf.write(u"\4\2\n\21\27\27\3\2IJ\2\u01cf\2N\3\2\2\2\4]\3\2\2\2\6")
        buf.write(u"`\3\2\2\2\bm\3\2\2\2\n{\3\2\2\2\f\u0091\3\2\2\2\16\u009c")
        buf.write(u"\3\2\2\2\20\u00a4\3\2\2\2\22\u00ab\3\2\2\2\24\u00c5\3")
        buf.write(u"\2\2\2\26\u00cb\3\2\2\2\30\u00cd\3\2\2\2\32\u00cf\3\2")
        buf.write(u"\2\2\34\u00d7\3\2\2\2\36\u00e0\3\2\2\2 \u00ea\3\2\2\2")
        buf.write(u"\"\u00ed\3\2\2\2$\u00f3\3\2\2\2&\u00f8\3\2\2\2(\u00fd")
        buf.write(u"\3\2\2\2*\u0100\3\2\2\2,\u0109\3\2\2\2.\u0110\3\2\2\2")
        buf.write(u"\60\u0117\3\2\2\2\62\u011a\3\2\2\2\64\u013f\3\2\2\2\66")
        buf.write(u"\u0141\3\2\2\28\u0152\3\2\2\2:\u0154\3\2\2\2<\u015f\3")
        buf.write(u"\2\2\2>\u016a\3\2\2\2@\u0175\3\2\2\2B\u0186\3\2\2\2D")
        buf.write(u"\u0188\3\2\2\2F\u018e\3\2\2\2H\u01a5\3\2\2\2J\u01a7\3")
        buf.write(u"\2\2\2L\u01ae\3\2\2\2NR\78\2\2OP\7:\2\2PQ\7\3\2\2QS\7")
        buf.write(u"\37\2\2RO\3\2\2\2RS\3\2\2\2ST\3\2\2\2TU\5\b\5\2UV\5\n")
        buf.write(u"\6\2VW\5\20\t\2WX\5.\30\2XY\5\66\34\2YZ\5@!\2Z[\5J&\2")
        buf.write(u"[\\\79\2\2\\\3\3\2\2\2]^\t\2\2\2^\5\3\2\2\2_a\7\33\2")
        buf.write(u"\2`_\3\2\2\2`a\3\2\2\2ak\3\2\2\2bl\7\32\2\2cf\5\4\3\2")
        buf.write(u"df\7\31\2\2ec\3\2\2\2ed\3\2\2\2fi\3\2\2\2gh\7\33\2\2")
        buf.write(u"hj\7\32\2\2ig\3\2\2\2ij\3\2\2\2jl\3\2\2\2kb\3\2\2\2k")
        buf.write(u"e\3\2\2\2l\7\3\2\2\2mn\7;\2\2no\7\27\2\2op\7\4\2\2pq")
        buf.write(u"\7\5\2\2qv\7M\2\2rs\7D\2\2su\7M\2\2tr\3\2\2\2ux\3\2\2")
        buf.write(u"\2vt\3\2\2\2vw\3\2\2\2wy\3\2\2\2xv\3\2\2\2yz\7\6\2\2")
        buf.write(u"z\t\3\2\2\2{\177\7<\2\2|~\7B\2\2}|\3\2\2\2~\u0081\3\2")
        buf.write(u"\2\2\177}\3\2\2\2\177\u0080\3\2\2\2\u0080\u0082\3\2\2")
        buf.write(u"\2\u0081\177\3\2\2\2\u0082\u0088\5\f\7\2\u0083\u0084")
        buf.write(u"\5\16\b\2\u0084\u0085\5\f\7\2\u0085\u0087\3\2\2\2\u0086")
        buf.write(u"\u0083\3\2\2\2\u0087\u008a\3\2\2\2\u0088\u0086\3\2\2")
        buf.write(u"\2\u0088\u0089\3\2\2\2\u0089\u008e\3\2\2\2\u008a\u0088")
        buf.write(u"\3\2\2\2\u008b\u008d\7B\2\2\u008c\u008b\3\2\2\2\u008d")
        buf.write(u"\u0090\3\2\2\2\u008e\u008c\3\2\2\2\u008e\u008f\3\2\2")
        buf.write(u"\2\u008f\13\3\2\2\2\u0090\u008e\3\2\2\2\u0091\u0092\7")
        buf.write(u"C\2\2\u0092\u0097\t\3\2\2\u0093\u0094\t\4\2\2\u0094\u0096")
        buf.write(u"\t\3\2\2\u0095\u0093\3\2\2\2\u0096\u0099\3\2\2\2\u0097")
        buf.write(u"\u0095\3\2\2\2\u0097\u0098\3\2\2\2\u0098\u009a\3\2\2")
        buf.write(u"\2\u0099\u0097\3\2\2\2\u009a\u009b\7C\2\2\u009b\r\3\2")
        buf.write(u"\2\2\u009c\u009e\7C\2\2\u009d\u009f\t\4\2\2\u009e\u009d")
        buf.write(u"\3\2\2\2\u009f\u00a0\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0")
        buf.write(u"\u00a1\3\2\2\2\u00a1\u00a2\3\2\2\2\u00a2\u00a3\7C\2\2")
        buf.write(u"\u00a3\17\3\2\2\2\u00a4\u00a8\7=\2\2\u00a5\u00a7\5\22")
        buf.write(u"\n\2\u00a6\u00a5\3\2\2\2\u00a7\u00aa\3\2\2\2\u00a8\u00a6")
        buf.write(u"\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\21\3\2\2\2\u00aa\u00a8")
        buf.write(u"\3\2\2\2\u00ab\u00ac\7K\2\2\u00ac\u00ad\5\24\13\2\u00ad")
        buf.write(u"\u00b1\7\7\2\2\u00ae\u00b0\7E\2\2\u00af\u00ae\3\2\2\2")
        buf.write(u"\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2")
        buf.write(u"\3\2\2\2\u00b2\u00b5\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4")
        buf.write(u"\u00b6\5\32\16\2\u00b5\u00b4\3\2\2\2\u00b6\u00b7\3\2")
        buf.write(u"\2\2\u00b7\u00b5\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00bc")
        buf.write(u"\3\2\2\2\u00b9\u00bb\7E\2\2\u00ba\u00b9\3\2\2\2\u00bb")
        buf.write(u"\u00be\3\2\2\2\u00bc\u00ba\3\2\2\2\u00bc\u00bd\3\2\2")
        buf.write(u"\2\u00bd\u00c2\3\2\2\2\u00be\u00bc\3\2\2\2\u00bf\u00c1")
        buf.write(u"\5\36\20\2\u00c0\u00bf\3\2\2\2\u00c1\u00c4\3\2\2\2\u00c2")
        buf.write(u"\u00c0\3\2\2\2\u00c2\u00c3\3\2\2\2\u00c3\23\3\2\2\2\u00c4")
        buf.write(u"\u00c2\3\2\2\2\u00c5\u00c6\7\b\2\2\u00c6\u00c7\5\26\f")
        buf.write(u"\2\u00c7\u00c8\5\30\r\2\u00c8\u00c9\7\t\2\2\u00c9\25")
        buf.write(u"\3\2\2\2\u00ca\u00cc\t\5\2\2\u00cb\u00ca\3\2\2\2\u00cb")
        buf.write(u"\u00cc\3\2\2\2\u00cc\27\3\2\2\2\u00cd\u00ce\t\6\2\2\u00ce")
        buf.write(u"\31\3\2\2\2\u00cf\u00d1\7E\2\2\u00d0\u00d2\5\34\17\2")
        buf.write(u"\u00d1\u00d0\3\2\2\2\u00d2\u00d3\3\2\2\2\u00d3\u00d1")
        buf.write(u"\3\2\2\2\u00d3\u00d4\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5")
        buf.write(u"\u00d6\7E\2\2\u00d6\33\3\2\2\2\u00d7\u00d8\t\7\2\2\u00d8")
        buf.write(u"\35\3\2\2\2\u00d9\u00e1\5 \21\2\u00da\u00e1\5\"\22\2")
        buf.write(u"\u00db\u00e1\5$\23\2\u00dc\u00e1\5&\24\2\u00dd\u00e1")
        buf.write(u"\5(\25\2\u00de\u00e1\5*\26\2\u00df\u00e1\5,\27\2\u00e0")
        buf.write(u"\u00d9\3\2\2\2\u00e0\u00da\3\2\2\2\u00e0\u00db\3\2\2")
        buf.write(u"\2\u00e0\u00dc\3\2\2\2\u00e0\u00dd\3\2\2\2\u00e0\u00de")
        buf.write(u"\3\2\2\2\u00e0\u00df\3\2\2\2\u00e1\u00e4\3\2\2\2\u00e2")
        buf.write(u"\u00e3\7.\2\2\u00e3\u00e5\7M\2\2\u00e4\u00e2\3\2\2\2")
        buf.write(u"\u00e4\u00e5\3\2\2\2\u00e5\u00e8\3\2\2\2\u00e6\u00e7")
        buf.write(u"\7/\2\2\u00e7\u00e9\7M\2\2\u00e8\u00e6\3\2\2\2\u00e8")
        buf.write(u"\u00e9\3\2\2\2\u00e9\37\3\2\2\2\u00ea\u00eb\7\13\2\2")
        buf.write(u"\u00eb\u00ec\7M\2\2\u00ec!\3\2\2\2\u00ed\u00ef\7\f\2")
        buf.write(u"\2\u00ee\u00f0\5\4\3\2\u00ef\u00ee\3\2\2\2\u00ef\u00f0")
        buf.write(u"\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f2\7M\2\2\u00f2")
        buf.write(u"#\3\2\2\2\u00f3\u00f4\7\27\2\2\u00f4\u00f6\7M\2\2\u00f5")
        buf.write(u"\u00f7\7M\2\2\u00f6\u00f5\3\2\2\2\u00f6\u00f7\3\2\2\2")
        buf.write(u"\u00f7%\3\2\2\2\u00f8\u00f9\7\r\2\2\u00f9\u00fb\7M\2")
        buf.write(u"\2\u00fa\u00fc\5\4\3\2\u00fb\u00fa\3\2\2\2\u00fb\u00fc")
        buf.write(u"\3\2\2\2\u00fc\'\3\2\2\2\u00fd\u00fe\7\16\2\2\u00fe\u00ff")
        buf.write(u"\5\4\3\2\u00ff)\3\2\2\2\u0100\u0103\7\17\2\2\u0101\u0104")
        buf.write(u"\7M\2\2\u0102\u0104\5> \2\u0103\u0101\3\2\2\2\u0103\u0102")
        buf.write(u"\3\2\2\2\u0104\u0107\3\2\2\2\u0105\u0108\7M\2\2\u0106")
        buf.write(u"\u0108\5H%\2\u0107\u0105\3\2\2\2\u0107\u0106\3\2\2\2")
        buf.write(u"\u0108+\3\2\2\2\u0109\u010c\7\20\2\2\u010a\u010d\7M\2")
        buf.write(u"\2\u010b\u010d\5F$\2\u010c\u010a\3\2\2\2\u010c\u010b")
        buf.write(u"\3\2\2\2\u010d\u010e\3\2\2\2\u010e\u010f\5\4\3\2\u010f")
        buf.write(u"-\3\2\2\2\u0110\u0114\7>\2\2\u0111\u0113\5\60\31\2\u0112")
        buf.write(u"\u0111\3\2\2\2\u0113\u0116\3\2\2\2\u0114\u0112\3\2\2")
        buf.write(u"\2\u0114\u0115\3\2\2\2\u0115/\3\2\2\2\u0116\u0114\3\2")
        buf.write(u"\2\2\u0117\u0118\7L\2\2\u0118\u0119\5\62\32\2\u0119\61")
        buf.write(u"\3\2\2\2\u011a\u0120\7\b\2\2\u011b\u0121\7\"\2\2\u011c")
        buf.write(u"\u0121\7#\2\2\u011d\u0121\7$\2\2\u011e\u011f\7%\2\2\u011f")
        buf.write(u"\u0121\7M\2\2\u0120\u011b\3\2\2\2\u0120\u011c\3\2\2\2")
        buf.write(u"\u0120\u011d\3\2\2\2\u0120\u011e\3\2\2\2\u0121\u0127")
        buf.write(u"\3\2\2\2\u0122\u0123\7\22\2\2\u0123\u0125\7H\2\2\u0124")
        buf.write(u"\u0126\7&\2\2\u0125\u0124\3\2\2\2\u0125\u0126\3\2\2\2")
        buf.write(u"\u0126\u0128\3\2\2\2\u0127\u0122\3\2\2\2\u0127\u0128")
        buf.write(u"\3\2\2\2\u0128\u0134\3\2\2\2\u0129\u012a\7\23\2\2\u012a")
        buf.write(u"\u012b\7\5\2\2\u012b\u0130\7L\2\2\u012c\u012d\7D\2\2")
        buf.write(u"\u012d\u012f\7L\2\2\u012e\u012c\3\2\2\2\u012f\u0132\3")
        buf.write(u"\2\2\2\u0130\u012e\3\2\2\2\u0130\u0131\3\2\2\2\u0131")
        buf.write(u"\u0133\3\2\2\2\u0132\u0130\3\2\2\2\u0133\u0135\7\6\2")
        buf.write(u"\2\u0134\u0129\3\2\2\2\u0134\u0135\3\2\2\2\u0135\u0136")
        buf.write(u"\3\2\2\2\u0136\u0139\7\t\2\2\u0137\u0138\7.\2\2\u0138")
        buf.write(u"\u013a\7M\2\2\u0139\u0137\3\2\2\2\u0139\u013a\3\2\2\2")
        buf.write(u"\u013a\u013d\3\2\2\2\u013b\u013c\7/\2\2\u013c\u013e\7")
        buf.write(u"M\2\2\u013d\u013b\3\2\2\2\u013d\u013e\3\2\2\2\u013e\63")
        buf.write(u"\3\2\2\2\u013f\u0140\t\b\2\2\u0140\65\3\2\2\2\u0141\u0148")
        buf.write(u"\7?\2\2\u0142\u0144\7\24\2\2\u0143\u0145\5:\36\2\u0144")
        buf.write(u"\u0143\3\2\2\2\u0145\u0146\3\2\2\2\u0146\u0144\3\2\2")
        buf.write(u"\2\u0146\u0147\3\2\2\2\u0147\u0149\3\2\2\2\u0148\u0142")
        buf.write(u"\3\2\2\2\u0148\u0149\3\2\2\2\u0149\u014a\3\2\2\2\u014a")
        buf.write(u"\u014b\7\25\2\2\u014b\u014c\58\35\2\u014c\67\3\2\2\2")
        buf.write(u"\u014d\u0153\7M\2\2\u014e\u0150\5\64\33\2\u014f\u014e")
        buf.write(u"\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0151\3\2\2\2\u0151")
        buf.write(u"\u0153\5<\37\2\u0152\u014d\3\2\2\2\u0152\u014f\3\2\2")
        buf.write(u"\2\u01539\3\2\2\2\u0154\u0156\7M\2\2\u0155\u0157\5\64")
        buf.write(u"\33\2\u0156\u0155\3\2\2\2\u0156\u0157\3\2\2\2\u0157\u0158")
        buf.write(u"\3\2\2\2\u0158\u015d\5<\37\2\u0159\u015a\7\25\2\2\u015a")
        buf.write(u"\u015b\7\26\2\2\u015b\u015c\7\7\2\2\u015c\u015e\7M\2")
        buf.write(u"\2\u015d\u0159\3\2\2\2\u015d\u015e\3\2\2\2\u015e;\3\2")
        buf.write(u"\2\2\u015f\u0160\7\5\2\2\u0160\u0165\5> \2\u0161\u0162")
        buf.write(u"\7D\2\2\u0162\u0164\5> \2\u0163\u0161\3\2\2\2\u0164\u0167")
        buf.write(u"\3\2\2\2\u0165\u0163\3\2\2\2\u0165\u0166\3\2\2\2\u0166")
        buf.write(u"\u0168\3\2\2\2\u0167\u0165\3\2\2\2\u0168\u0169\7\6\2")
        buf.write(u"\2\u0169=\3\2\2\2\u016a\u016b\7\5\2\2\u016b\u0170\5\6")
        buf.write(u"\4\2\u016c\u016d\7D\2\2\u016d\u016f\5\6\4\2\u016e\u016c")
        buf.write(u"\3\2\2\2\u016f\u0172\3\2\2\2\u0170\u016e\3\2\2\2\u0170")
        buf.write(u"\u0171\3\2\2\2\u0171\u0173\3\2\2\2\u0172\u0170\3\2\2")
        buf.write(u"\2\u0173\u0174\7\6\2\2\u0174?\3\2\2\2\u0175\u017c\7@")
        buf.write(u"\2\2\u0176\u0178\7\24\2\2\u0177\u0179\5D#\2\u0178\u0177")
        buf.write(u"\3\2\2\2\u0179\u017a\3\2\2\2\u017a\u0178\3\2\2\2\u017a")
        buf.write(u"\u017b\3\2\2\2\u017b\u017d\3\2\2\2\u017c\u0176\3\2\2")
        buf.write(u"\2\u017c\u017d\3\2\2\2\u017d\u017e\3\2\2\2\u017e\u017f")
        buf.write(u"\7\25\2\2\u017f\u0180\5B\"\2\u0180A\3\2\2\2\u0181\u0187")
        buf.write(u"\7M\2\2\u0182\u0184\5\64\33\2\u0183\u0182\3\2\2\2\u0183")
        buf.write(u"\u0184\3\2\2\2\u0184\u0185\3\2\2\2\u0185\u0187\5F$\2")
        buf.write(u"\u0186\u0181\3\2\2\2\u0186\u0183\3\2\2\2\u0187C\3\2\2")
        buf.write(u"\2\u0188\u018a\7M\2\2\u0189\u018b\5\64\33\2\u018a\u0189")
        buf.write(u"\3\2\2\2\u018a\u018b\3\2\2\2\u018b\u018c\3\2\2\2\u018c")
        buf.write(u"\u018d\5F$\2\u018dE\3\2\2\2\u018e\u018f\7\5\2\2\u018f")
        buf.write(u"\u0194\5H%\2\u0190\u0191\7D\2\2\u0191\u0193\5H%\2\u0192")
        buf.write(u"\u0190\3\2\2\2\u0193\u0196\3\2\2\2\u0194\u0192\3\2\2")
        buf.write(u"\2\u0194\u0195\3\2\2\2\u0195\u0197\3\2\2\2\u0196\u0194")
        buf.write(u"\3\2\2\2\u0197\u0198\7\6\2\2\u0198G\3\2\2\2\u0199\u019a")
        buf.write(u"\7\60\2\2\u019a\u01a6\5\4\3\2\u019b\u019c\7\61\2\2\u019c")
        buf.write(u"\u01a6\5\4\3\2\u019d\u019e\7\62\2\2\u019e\u01a6\5\4\3")
        buf.write(u"\2\u019f\u01a0\7\63\2\2\u01a0\u01a6\7M\2\2\u01a1\u01a3")
        buf.write(u"\7\64\2\2\u01a2\u01a4\5\4\3\2\u01a3\u01a2\3\2\2\2\u01a3")
        buf.write(u"\u01a4\3\2\2\2\u01a4\u01a6\3\2\2\2\u01a5\u0199\3\2\2")
        buf.write(u"\2\u01a5\u019b\3\2\2\2\u01a5\u019d\3\2\2\2\u01a5\u019f")
        buf.write(u"\3\2\2\2\u01a5\u01a1\3\2\2\2\u01a6I\3\2\2\2\u01a7\u01ab")
        buf.write(u"\7A\2\2\u01a8\u01aa\5L\'\2\u01a9\u01a8\3\2\2\2\u01aa")
        buf.write(u"\u01ad\3\2\2\2\u01ab\u01a9\3\2\2\2\u01ab\u01ac\3\2\2")
        buf.write(u"\2\u01acK\3\2\2\2\u01ad\u01ab\3\2\2\2\u01ae\u01af\7M")
        buf.write(u"\2\2\u01af\u01b4\7\37\2\2\u01b0\u01b1\7%\2\2\u01b1\u01b2")
        buf.write(u"\7M\2\2\u01b2\u01b3\7\65\2\2\u01b3\u01b5\7M\2\2\u01b4")
        buf.write(u"\u01b0\3\2\2\2\u01b4\u01b5\3\2\2\2\u01b5M\3\2\2\2\67")
        buf.write(u"R`eikv\177\u0088\u008e\u0097\u00a0\u00a8\u00b1\u00b7")
        buf.write(u"\u00bc\u00c2\u00cb\u00d3\u00e0\u00e4\u00e8\u00ef\u00f6")
        buf.write(u"\u00fb\u0103\u0107\u010c\u0114\u0120\u0125\u0127\u0130")
        buf.write(u"\u0134\u0139\u013d\u0146\u0148\u014f\u0152\u0156\u015d")
        buf.write(u"\u0165\u0170\u017a\u017c\u0183\u0186\u018a\u0194\u01a3")
        buf.write(u"\u01a5\u01ab\u01b4")
        return buf.getvalue()


class QrogueDungeonParser ( Parser ):

    grammarFileName = "QrogueDungeon.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ u"<INVALID>", u"'='", u"'qubits'", u"'['", u"']'", 
                     u"':'", u"'('", u"')'", u"'o'", u"'t'", u"'m'", u"'c'", 
                     u"'e'", u"'r'", u"'$'", u"'_'", u"'one way'", u"'entangled'", 
                     u"'custom'", u"'default'", u"'rewards'", u"<INVALID>", 
                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                     u"'visible'", u"'foggy'", u"'open'", u"'closed'", u"'locked'", 
                     u"'event'", u"'permanent'", u"'Spawn'", u"'Wild'", 
                     u"'Shop'", u"'Riddle'", u"'Boss'", u"'Gate'", u"'Treasure'", 
                     u"'tutorial'", u"'trigger'", u"'key'", u"'coin'", u"'energy'", 
                     u"'gate'", u"'qubit'", u"'alternative'", u"'+'", u"'-'", 
                     u"'Qrogue<'", u"'>Qrogue'", u"'Name'", u"'[Robot]'", 
                     u"'[Layout]'", u"'[Custom Rooms]'", u"'[Hallways]'", 
                     u"'[StateVector Pools]'", u"'[Reward Pools]'", u"'[Messages]'", 
                     u"'~'", u"'|'", u"','", u"'#'", u"'..'", u"'__'", u"<INVALID>", 
                     u"'ordered'", u"'random'" ]

    symbolicNames = [ u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                      u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                      u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                      u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                      u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                      u"<INVALID>", u"DIGIT", u"INTEGER", u"FLOAT", u"IMAG_NUMBER", 
                      u"SIGN", u"CHARACTER_LOW", u"CHARACTER_UP", u"CHARACTER", 
                      u"TEXT", u"VISIBLE_LITERAL", u"FOGGY_LITERAL", u"OPEN_LITERAL", 
                      u"CLOSED_LITERAL", u"LOCKED_LITERAL", u"EVENT_LITERAL", 
                      u"PERMANENT_LITERAL", u"SPAWN_LITERAL", u"WILD_LITERAL", 
                      u"SHOP_LITERAL", u"RIDDLE_LITERAL", u"BOSS_LITERAL", 
                      u"GATE_ROOM_LITERAL", u"TREASURE_LITERAL", u"TUTORIAL_LITERAL", 
                      u"TRIGGER_LITERAL", u"KEY_LITERAL", u"COIN_LITERAL", 
                      u"ENERGY_LITERAL", u"GATE_LITERAL", u"QUBIT_LITERAL", 
                      u"ALTERNATIVE_LITERAL", u"PLUS_SIGN", u"MINUS_SIGN", 
                      u"HEADER", u"ENDER", u"NAME", u"ROBOT", u"LAYOUT", 
                      u"ROOMS", u"HALLWAYS", u"STV_POOLS", u"REWARD_POOLS", 
                      u"MESSAGES", u"HORIZONTAL_SEPARATOR", u"VERTICAL_SEPARATOR", 
                      u"LIST_SEPARATOR", u"WALL", u"EMPTY_HALLWAY", u"EMPTY_ROOM", 
                      u"DIRECTION", u"ORDERED_DRAW", u"RANDOM_DRAW", u"ROOM_ID", 
                      u"HALLWAY_ID", u"REFERENCE", u"WS", u"UNIVERSAL_SEPARATOR", 
                      u"COMMENT", u"LINE_COMMENT" ]

    RULE_start = 0
    RULE_integer = 1
    RULE_complex_number = 2
    RULE_robot = 3
    RULE_layout = 4
    RULE_l_room_row = 5
    RULE_l_hallway_row = 6
    RULE_rooms = 7
    RULE_room = 8
    RULE_r_attributes = 9
    RULE_r_visibility = 10
    RULE_r_type = 11
    RULE_r_row = 12
    RULE_tile = 13
    RULE_tile_descriptor = 14
    RULE_trigger_descriptor = 15
    RULE_message_descriptor = 16
    RULE_enemy_descriptor = 17
    RULE_collectible_descriptor = 18
    RULE_energy_descriptor = 19
    RULE_riddle_descriptor = 20
    RULE_shop_descriptor = 21
    RULE_hallways = 22
    RULE_hallway = 23
    RULE_h_attributes = 24
    RULE_draw_strategy = 25
    RULE_stv_pools = 26
    RULE_default_stv_pool = 27
    RULE_stv_pool = 28
    RULE_stvs = 29
    RULE_stv = 30
    RULE_reward_pools = 31
    RULE_default_reward_pool = 32
    RULE_reward_pool = 33
    RULE_collectibles = 34
    RULE_collectible = 35
    RULE_messages = 36
    RULE_message = 37

    ruleNames =  [ u"start", u"integer", u"complex_number", u"robot", u"layout", 
                   u"l_room_row", u"l_hallway_row", u"rooms", u"room", u"r_attributes", 
                   u"r_visibility", u"r_type", u"r_row", u"tile", u"tile_descriptor", 
                   u"trigger_descriptor", u"message_descriptor", u"enemy_descriptor", 
                   u"collectible_descriptor", u"energy_descriptor", u"riddle_descriptor", 
                   u"shop_descriptor", u"hallways", u"hallway", u"h_attributes", 
                   u"draw_strategy", u"stv_pools", u"default_stv_pool", 
                   u"stv_pool", u"stvs", u"stv", u"reward_pools", u"default_reward_pool", 
                   u"reward_pool", u"collectibles", u"collectible", u"messages", 
                   u"message" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    DIGIT=21
    INTEGER=22
    FLOAT=23
    IMAG_NUMBER=24
    SIGN=25
    CHARACTER_LOW=26
    CHARACTER_UP=27
    CHARACTER=28
    TEXT=29
    VISIBLE_LITERAL=30
    FOGGY_LITERAL=31
    OPEN_LITERAL=32
    CLOSED_LITERAL=33
    LOCKED_LITERAL=34
    EVENT_LITERAL=35
    PERMANENT_LITERAL=36
    SPAWN_LITERAL=37
    WILD_LITERAL=38
    SHOP_LITERAL=39
    RIDDLE_LITERAL=40
    BOSS_LITERAL=41
    GATE_ROOM_LITERAL=42
    TREASURE_LITERAL=43
    TUTORIAL_LITERAL=44
    TRIGGER_LITERAL=45
    KEY_LITERAL=46
    COIN_LITERAL=47
    ENERGY_LITERAL=48
    GATE_LITERAL=49
    QUBIT_LITERAL=50
    ALTERNATIVE_LITERAL=51
    PLUS_SIGN=52
    MINUS_SIGN=53
    HEADER=54
    ENDER=55
    NAME=56
    ROBOT=57
    LAYOUT=58
    ROOMS=59
    HALLWAYS=60
    STV_POOLS=61
    REWARD_POOLS=62
    MESSAGES=63
    HORIZONTAL_SEPARATOR=64
    VERTICAL_SEPARATOR=65
    LIST_SEPARATOR=66
    WALL=67
    EMPTY_HALLWAY=68
    EMPTY_ROOM=69
    DIRECTION=70
    ORDERED_DRAW=71
    RANDOM_DRAW=72
    ROOM_ID=73
    HALLWAY_ID=74
    REFERENCE=75
    WS=76
    UNIVERSAL_SEPARATOR=77
    COMMENT=78
    LINE_COMMENT=79

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




    class StartContext(ParserRuleContext):

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

        def HEADER(self):
            return self.getToken(QrogueDungeonParser.HEADER, 0)

        def robot(self):
            return self.getTypedRuleContext(QrogueDungeonParser.RobotContext,0)


        def layout(self):
            return self.getTypedRuleContext(QrogueDungeonParser.LayoutContext,0)


        def rooms(self):
            return self.getTypedRuleContext(QrogueDungeonParser.RoomsContext,0)


        def hallways(self):
            return self.getTypedRuleContext(QrogueDungeonParser.HallwaysContext,0)


        def stv_pools(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Stv_poolsContext,0)


        def reward_pools(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Reward_poolsContext,0)


        def messages(self):
            return self.getTypedRuleContext(QrogueDungeonParser.MessagesContext,0)


        def ENDER(self):
            return self.getToken(QrogueDungeonParser.ENDER, 0)

        def NAME(self):
            return self.getToken(QrogueDungeonParser.NAME, 0)

        def TEXT(self):
            return self.getToken(QrogueDungeonParser.TEXT, 0)

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_start

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

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

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




    def start(self):

        localctx = QrogueDungeonParser.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 = 76
            self.match(QrogueDungeonParser.HEADER)
            self.state = 80
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.NAME:
                self.state = 77
                self.match(QrogueDungeonParser.NAME)
                self.state = 78
                self.match(QrogueDungeonParser.T__0)
                self.state = 79
                self.match(QrogueDungeonParser.TEXT)


            self.state = 82
            self.robot()
            self.state = 83
            self.layout()
            self.state = 84
            self.rooms()
            self.state = 85
            self.hallways()
            self.state = 86
            self.stv_pools()
            self.state = 87
            self.reward_pools()
            self.state = 88
            self.messages()
            self.state = 89
            self.match(QrogueDungeonParser.ENDER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IntegerContext(ParserRuleContext):

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

        def DIGIT(self):
            return self.getToken(QrogueDungeonParser.DIGIT, 0)

        def HALLWAY_ID(self):
            return self.getToken(QrogueDungeonParser.HALLWAY_ID, 0)

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_integer

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

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

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




    def integer(self):

        localctx = QrogueDungeonParser.IntegerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_integer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 91
            _la = self._input.LA(1)
            if not(((((_la - 21)) & ~0x3f) == 0 and ((1 << (_la - 21)) & ((1 << (QrogueDungeonParser.DIGIT - 21)) | (1 << (QrogueDungeonParser.INTEGER - 21)) | (1 << (QrogueDungeonParser.HALLWAY_ID - 21)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Complex_numberContext(ParserRuleContext):

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

        def IMAG_NUMBER(self):
            return self.getToken(QrogueDungeonParser.IMAG_NUMBER, 0)

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

        def integer(self):
            return self.getTypedRuleContext(QrogueDungeonParser.IntegerContext,0)


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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_complex_number

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

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

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




    def complex_number(self):

        localctx = QrogueDungeonParser.Complex_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_complex_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 94
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.SIGN:
                self.state = 93
                self.match(QrogueDungeonParser.SIGN)


            self.state = 105
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [QrogueDungeonParser.IMAG_NUMBER]:
                self.state = 96
                self.match(QrogueDungeonParser.IMAG_NUMBER)
                pass
            elif token in [QrogueDungeonParser.DIGIT, QrogueDungeonParser.INTEGER, QrogueDungeonParser.FLOAT, QrogueDungeonParser.HALLWAY_ID]:
                self.state = 99
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [QrogueDungeonParser.DIGIT, QrogueDungeonParser.INTEGER, QrogueDungeonParser.HALLWAY_ID]:
                    self.state = 97
                    self.integer()
                    pass
                elif token in [QrogueDungeonParser.FLOAT]:
                    self.state = 98
                    self.match(QrogueDungeonParser.FLOAT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 103
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==QrogueDungeonParser.SIGN:
                    self.state = 101
                    self.match(QrogueDungeonParser.SIGN)
                    self.state = 102
                    self.match(QrogueDungeonParser.IMAG_NUMBER)


                pass
            else:
                raise NoViableAltException(self)

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


    class RobotContext(ParserRuleContext):

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

        def ROBOT(self):
            return self.getToken(QrogueDungeonParser.ROBOT, 0)

        def DIGIT(self):
            return self.getToken(QrogueDungeonParser.DIGIT, 0)

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

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_robot

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

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

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




    def robot(self):

        localctx = QrogueDungeonParser.RobotContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_robot)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 107
            self.match(QrogueDungeonParser.ROBOT)
            self.state = 108
            self.match(QrogueDungeonParser.DIGIT)
            self.state = 109
            self.match(QrogueDungeonParser.T__1)
            self.state = 110
            self.match(QrogueDungeonParser.T__2)
            self.state = 111
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 116
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==QrogueDungeonParser.LIST_SEPARATOR:
                self.state = 112
                self.match(QrogueDungeonParser.LIST_SEPARATOR)
                self.state = 113
                self.match(QrogueDungeonParser.REFERENCE)
                self.state = 118
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 119
            self.match(QrogueDungeonParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LayoutContext(ParserRuleContext):

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

        def LAYOUT(self):
            return self.getToken(QrogueDungeonParser.LAYOUT, 0)

        def l_room_row(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.L_room_rowContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.L_room_rowContext,i)


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

        def l_hallway_row(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.L_hallway_rowContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.L_hallway_rowContext,i)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_layout

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

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

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




    def layout(self):

        localctx = QrogueDungeonParser.LayoutContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_layout)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 121
            self.match(QrogueDungeonParser.LAYOUT)
            self.state = 125
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==QrogueDungeonParser.HORIZONTAL_SEPARATOR:
                self.state = 122
                self.match(QrogueDungeonParser.HORIZONTAL_SEPARATOR)
                self.state = 127
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 128
            self.l_room_row()
            self.state = 134
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==QrogueDungeonParser.VERTICAL_SEPARATOR:
                self.state = 129
                self.l_hallway_row()
                self.state = 130
                self.l_room_row()
                self.state = 136
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 140
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==QrogueDungeonParser.HORIZONTAL_SEPARATOR:
                self.state = 137
                self.match(QrogueDungeonParser.HORIZONTAL_SEPARATOR)
                self.state = 142
                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 L_room_rowContext(ParserRuleContext):

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

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

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

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

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

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_l_room_row

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

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

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




    def l_room_row(self):

        localctx = QrogueDungeonParser.L_room_rowContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_l_room_row)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 143
            self.match(QrogueDungeonParser.VERTICAL_SEPARATOR)
            self.state = 144
            _la = self._input.LA(1)
            if not(_la==QrogueDungeonParser.EMPTY_ROOM or _la==QrogueDungeonParser.ROOM_ID):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 149
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==QrogueDungeonParser.EMPTY_HALLWAY or _la==QrogueDungeonParser.HALLWAY_ID:
                self.state = 145
                _la = self._input.LA(1)
                if not(_la==QrogueDungeonParser.EMPTY_HALLWAY or _la==QrogueDungeonParser.HALLWAY_ID):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 146
                _la = self._input.LA(1)
                if not(_la==QrogueDungeonParser.EMPTY_ROOM or _la==QrogueDungeonParser.ROOM_ID):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 151
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 152
            self.match(QrogueDungeonParser.VERTICAL_SEPARATOR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class L_hallway_rowContext(ParserRuleContext):

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

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

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

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_l_hallway_row

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

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

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




    def l_hallway_row(self):

        localctx = QrogueDungeonParser.L_hallway_rowContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_l_hallway_row)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 154
            self.match(QrogueDungeonParser.VERTICAL_SEPARATOR)
            self.state = 156 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 155
                _la = self._input.LA(1)
                if not(_la==QrogueDungeonParser.EMPTY_HALLWAY or _la==QrogueDungeonParser.HALLWAY_ID):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 158 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==QrogueDungeonParser.EMPTY_HALLWAY or _la==QrogueDungeonParser.HALLWAY_ID):
                    break

            self.state = 160
            self.match(QrogueDungeonParser.VERTICAL_SEPARATOR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RoomsContext(ParserRuleContext):

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

        def ROOMS(self):
            return self.getToken(QrogueDungeonParser.ROOMS, 0)

        def room(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.RoomContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.RoomContext,i)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_rooms

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

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

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




    def rooms(self):

        localctx = QrogueDungeonParser.RoomsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_rooms)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 162
            self.match(QrogueDungeonParser.ROOMS)
            self.state = 166
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==QrogueDungeonParser.ROOM_ID:
                self.state = 163
                self.room()
                self.state = 168
                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 RoomContext(ParserRuleContext):

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

        def ROOM_ID(self):
            return self.getToken(QrogueDungeonParser.ROOM_ID, 0)

        def r_attributes(self):
            return self.getTypedRuleContext(QrogueDungeonParser.R_attributesContext,0)


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

        def r_row(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.R_rowContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.R_rowContext,i)


        def tile_descriptor(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.Tile_descriptorContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.Tile_descriptorContext,i)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_room

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

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

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




    def room(self):

        localctx = QrogueDungeonParser.RoomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_room)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 169
            self.match(QrogueDungeonParser.ROOM_ID)
            self.state = 170
            self.r_attributes()
            self.state = 171
            self.match(QrogueDungeonParser.T__4)
            self.state = 175
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 172
                    self.match(QrogueDungeonParser.WALL) 
                self.state = 177
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,12,self._ctx)

            self.state = 179 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 178
                    self.r_row()

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

            self.state = 186
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==QrogueDungeonParser.WALL:
                self.state = 183
                self.match(QrogueDungeonParser.WALL)
                self.state = 188
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 192
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << QrogueDungeonParser.T__8) | (1 << QrogueDungeonParser.T__9) | (1 << QrogueDungeonParser.T__10) | (1 << QrogueDungeonParser.T__11) | (1 << QrogueDungeonParser.T__12) | (1 << QrogueDungeonParser.T__13) | (1 << QrogueDungeonParser.DIGIT))) != 0):
                self.state = 189
                self.tile_descriptor()
                self.state = 194
                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 R_attributesContext(ParserRuleContext):

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

        def r_visibility(self):
            return self.getTypedRuleContext(QrogueDungeonParser.R_visibilityContext,0)


        def r_type(self):
            return self.getTypedRuleContext(QrogueDungeonParser.R_typeContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_r_attributes

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

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

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




    def r_attributes(self):

        localctx = QrogueDungeonParser.R_attributesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_r_attributes)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 195
            self.match(QrogueDungeonParser.T__5)
            self.state = 196
            self.r_visibility()
            self.state = 197
            self.r_type()
            self.state = 198
            self.match(QrogueDungeonParser.T__6)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class R_visibilityContext(ParserRuleContext):

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

        def VISIBLE_LITERAL(self):
            return self.getToken(QrogueDungeonParser.VISIBLE_LITERAL, 0)

        def FOGGY_LITERAL(self):
            return self.getToken(QrogueDungeonParser.FOGGY_LITERAL, 0)

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_r_visibility

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

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

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




    def r_visibility(self):

        localctx = QrogueDungeonParser.R_visibilityContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_r_visibility)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 201
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.VISIBLE_LITERAL or _la==QrogueDungeonParser.FOGGY_LITERAL:
                self.state = 200
                _la = self._input.LA(1)
                if not(_la==QrogueDungeonParser.VISIBLE_LITERAL or _la==QrogueDungeonParser.FOGGY_LITERAL):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


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


    class R_typeContext(ParserRuleContext):

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

        def SPAWN_LITERAL(self):
            return self.getToken(QrogueDungeonParser.SPAWN_LITERAL, 0)

        def BOSS_LITERAL(self):
            return self.getToken(QrogueDungeonParser.BOSS_LITERAL, 0)

        def WILD_LITERAL(self):
            return self.getToken(QrogueDungeonParser.WILD_LITERAL, 0)

        def SHOP_LITERAL(self):
            return self.getToken(QrogueDungeonParser.SHOP_LITERAL, 0)

        def RIDDLE_LITERAL(self):
            return self.getToken(QrogueDungeonParser.RIDDLE_LITERAL, 0)

        def GATE_ROOM_LITERAL(self):
            return self.getToken(QrogueDungeonParser.GATE_ROOM_LITERAL, 0)

        def TREASURE_LITERAL(self):
            return self.getToken(QrogueDungeonParser.TREASURE_LITERAL, 0)

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_r_type

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

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

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




    def r_type(self):

        localctx = QrogueDungeonParser.R_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_r_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 203
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << QrogueDungeonParser.SPAWN_LITERAL) | (1 << QrogueDungeonParser.WILD_LITERAL) | (1 << QrogueDungeonParser.SHOP_LITERAL) | (1 << QrogueDungeonParser.RIDDLE_LITERAL) | (1 << QrogueDungeonParser.BOSS_LITERAL) | (1 << QrogueDungeonParser.GATE_ROOM_LITERAL) | (1 << QrogueDungeonParser.TREASURE_LITERAL))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class R_rowContext(ParserRuleContext):

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

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

        def tile(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.TileContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.TileContext,i)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_r_row

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

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

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




    def r_row(self):

        localctx = QrogueDungeonParser.R_rowContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_r_row)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 205
            self.match(QrogueDungeonParser.WALL)
            self.state = 207 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 206
                self.tile()
                self.state = 209 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << QrogueDungeonParser.T__7) | (1 << QrogueDungeonParser.T__8) | (1 << QrogueDungeonParser.T__9) | (1 << QrogueDungeonParser.T__10) | (1 << QrogueDungeonParser.T__11) | (1 << QrogueDungeonParser.T__12) | (1 << QrogueDungeonParser.T__13) | (1 << QrogueDungeonParser.T__14) | (1 << QrogueDungeonParser.DIGIT))) != 0)):
                    break

            self.state = 211
            self.match(QrogueDungeonParser.WALL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TileContext(ParserRuleContext):

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

        def DIGIT(self):
            return self.getToken(QrogueDungeonParser.DIGIT, 0)

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_tile

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

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

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




    def tile(self):

        localctx = QrogueDungeonParser.TileContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_tile)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 213
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << QrogueDungeonParser.T__7) | (1 << QrogueDungeonParser.T__8) | (1 << QrogueDungeonParser.T__9) | (1 << QrogueDungeonParser.T__10) | (1 << QrogueDungeonParser.T__11) | (1 << QrogueDungeonParser.T__12) | (1 << QrogueDungeonParser.T__13) | (1 << QrogueDungeonParser.T__14) | (1 << QrogueDungeonParser.DIGIT))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Tile_descriptorContext(ParserRuleContext):

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

        def trigger_descriptor(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Trigger_descriptorContext,0)


        def message_descriptor(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Message_descriptorContext,0)


        def enemy_descriptor(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Enemy_descriptorContext,0)


        def collectible_descriptor(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Collectible_descriptorContext,0)


        def energy_descriptor(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Energy_descriptorContext,0)


        def riddle_descriptor(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Riddle_descriptorContext,0)


        def shop_descriptor(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Shop_descriptorContext,0)


        def TUTORIAL_LITERAL(self):
            return self.getToken(QrogueDungeonParser.TUTORIAL_LITERAL, 0)

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

        def TRIGGER_LITERAL(self):
            return self.getToken(QrogueDungeonParser.TRIGGER_LITERAL, 0)

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_tile_descriptor

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

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

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




    def tile_descriptor(self):

        localctx = QrogueDungeonParser.Tile_descriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_tile_descriptor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 222
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [QrogueDungeonParser.T__8]:
                self.state = 215
                self.trigger_descriptor()
                pass
            elif token in [QrogueDungeonParser.T__9]:
                self.state = 216
                self.message_descriptor()
                pass
            elif token in [QrogueDungeonParser.DIGIT]:
                self.state = 217
                self.enemy_descriptor()
                pass
            elif token in [QrogueDungeonParser.T__10]:
                self.state = 218
                self.collectible_descriptor()
                pass
            elif token in [QrogueDungeonParser.T__11]:
                self.state = 219
                self.energy_descriptor()
                pass
            elif token in [QrogueDungeonParser.T__12]:
                self.state = 220
                self.riddle_descriptor()
                pass
            elif token in [QrogueDungeonParser.T__13]:
                self.state = 221
                self.shop_descriptor()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 226
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.TUTORIAL_LITERAL:
                self.state = 224
                self.match(QrogueDungeonParser.TUTORIAL_LITERAL)
                self.state = 225
                self.match(QrogueDungeonParser.REFERENCE)


            self.state = 230
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.TRIGGER_LITERAL:
                self.state = 228
                self.match(QrogueDungeonParser.TRIGGER_LITERAL)
                self.state = 229
                self.match(QrogueDungeonParser.REFERENCE)


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


    class Trigger_descriptorContext(ParserRuleContext):

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

        def REFERENCE(self):
            return self.getToken(QrogueDungeonParser.REFERENCE, 0)

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_trigger_descriptor

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

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

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




    def trigger_descriptor(self):

        localctx = QrogueDungeonParser.Trigger_descriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_trigger_descriptor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 232
            self.match(QrogueDungeonParser.T__8)
            self.state = 233
            self.match(QrogueDungeonParser.REFERENCE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Message_descriptorContext(ParserRuleContext):

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

        def REFERENCE(self):
            return self.getToken(QrogueDungeonParser.REFERENCE, 0)

        def integer(self):
            return self.getTypedRuleContext(QrogueDungeonParser.IntegerContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_message_descriptor

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

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

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




    def message_descriptor(self):

        localctx = QrogueDungeonParser.Message_descriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_message_descriptor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 235
            self.match(QrogueDungeonParser.T__9)
            self.state = 237
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 21)) & ~0x3f) == 0 and ((1 << (_la - 21)) & ((1 << (QrogueDungeonParser.DIGIT - 21)) | (1 << (QrogueDungeonParser.INTEGER - 21)) | (1 << (QrogueDungeonParser.HALLWAY_ID - 21)))) != 0):
                self.state = 236
                self.integer()


            self.state = 239
            self.match(QrogueDungeonParser.REFERENCE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Enemy_descriptorContext(ParserRuleContext):

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

        def DIGIT(self):
            return self.getToken(QrogueDungeonParser.DIGIT, 0)

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_enemy_descriptor

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

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

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




    def enemy_descriptor(self):

        localctx = QrogueDungeonParser.Enemy_descriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_enemy_descriptor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 241
            self.match(QrogueDungeonParser.DIGIT)
            self.state = 242
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 244
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.REFERENCE:
                self.state = 243
                self.match(QrogueDungeonParser.REFERENCE)


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


    class Collectible_descriptorContext(ParserRuleContext):

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

        def REFERENCE(self):
            return self.getToken(QrogueDungeonParser.REFERENCE, 0)

        def integer(self):
            return self.getTypedRuleContext(QrogueDungeonParser.IntegerContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_collectible_descriptor

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

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

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




    def collectible_descriptor(self):

        localctx = QrogueDungeonParser.Collectible_descriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_collectible_descriptor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 246
            self.match(QrogueDungeonParser.T__10)
            self.state = 247
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 249
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
            if la_ == 1:
                self.state = 248
                self.integer()


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


    class Energy_descriptorContext(ParserRuleContext):

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

        def integer(self):
            return self.getTypedRuleContext(QrogueDungeonParser.IntegerContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_energy_descriptor

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

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

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




    def energy_descriptor(self):

        localctx = QrogueDungeonParser.Energy_descriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_energy_descriptor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 251
            self.match(QrogueDungeonParser.T__11)
            self.state = 252
            self.integer()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Riddle_descriptorContext(ParserRuleContext):

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

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

        def stv(self):
            return self.getTypedRuleContext(QrogueDungeonParser.StvContext,0)


        def collectible(self):
            return self.getTypedRuleContext(QrogueDungeonParser.CollectibleContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_riddle_descriptor

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

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

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




    def riddle_descriptor(self):

        localctx = QrogueDungeonParser.Riddle_descriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_riddle_descriptor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 254
            self.match(QrogueDungeonParser.T__12)
            self.state = 257
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [QrogueDungeonParser.REFERENCE]:
                self.state = 255
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [QrogueDungeonParser.T__2]:
                self.state = 256
                self.stv()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 261
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [QrogueDungeonParser.REFERENCE]:
                self.state = 259
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [QrogueDungeonParser.KEY_LITERAL, QrogueDungeonParser.COIN_LITERAL, QrogueDungeonParser.ENERGY_LITERAL, QrogueDungeonParser.GATE_LITERAL, QrogueDungeonParser.QUBIT_LITERAL]:
                self.state = 260
                self.collectible()
                pass
            else:
                raise NoViableAltException(self)

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


    class Shop_descriptorContext(ParserRuleContext):

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

        def integer(self):
            return self.getTypedRuleContext(QrogueDungeonParser.IntegerContext,0)


        def REFERENCE(self):
            return self.getToken(QrogueDungeonParser.REFERENCE, 0)

        def collectibles(self):
            return self.getTypedRuleContext(QrogueDungeonParser.CollectiblesContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_shop_descriptor

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

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

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




    def shop_descriptor(self):

        localctx = QrogueDungeonParser.Shop_descriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_shop_descriptor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 263
            self.match(QrogueDungeonParser.T__13)
            self.state = 266
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [QrogueDungeonParser.REFERENCE]:
                self.state = 264
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [QrogueDungeonParser.T__2]:
                self.state = 265
                self.collectibles()
                pass
            else:
                raise NoViableAltException(self)

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


    class HallwaysContext(ParserRuleContext):

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

        def HALLWAYS(self):
            return self.getToken(QrogueDungeonParser.HALLWAYS, 0)

        def hallway(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.HallwayContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.HallwayContext,i)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_hallways

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

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

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




    def hallways(self):

        localctx = QrogueDungeonParser.HallwaysContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_hallways)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 270
            self.match(QrogueDungeonParser.HALLWAYS)
            self.state = 274
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==QrogueDungeonParser.HALLWAY_ID:
                self.state = 271
                self.hallway()
                self.state = 276
                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 HallwayContext(ParserRuleContext):

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

        def HALLWAY_ID(self):
            return self.getToken(QrogueDungeonParser.HALLWAY_ID, 0)

        def h_attributes(self):
            return self.getTypedRuleContext(QrogueDungeonParser.H_attributesContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_hallway

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

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

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




    def hallway(self):

        localctx = QrogueDungeonParser.HallwayContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_hallway)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 277
            self.match(QrogueDungeonParser.HALLWAY_ID)
            self.state = 278
            self.h_attributes()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class H_attributesContext(ParserRuleContext):

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

        def OPEN_LITERAL(self):
            return self.getToken(QrogueDungeonParser.OPEN_LITERAL, 0)

        def CLOSED_LITERAL(self):
            return self.getToken(QrogueDungeonParser.CLOSED_LITERAL, 0)

        def LOCKED_LITERAL(self):
            return self.getToken(QrogueDungeonParser.LOCKED_LITERAL, 0)

        def EVENT_LITERAL(self):
            return self.getToken(QrogueDungeonParser.EVENT_LITERAL, 0)

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

        def DIRECTION(self):
            return self.getToken(QrogueDungeonParser.DIRECTION, 0)

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

        def TUTORIAL_LITERAL(self):
            return self.getToken(QrogueDungeonParser.TUTORIAL_LITERAL, 0)

        def TRIGGER_LITERAL(self):
            return self.getToken(QrogueDungeonParser.TRIGGER_LITERAL, 0)

        def PERMANENT_LITERAL(self):
            return self.getToken(QrogueDungeonParser.PERMANENT_LITERAL, 0)

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_h_attributes

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

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

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




    def h_attributes(self):

        localctx = QrogueDungeonParser.H_attributesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_h_attributes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 280
            self.match(QrogueDungeonParser.T__5)
            self.state = 286
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [QrogueDungeonParser.OPEN_LITERAL]:
                self.state = 281
                self.match(QrogueDungeonParser.OPEN_LITERAL)
                pass
            elif token in [QrogueDungeonParser.CLOSED_LITERAL]:
                self.state = 282
                self.match(QrogueDungeonParser.CLOSED_LITERAL)
                pass
            elif token in [QrogueDungeonParser.LOCKED_LITERAL]:
                self.state = 283
                self.match(QrogueDungeonParser.LOCKED_LITERAL)
                pass
            elif token in [QrogueDungeonParser.EVENT_LITERAL]:
                self.state = 284
                self.match(QrogueDungeonParser.EVENT_LITERAL)
                self.state = 285
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 293
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.T__15:
                self.state = 288
                self.match(QrogueDungeonParser.T__15)
                self.state = 289
                self.match(QrogueDungeonParser.DIRECTION)
                self.state = 291
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==QrogueDungeonParser.PERMANENT_LITERAL:
                    self.state = 290
                    self.match(QrogueDungeonParser.PERMANENT_LITERAL)




            self.state = 306
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.T__16:
                self.state = 295
                self.match(QrogueDungeonParser.T__16)
                self.state = 296
                self.match(QrogueDungeonParser.T__2)
                self.state = 297
                self.match(QrogueDungeonParser.HALLWAY_ID)
                self.state = 302
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==QrogueDungeonParser.LIST_SEPARATOR:
                    self.state = 298
                    self.match(QrogueDungeonParser.LIST_SEPARATOR)
                    self.state = 299
                    self.match(QrogueDungeonParser.HALLWAY_ID)
                    self.state = 304
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 305
                self.match(QrogueDungeonParser.T__3)


            self.state = 308
            self.match(QrogueDungeonParser.T__6)
            self.state = 311
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.TUTORIAL_LITERAL:
                self.state = 309
                self.match(QrogueDungeonParser.TUTORIAL_LITERAL)
                self.state = 310
                self.match(QrogueDungeonParser.REFERENCE)


            self.state = 315
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.TRIGGER_LITERAL:
                self.state = 313
                self.match(QrogueDungeonParser.TRIGGER_LITERAL)
                self.state = 314
                self.match(QrogueDungeonParser.REFERENCE)


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


    class Draw_strategyContext(ParserRuleContext):

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

        def RANDOM_DRAW(self):
            return self.getToken(QrogueDungeonParser.RANDOM_DRAW, 0)

        def ORDERED_DRAW(self):
            return self.getToken(QrogueDungeonParser.ORDERED_DRAW, 0)

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_draw_strategy

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

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

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




    def draw_strategy(self):

        localctx = QrogueDungeonParser.Draw_strategyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_draw_strategy)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 317
            _la = self._input.LA(1)
            if not(_la==QrogueDungeonParser.ORDERED_DRAW or _la==QrogueDungeonParser.RANDOM_DRAW):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Stv_poolsContext(ParserRuleContext):

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

        def STV_POOLS(self):
            return self.getToken(QrogueDungeonParser.STV_POOLS, 0)

        def default_stv_pool(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Default_stv_poolContext,0)


        def stv_pool(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.Stv_poolContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.Stv_poolContext,i)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_stv_pools

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

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

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




    def stv_pools(self):

        localctx = QrogueDungeonParser.Stv_poolsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_stv_pools)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 319
            self.match(QrogueDungeonParser.STV_POOLS)
            self.state = 326
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.T__17:
                self.state = 320
                self.match(QrogueDungeonParser.T__17)
                self.state = 322 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 321
                    self.stv_pool()
                    self.state = 324 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==QrogueDungeonParser.REFERENCE):
                        break



            self.state = 328
            self.match(QrogueDungeonParser.T__18)
            self.state = 329
            self.default_stv_pool()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Default_stv_poolContext(ParserRuleContext):

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

        def REFERENCE(self):
            return self.getToken(QrogueDungeonParser.REFERENCE, 0)

        def stvs(self):
            return self.getTypedRuleContext(QrogueDungeonParser.StvsContext,0)


        def draw_strategy(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Draw_strategyContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_default_stv_pool

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

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

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




    def default_stv_pool(self):

        localctx = QrogueDungeonParser.Default_stv_poolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_default_stv_pool)
        self._la = 0 # Token type
        try:
            self.state = 336
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [QrogueDungeonParser.REFERENCE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 331
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [QrogueDungeonParser.T__2, QrogueDungeonParser.ORDERED_DRAW, QrogueDungeonParser.RANDOM_DRAW]:
                self.enterOuterAlt(localctx, 2)
                self.state = 333
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==QrogueDungeonParser.ORDERED_DRAW or _la==QrogueDungeonParser.RANDOM_DRAW:
                    self.state = 332
                    self.draw_strategy()


                self.state = 335
                self.stvs()
                pass
            else:
                raise NoViableAltException(self)

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


    class Stv_poolContext(ParserRuleContext):

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

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

        def stvs(self):
            return self.getTypedRuleContext(QrogueDungeonParser.StvsContext,0)


        def draw_strategy(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Draw_strategyContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_stv_pool

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

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

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




    def stv_pool(self):

        localctx = QrogueDungeonParser.Stv_poolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_stv_pool)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 338
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 340
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.ORDERED_DRAW or _la==QrogueDungeonParser.RANDOM_DRAW:
                self.state = 339
                self.draw_strategy()


            self.state = 342
            self.stvs()
            self.state = 347
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
            if la_ == 1:
                self.state = 343
                self.match(QrogueDungeonParser.T__18)
                self.state = 344
                self.match(QrogueDungeonParser.T__19)
                self.state = 345
                self.match(QrogueDungeonParser.T__4)
                self.state = 346
                self.match(QrogueDungeonParser.REFERENCE)


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


    class StvsContext(ParserRuleContext):

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

        def stv(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.StvContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.StvContext,i)


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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_stvs

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

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

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




    def stvs(self):

        localctx = QrogueDungeonParser.StvsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_stvs)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 349
            self.match(QrogueDungeonParser.T__2)
            self.state = 350
            self.stv()
            self.state = 355
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==QrogueDungeonParser.LIST_SEPARATOR:
                self.state = 351
                self.match(QrogueDungeonParser.LIST_SEPARATOR)
                self.state = 352
                self.stv()
                self.state = 357
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 358
            self.match(QrogueDungeonParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StvContext(ParserRuleContext):

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

        def complex_number(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.Complex_numberContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.Complex_numberContext,i)


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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_stv

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

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

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




    def stv(self):

        localctx = QrogueDungeonParser.StvContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_stv)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 360
            self.match(QrogueDungeonParser.T__2)
            self.state = 361
            self.complex_number()
            self.state = 366
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==QrogueDungeonParser.LIST_SEPARATOR:
                self.state = 362
                self.match(QrogueDungeonParser.LIST_SEPARATOR)
                self.state = 363
                self.complex_number()
                self.state = 368
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 369
            self.match(QrogueDungeonParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Reward_poolsContext(ParserRuleContext):

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

        def REWARD_POOLS(self):
            return self.getToken(QrogueDungeonParser.REWARD_POOLS, 0)

        def default_reward_pool(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Default_reward_poolContext,0)


        def reward_pool(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.Reward_poolContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.Reward_poolContext,i)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_reward_pools

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

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

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




    def reward_pools(self):

        localctx = QrogueDungeonParser.Reward_poolsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_reward_pools)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 371
            self.match(QrogueDungeonParser.REWARD_POOLS)
            self.state = 378
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.T__17:
                self.state = 372
                self.match(QrogueDungeonParser.T__17)
                self.state = 374 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 373
                    self.reward_pool()
                    self.state = 376 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==QrogueDungeonParser.REFERENCE):
                        break



            self.state = 380
            self.match(QrogueDungeonParser.T__18)
            self.state = 381
            self.default_reward_pool()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Default_reward_poolContext(ParserRuleContext):

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

        def REFERENCE(self):
            return self.getToken(QrogueDungeonParser.REFERENCE, 0)

        def collectibles(self):
            return self.getTypedRuleContext(QrogueDungeonParser.CollectiblesContext,0)


        def draw_strategy(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Draw_strategyContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_default_reward_pool

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

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

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




    def default_reward_pool(self):

        localctx = QrogueDungeonParser.Default_reward_poolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_default_reward_pool)
        self._la = 0 # Token type
        try:
            self.state = 388
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [QrogueDungeonParser.REFERENCE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 383
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [QrogueDungeonParser.T__2, QrogueDungeonParser.ORDERED_DRAW, QrogueDungeonParser.RANDOM_DRAW]:
                self.enterOuterAlt(localctx, 2)
                self.state = 385
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==QrogueDungeonParser.ORDERED_DRAW or _la==QrogueDungeonParser.RANDOM_DRAW:
                    self.state = 384
                    self.draw_strategy()


                self.state = 387
                self.collectibles()
                pass
            else:
                raise NoViableAltException(self)

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


    class Reward_poolContext(ParserRuleContext):

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

        def REFERENCE(self):
            return self.getToken(QrogueDungeonParser.REFERENCE, 0)

        def collectibles(self):
            return self.getTypedRuleContext(QrogueDungeonParser.CollectiblesContext,0)


        def draw_strategy(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Draw_strategyContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_reward_pool

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

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

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




    def reward_pool(self):

        localctx = QrogueDungeonParser.Reward_poolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_reward_pool)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 390
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 392
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.ORDERED_DRAW or _la==QrogueDungeonParser.RANDOM_DRAW:
                self.state = 391
                self.draw_strategy()


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


    class CollectiblesContext(ParserRuleContext):

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

        def collectible(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.CollectibleContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.CollectibleContext,i)


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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_collectibles

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

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

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




    def collectibles(self):

        localctx = QrogueDungeonParser.CollectiblesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_collectibles)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 396
            self.match(QrogueDungeonParser.T__2)
            self.state = 397
            self.collectible()
            self.state = 402
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==QrogueDungeonParser.LIST_SEPARATOR:
                self.state = 398
                self.match(QrogueDungeonParser.LIST_SEPARATOR)
                self.state = 399
                self.collectible()
                self.state = 404
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 405
            self.match(QrogueDungeonParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CollectibleContext(ParserRuleContext):

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

        def KEY_LITERAL(self):
            return self.getToken(QrogueDungeonParser.KEY_LITERAL, 0)

        def integer(self):
            return self.getTypedRuleContext(QrogueDungeonParser.IntegerContext,0)


        def COIN_LITERAL(self):
            return self.getToken(QrogueDungeonParser.COIN_LITERAL, 0)

        def ENERGY_LITERAL(self):
            return self.getToken(QrogueDungeonParser.ENERGY_LITERAL, 0)

        def GATE_LITERAL(self):
            return self.getToken(QrogueDungeonParser.GATE_LITERAL, 0)

        def REFERENCE(self):
            return self.getToken(QrogueDungeonParser.REFERENCE, 0)

        def QUBIT_LITERAL(self):
            return self.getToken(QrogueDungeonParser.QUBIT_LITERAL, 0)

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_collectible

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

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

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




    def collectible(self):

        localctx = QrogueDungeonParser.CollectibleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_collectible)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 419
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [QrogueDungeonParser.KEY_LITERAL]:
                self.state = 407
                self.match(QrogueDungeonParser.KEY_LITERAL)
                self.state = 408
                self.integer()
                pass
            elif token in [QrogueDungeonParser.COIN_LITERAL]:
                self.state = 409
                self.match(QrogueDungeonParser.COIN_LITERAL)
                self.state = 410
                self.integer()
                pass
            elif token in [QrogueDungeonParser.ENERGY_LITERAL]:
                self.state = 411
                self.match(QrogueDungeonParser.ENERGY_LITERAL)
                self.state = 412
                self.integer()
                pass
            elif token in [QrogueDungeonParser.GATE_LITERAL]:
                self.state = 413
                self.match(QrogueDungeonParser.GATE_LITERAL)
                self.state = 414
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [QrogueDungeonParser.QUBIT_LITERAL]:
                self.state = 415
                self.match(QrogueDungeonParser.QUBIT_LITERAL)
                self.state = 417
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
                if la_ == 1:
                    self.state = 416
                    self.integer()


                pass
            else:
                raise NoViableAltException(self)

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


    class MessagesContext(ParserRuleContext):

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

        def MESSAGES(self):
            return self.getToken(QrogueDungeonParser.MESSAGES, 0)

        def message(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.MessageContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.MessageContext,i)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_messages

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

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

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




    def messages(self):

        localctx = QrogueDungeonParser.MessagesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_messages)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 421
            self.match(QrogueDungeonParser.MESSAGES)
            self.state = 425
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==QrogueDungeonParser.REFERENCE:
                self.state = 422
                self.message()
                self.state = 427
                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 MessageContext(ParserRuleContext):

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

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

        def TEXT(self):
            return self.getToken(QrogueDungeonParser.TEXT, 0)

        def EVENT_LITERAL(self):
            return self.getToken(QrogueDungeonParser.EVENT_LITERAL, 0)

        def ALTERNATIVE_LITERAL(self):
            return self.getToken(QrogueDungeonParser.ALTERNATIVE_LITERAL, 0)

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_message

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

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

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




    def message(self):

        localctx = QrogueDungeonParser.MessageContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_message)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 428
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 429
            self.match(QrogueDungeonParser.TEXT)
            self.state = 434
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==QrogueDungeonParser.EVENT_LITERAL:
                self.state = 430
                self.match(QrogueDungeonParser.EVENT_LITERAL)
                self.state = 431
                self.match(QrogueDungeonParser.REFERENCE)
                self.state = 432
                self.match(QrogueDungeonParser.ALTERNATIVE_LITERAL)
                self.state = 433
                self.match(QrogueDungeonParser.REFERENCE)


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





