# Generated from D:/Workspaces/pycharm-workspace/Qrogue/qrogue/game/world/dungeon_generator\QrogueDungeon.g4 by ANTLR 4.12.0
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO

def serializedATN():
    return [
        4,1,114,655,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
        7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
        13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
        20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
        26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
        33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
        39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
        46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,1,0,1,
        0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,3,1,119,8,1,1,
        1,1,1,1,1,1,1,3,1,125,8,1,3,1,127,8,1,1,1,3,1,130,8,1,1,1,3,1,133,
        8,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,5,2,142,8,2,10,2,12,2,145,9,2,1,
        2,1,2,1,2,1,2,3,2,151,8,2,1,2,1,2,1,2,3,2,156,8,2,1,2,1,2,1,2,1,
        2,1,2,1,2,3,2,164,8,2,3,2,166,8,2,1,3,5,3,169,8,3,10,3,12,3,172,
        9,3,1,3,4,3,175,8,3,11,3,12,3,176,1,3,5,3,180,8,3,10,3,12,3,183,
        9,3,1,3,5,3,186,8,3,10,3,12,3,189,9,3,1,4,1,4,4,4,193,8,4,11,4,12,
        4,194,1,4,1,4,1,5,1,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,3,6,210,
        8,6,1,6,1,6,3,6,214,8,6,1,6,1,6,3,6,218,8,6,1,7,1,7,1,7,3,7,223,
        8,7,1,8,3,8,226,8,8,1,8,1,8,1,9,1,9,1,9,3,9,233,8,9,1,9,1,9,3,9,
        237,8,9,1,10,1,10,3,10,241,8,10,1,10,1,10,1,11,1,11,1,11,3,11,248,
        8,11,1,11,3,11,251,8,11,1,12,1,12,1,12,1,13,1,13,1,13,1,13,3,13,
        260,8,13,1,14,1,14,1,14,3,14,265,8,14,1,14,1,14,3,14,269,8,14,1,
        14,3,14,272,8,14,1,15,1,15,1,15,1,15,1,15,1,15,5,15,280,8,15,10,
        15,12,15,283,9,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,291,8,15,3,
        15,293,8,15,1,15,1,15,3,15,297,8,15,1,16,1,16,1,16,1,16,1,17,1,17,
        1,17,3,17,306,8,17,1,17,1,17,1,18,1,18,3,18,312,8,18,1,18,1,18,3,
        18,316,8,18,1,18,3,18,319,8,18,1,19,1,19,1,19,1,19,3,19,325,8,19,
        1,20,1,20,3,20,329,8,20,1,20,1,20,1,21,1,21,1,21,1,21,1,21,1,21,
        3,21,339,8,21,1,21,1,21,1,21,3,21,344,8,21,5,21,346,8,21,10,21,12,
        21,349,9,21,1,22,1,22,1,22,1,22,1,22,5,22,356,8,22,10,22,12,22,359,
        9,22,1,22,3,22,362,8,22,1,22,1,22,1,22,1,23,1,23,1,23,1,23,1,23,
        1,23,4,23,373,8,23,11,23,12,23,374,1,23,1,23,1,24,1,24,1,25,1,25,
        1,25,4,25,384,8,25,11,25,12,25,385,3,25,388,8,25,1,25,1,25,1,25,
        1,26,1,26,3,26,395,8,26,1,26,3,26,398,8,26,1,27,1,27,3,27,402,8,
        27,1,27,1,27,1,27,1,27,1,27,3,27,409,8,27,1,28,1,28,1,28,1,28,5,
        28,415,8,28,10,28,12,28,418,9,28,1,28,1,28,1,29,1,29,3,29,424,8,
        29,1,30,1,30,1,30,1,30,5,30,430,8,30,10,30,12,30,433,9,30,1,30,1,
        30,1,30,1,30,1,30,1,30,3,30,441,8,30,1,31,1,31,1,31,4,31,446,8,31,
        11,31,12,31,447,3,31,450,8,31,1,31,1,31,1,31,1,32,1,32,3,32,457,
        8,32,1,32,3,32,460,8,32,1,33,1,33,3,33,464,8,33,1,33,1,33,1,34,1,
        34,1,34,1,34,5,34,472,8,34,10,34,12,34,475,9,34,1,34,1,34,1,35,1,
        35,1,35,1,35,1,35,1,35,3,35,485,8,35,1,35,3,35,488,8,35,1,36,1,36,
        1,37,3,37,493,8,37,1,37,1,37,1,37,3,37,498,8,37,1,37,1,37,3,37,502,
        8,37,3,37,504,8,37,1,38,1,38,5,38,508,8,38,10,38,12,38,511,9,38,
        1,38,1,38,1,38,1,38,5,38,517,8,38,10,38,12,38,520,9,38,1,38,5,38,
        523,8,38,10,38,12,38,526,9,38,1,39,1,39,1,39,1,39,5,39,532,8,39,
        10,39,12,39,535,9,39,1,39,1,39,1,40,1,40,4,40,541,8,40,11,40,12,
        40,542,1,40,1,40,1,41,1,41,5,41,549,8,41,10,41,12,41,552,9,41,1,
        42,1,42,1,42,1,42,1,42,1,43,1,43,1,43,1,43,1,43,1,44,3,44,565,8,
        44,1,45,1,45,1,46,1,46,5,46,571,8,46,10,46,12,46,574,9,46,1,47,1,
        47,1,47,1,48,1,48,1,48,1,48,1,48,1,48,3,48,585,8,48,1,48,1,48,1,
        48,3,48,590,8,48,3,48,592,8,48,1,48,1,48,1,48,1,48,1,48,5,48,599,
        8,48,10,48,12,48,602,9,48,1,48,3,48,605,8,48,1,48,1,48,1,48,3,48,
        610,8,48,1,48,1,48,3,48,614,8,48,1,49,1,49,1,49,1,49,3,49,620,8,
        49,1,49,5,49,623,8,49,10,49,12,49,626,9,49,1,50,1,50,1,50,1,50,1,
        50,1,50,3,50,634,8,50,1,51,1,51,3,51,638,8,51,1,51,3,51,641,8,51,
        1,51,1,51,3,51,645,8,51,1,51,3,51,648,8,51,1,51,4,51,651,8,51,11,
        51,12,51,652,1,51,0,0,52,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,
        30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,
        74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,0,13,1,0,31,32,2,
        0,7,16,71,71,2,0,51,52,82,82,1,0,48,50,2,0,79,79,82,82,1,0,19,20,
        1,0,55,56,1,0,41,44,2,0,71,72,81,81,2,0,70,70,80,80,2,0,69,69,81,
        81,1,0,90,91,1,0,94,103,704,0,104,1,0,0,0,2,118,1,0,0,0,4,134,1,
        0,0,0,6,170,1,0,0,0,8,190,1,0,0,0,10,198,1,0,0,0,12,209,1,0,0,0,
        14,219,1,0,0,0,16,225,1,0,0,0,18,236,1,0,0,0,20,238,1,0,0,0,22,244,
        1,0,0,0,24,252,1,0,0,0,26,255,1,0,0,0,28,261,1,0,0,0,30,273,1,0,
        0,0,32,298,1,0,0,0,34,302,1,0,0,0,36,311,1,0,0,0,38,320,1,0,0,0,
        40,328,1,0,0,0,42,332,1,0,0,0,44,361,1,0,0,0,46,366,1,0,0,0,48,378,
        1,0,0,0,50,380,1,0,0,0,52,397,1,0,0,0,54,399,1,0,0,0,56,410,1,0,
        0,0,58,423,1,0,0,0,60,440,1,0,0,0,62,442,1,0,0,0,64,459,1,0,0,0,
        66,461,1,0,0,0,68,467,1,0,0,0,70,487,1,0,0,0,72,489,1,0,0,0,74,492,
        1,0,0,0,76,505,1,0,0,0,78,527,1,0,0,0,80,538,1,0,0,0,82,546,1,0,
        0,0,84,553,1,0,0,0,86,558,1,0,0,0,88,564,1,0,0,0,90,566,1,0,0,0,
        92,568,1,0,0,0,94,575,1,0,0,0,96,578,1,0,0,0,98,615,1,0,0,0,100,
        627,1,0,0,0,102,637,1,0,0,0,104,105,5,63,0,0,105,106,3,2,1,0,106,
        107,3,4,2,0,107,108,3,76,38,0,108,109,3,82,41,0,109,110,3,92,46,
        0,110,111,3,50,25,0,111,112,3,62,31,0,112,113,3,98,49,0,113,114,
        5,64,0,0,114,1,1,0,0,0,115,116,5,1,0,0,116,117,5,2,0,0,117,119,5,
        79,0,0,118,115,1,0,0,0,118,119,1,0,0,0,119,126,1,0,0,0,120,121,5,
        3,0,0,121,124,5,2,0,0,122,125,3,102,51,0,123,125,5,82,0,0,124,122,
        1,0,0,0,124,123,1,0,0,0,125,127,1,0,0,0,126,120,1,0,0,0,126,127,
        1,0,0,0,127,129,1,0,0,0,128,130,7,0,0,0,129,128,1,0,0,0,129,130,
        1,0,0,0,130,132,1,0,0,0,131,133,5,33,0,0,132,131,1,0,0,0,132,133,
        1,0,0,0,133,3,1,0,0,0,134,135,5,34,0,0,135,136,5,71,0,0,136,137,
        5,4,0,0,137,138,5,5,0,0,138,143,5,82,0,0,139,140,5,67,0,0,140,142,
        5,82,0,0,141,139,1,0,0,0,142,145,1,0,0,0,143,141,1,0,0,0,143,144,
        1,0,0,0,144,146,1,0,0,0,145,143,1,0,0,0,146,150,5,6,0,0,147,148,
        5,39,0,0,148,149,5,2,0,0,149,151,3,72,36,0,150,147,1,0,0,0,150,151,
        1,0,0,0,151,155,1,0,0,0,152,153,5,40,0,0,153,154,5,2,0,0,154,156,
        3,72,36,0,155,152,1,0,0,0,155,156,1,0,0,0,156,165,1,0,0,0,157,158,
        5,37,0,0,158,159,5,2,0,0,159,163,3,72,36,0,160,161,5,38,0,0,161,
        162,5,2,0,0,162,164,3,72,36,0,163,160,1,0,0,0,163,164,1,0,0,0,164,
        166,1,0,0,0,165,157,1,0,0,0,165,166,1,0,0,0,166,5,1,0,0,0,167,169,
        5,68,0,0,168,167,1,0,0,0,169,172,1,0,0,0,170,168,1,0,0,0,170,171,
        1,0,0,0,171,174,1,0,0,0,172,170,1,0,0,0,173,175,3,8,4,0,174,173,
        1,0,0,0,175,176,1,0,0,0,176,174,1,0,0,0,176,177,1,0,0,0,177,181,
        1,0,0,0,178,180,5,68,0,0,179,178,1,0,0,0,180,183,1,0,0,0,181,179,
        1,0,0,0,181,182,1,0,0,0,182,187,1,0,0,0,183,181,1,0,0,0,184,186,
        3,12,6,0,185,184,1,0,0,0,186,189,1,0,0,0,187,185,1,0,0,0,187,188,
        1,0,0,0,188,7,1,0,0,0,189,187,1,0,0,0,190,192,5,68,0,0,191,193,3,
        10,5,0,192,191,1,0,0,0,193,194,1,0,0,0,194,192,1,0,0,0,194,195,1,
        0,0,0,195,196,1,0,0,0,196,197,5,68,0,0,197,9,1,0,0,0,198,199,7,1,
        0,0,199,11,1,0,0,0,200,210,3,14,7,0,201,210,3,20,10,0,202,210,3,
        28,14,0,203,210,3,30,15,0,204,210,3,22,11,0,205,210,3,24,12,0,206,
        210,3,32,16,0,207,210,3,34,17,0,208,210,3,26,13,0,209,200,1,0,0,
        0,209,201,1,0,0,0,209,202,1,0,0,0,209,203,1,0,0,0,209,204,1,0,0,
        0,209,205,1,0,0,0,209,206,1,0,0,0,209,207,1,0,0,0,209,208,1,0,0,
        0,210,213,1,0,0,0,211,212,5,61,0,0,212,214,5,82,0,0,213,211,1,0,
        0,0,213,214,1,0,0,0,214,217,1,0,0,0,215,216,5,62,0,0,216,218,7,2,
        0,0,217,215,1,0,0,0,217,218,1,0,0,0,218,13,1,0,0,0,219,222,5,8,0,
        0,220,223,3,16,8,0,221,223,3,18,9,0,222,220,1,0,0,0,222,221,1,0,
        0,0,223,15,1,0,0,0,224,226,7,3,0,0,225,224,1,0,0,0,225,226,1,0,0,
        0,226,227,1,0,0,0,227,228,5,82,0,0,228,17,1,0,0,0,229,230,5,53,0,
        0,230,232,5,80,0,0,231,233,3,72,36,0,232,231,1,0,0,0,232,233,1,0,
        0,0,233,237,1,0,0,0,234,235,5,54,0,0,235,237,5,82,0,0,236,229,1,
        0,0,0,236,234,1,0,0,0,237,19,1,0,0,0,238,240,5,9,0,0,239,241,3,72,
        36,0,240,239,1,0,0,0,240,241,1,0,0,0,241,242,1,0,0,0,242,243,7,4,
        0,0,243,21,1,0,0,0,244,250,5,11,0,0,245,247,5,82,0,0,246,248,3,72,
        36,0,247,246,1,0,0,0,247,248,1,0,0,0,248,251,1,0,0,0,249,251,3,70,
        35,0,250,245,1,0,0,0,250,249,1,0,0,0,251,23,1,0,0,0,252,253,5,12,
        0,0,253,254,3,72,36,0,254,25,1,0,0,0,255,256,5,15,0,0,256,259,3,
        72,36,0,257,260,5,82,0,0,258,260,3,68,34,0,259,257,1,0,0,0,259,258,
        1,0,0,0,260,27,1,0,0,0,261,264,5,71,0,0,262,265,5,82,0,0,263,265,
        3,60,30,0,264,262,1,0,0,0,264,263,1,0,0,0,265,268,1,0,0,0,266,269,
        5,82,0,0,267,269,3,70,35,0,268,266,1,0,0,0,268,267,1,0,0,0,268,269,
        1,0,0,0,269,271,1,0,0,0,270,272,3,38,19,0,271,270,1,0,0,0,271,272,
        1,0,0,0,272,29,1,0,0,0,273,292,5,10,0,0,274,293,5,82,0,0,275,276,
        5,5,0,0,276,281,3,40,20,0,277,278,5,67,0,0,278,280,3,40,20,0,279,
        277,1,0,0,0,280,283,1,0,0,0,281,279,1,0,0,0,281,282,1,0,0,0,282,
        284,1,0,0,0,283,281,1,0,0,0,284,290,5,6,0,0,285,286,5,45,0,0,286,
        287,5,17,0,0,287,288,3,42,21,0,288,289,5,18,0,0,289,291,1,0,0,0,
        290,285,1,0,0,0,290,291,1,0,0,0,291,293,1,0,0,0,292,274,1,0,0,0,
        292,275,1,0,0,0,293,296,1,0,0,0,294,297,5,82,0,0,295,297,3,70,35,
        0,296,294,1,0,0,0,296,295,1,0,0,0,297,31,1,0,0,0,298,299,5,13,0,
        0,299,300,3,72,36,0,300,301,3,36,18,0,301,33,1,0,0,0,302,303,5,14,
        0,0,303,305,3,72,36,0,304,306,3,72,36,0,305,304,1,0,0,0,305,306,
        1,0,0,0,306,307,1,0,0,0,307,308,3,36,18,0,308,35,1,0,0,0,309,312,
        5,82,0,0,310,312,3,60,30,0,311,309,1,0,0,0,311,310,1,0,0,0,312,315,
        1,0,0,0,313,316,5,82,0,0,314,316,3,70,35,0,315,313,1,0,0,0,315,314,
        1,0,0,0,316,318,1,0,0,0,317,319,3,38,19,0,318,317,1,0,0,0,318,319,
        1,0,0,0,319,37,1,0,0,0,320,321,7,5,0,0,321,324,5,2,0,0,322,325,5,
        82,0,0,323,325,3,60,30,0,324,322,1,0,0,0,324,323,1,0,0,0,325,39,
        1,0,0,0,326,329,5,82,0,0,327,329,3,60,30,0,328,326,1,0,0,0,328,327,
        1,0,0,0,329,330,1,0,0,0,330,331,3,38,19,0,331,41,1,0,0,0,332,333,
        5,57,0,0,333,334,5,2,0,0,334,335,5,71,0,0,335,338,5,21,0,0,336,339,
        3,44,22,0,337,339,3,46,23,0,338,336,1,0,0,0,338,337,1,0,0,0,339,
        347,1,0,0,0,340,343,5,67,0,0,341,344,3,44,22,0,342,344,3,46,23,0,
        343,341,1,0,0,0,343,342,1,0,0,0,344,346,1,0,0,0,345,340,1,0,0,0,
        346,349,1,0,0,0,347,345,1,0,0,0,347,348,1,0,0,0,348,43,1,0,0,0,349,
        347,1,0,0,0,350,362,5,59,0,0,351,352,5,5,0,0,352,357,5,59,0,0,353,
        354,5,67,0,0,354,356,5,59,0,0,355,353,1,0,0,0,356,359,1,0,0,0,357,
        355,1,0,0,0,357,358,1,0,0,0,358,360,1,0,0,0,359,357,1,0,0,0,360,
        362,5,6,0,0,361,350,1,0,0,0,361,351,1,0,0,0,362,363,1,0,0,0,363,
        364,5,22,0,0,364,365,5,58,0,0,365,45,1,0,0,0,366,367,5,59,0,0,367,
        368,5,22,0,0,368,369,5,5,0,0,369,370,5,58,0,0,370,372,5,67,0,0,371,
        373,5,58,0,0,372,371,1,0,0,0,373,374,1,0,0,0,374,372,1,0,0,0,374,
        375,1,0,0,0,375,376,1,0,0,0,376,377,5,6,0,0,377,47,1,0,0,0,378,379,
        7,6,0,0,379,49,1,0,0,0,380,387,5,35,0,0,381,383,5,23,0,0,382,384,
        3,54,27,0,383,382,1,0,0,0,384,385,1,0,0,0,385,383,1,0,0,0,385,386,
        1,0,0,0,386,388,1,0,0,0,387,381,1,0,0,0,387,388,1,0,0,0,388,389,
        1,0,0,0,389,390,5,24,0,0,390,391,3,52,26,0,391,51,1,0,0,0,392,398,
        5,82,0,0,393,395,3,48,24,0,394,393,1,0,0,0,394,395,1,0,0,0,395,396,
        1,0,0,0,396,398,3,56,28,0,397,392,1,0,0,0,397,394,1,0,0,0,398,53,
        1,0,0,0,399,401,5,82,0,0,400,402,3,48,24,0,401,400,1,0,0,0,401,402,
        1,0,0,0,402,403,1,0,0,0,403,408,3,56,28,0,404,405,5,24,0,0,405,406,
        5,25,0,0,406,407,5,21,0,0,407,409,5,82,0,0,408,404,1,0,0,0,408,409,
        1,0,0,0,409,55,1,0,0,0,410,411,5,5,0,0,411,416,3,58,29,0,412,413,
        5,67,0,0,413,415,3,58,29,0,414,412,1,0,0,0,415,418,1,0,0,0,416,414,
        1,0,0,0,416,417,1,0,0,0,417,419,1,0,0,0,418,416,1,0,0,0,419,420,
        5,6,0,0,420,57,1,0,0,0,421,424,3,60,30,0,422,424,5,82,0,0,423,421,
        1,0,0,0,423,422,1,0,0,0,424,59,1,0,0,0,425,426,5,5,0,0,426,431,3,
        74,37,0,427,428,5,67,0,0,428,430,3,74,37,0,429,427,1,0,0,0,430,433,
        1,0,0,0,431,429,1,0,0,0,431,432,1,0,0,0,432,434,1,0,0,0,433,431,
        1,0,0,0,434,435,5,6,0,0,435,441,1,0,0,0,436,437,5,26,0,0,437,438,
        3,42,21,0,438,439,5,27,0,0,439,441,1,0,0,0,440,425,1,0,0,0,440,436,
        1,0,0,0,441,61,1,0,0,0,442,449,5,36,0,0,443,445,5,23,0,0,444,446,
        3,66,33,0,445,444,1,0,0,0,446,447,1,0,0,0,447,445,1,0,0,0,447,448,
        1,0,0,0,448,450,1,0,0,0,449,443,1,0,0,0,449,450,1,0,0,0,450,451,
        1,0,0,0,451,452,5,24,0,0,452,453,3,64,32,0,453,63,1,0,0,0,454,460,
        5,82,0,0,455,457,3,48,24,0,456,455,1,0,0,0,456,457,1,0,0,0,457,458,
        1,0,0,0,458,460,3,68,34,0,459,454,1,0,0,0,459,456,1,0,0,0,460,65,
        1,0,0,0,461,463,5,82,0,0,462,464,3,48,24,0,463,462,1,0,0,0,463,464,
        1,0,0,0,464,465,1,0,0,0,465,466,3,68,34,0,466,67,1,0,0,0,467,468,
        5,5,0,0,468,473,3,70,35,0,469,470,5,67,0,0,470,472,3,70,35,0,471,
        469,1,0,0,0,472,475,1,0,0,0,473,471,1,0,0,0,473,474,1,0,0,0,474,
        476,1,0,0,0,475,473,1,0,0,0,476,477,5,6,0,0,477,69,1,0,0,0,478,479,
        7,7,0,0,479,488,3,72,36,0,480,481,5,45,0,0,481,488,5,82,0,0,482,
        484,5,46,0,0,483,485,3,72,36,0,484,483,1,0,0,0,484,485,1,0,0,0,485,
        488,1,0,0,0,486,488,5,47,0,0,487,478,1,0,0,0,487,480,1,0,0,0,487,
        482,1,0,0,0,487,486,1,0,0,0,488,71,1,0,0,0,489,490,7,8,0,0,490,73,
        1,0,0,0,491,493,5,75,0,0,492,491,1,0,0,0,492,493,1,0,0,0,493,503,
        1,0,0,0,494,504,5,74,0,0,495,498,3,72,36,0,496,498,5,73,0,0,497,
        495,1,0,0,0,497,496,1,0,0,0,498,501,1,0,0,0,499,500,5,75,0,0,500,
        502,5,74,0,0,501,499,1,0,0,0,501,502,1,0,0,0,502,504,1,0,0,0,503,
        494,1,0,0,0,503,497,1,0,0,0,504,75,1,0,0,0,505,509,5,87,0,0,506,
        508,5,65,0,0,507,506,1,0,0,0,508,511,1,0,0,0,509,507,1,0,0,0,509,
        510,1,0,0,0,510,512,1,0,0,0,511,509,1,0,0,0,512,518,3,78,39,0,513,
        514,3,80,40,0,514,515,3,78,39,0,515,517,1,0,0,0,516,513,1,0,0,0,
        517,520,1,0,0,0,518,516,1,0,0,0,518,519,1,0,0,0,519,524,1,0,0,0,
        520,518,1,0,0,0,521,523,5,65,0,0,522,521,1,0,0,0,523,526,1,0,0,0,
        524,522,1,0,0,0,524,525,1,0,0,0,525,77,1,0,0,0,526,524,1,0,0,0,527,
        528,5,66,0,0,528,533,7,9,0,0,529,530,7,10,0,0,530,532,7,9,0,0,531,
        529,1,0,0,0,532,535,1,0,0,0,533,531,1,0,0,0,533,534,1,0,0,0,534,
        536,1,0,0,0,535,533,1,0,0,0,536,537,5,66,0,0,537,79,1,0,0,0,538,
        540,5,66,0,0,539,541,7,10,0,0,540,539,1,0,0,0,541,542,1,0,0,0,542,
        540,1,0,0,0,542,543,1,0,0,0,543,544,1,0,0,0,544,545,5,66,0,0,545,
        81,1,0,0,0,546,550,5,88,0,0,547,549,3,84,42,0,548,547,1,0,0,0,549,
        552,1,0,0,0,550,548,1,0,0,0,550,551,1,0,0,0,551,83,1,0,0,0,552,550,
        1,0,0,0,553,554,5,80,0,0,554,555,3,86,43,0,555,556,5,21,0,0,556,
        557,3,6,3,0,557,85,1,0,0,0,558,559,5,17,0,0,559,560,3,88,44,0,560,
        561,3,90,45,0,561,562,5,18,0,0,562,87,1,0,0,0,563,565,7,11,0,0,564,
        563,1,0,0,0,564,565,1,0,0,0,565,89,1,0,0,0,566,567,7,12,0,0,567,
        91,1,0,0,0,568,572,5,89,0,0,569,571,3,94,47,0,570,569,1,0,0,0,571,
        574,1,0,0,0,572,570,1,0,0,0,572,573,1,0,0,0,573,93,1,0,0,0,574,572,
        1,0,0,0,575,576,5,81,0,0,576,577,3,96,48,0,577,95,1,0,0,0,578,584,
        5,17,0,0,579,585,5,104,0,0,580,585,5,105,0,0,581,585,5,106,0,0,582,
        583,5,107,0,0,583,585,5,82,0,0,584,579,1,0,0,0,584,580,1,0,0,0,584,
        581,1,0,0,0,584,582,1,0,0,0,585,591,1,0,0,0,586,587,5,28,0,0,587,
        589,5,60,0,0,588,590,5,108,0,0,589,588,1,0,0,0,589,590,1,0,0,0,590,
        592,1,0,0,0,591,586,1,0,0,0,591,592,1,0,0,0,592,604,1,0,0,0,593,
        594,5,109,0,0,594,595,5,5,0,0,595,600,5,81,0,0,596,597,5,67,0,0,
        597,599,5,81,0,0,598,596,1,0,0,0,599,602,1,0,0,0,600,598,1,0,0,0,
        600,601,1,0,0,0,601,603,1,0,0,0,602,600,1,0,0,0,603,605,5,6,0,0,
        604,593,1,0,0,0,604,605,1,0,0,0,605,606,1,0,0,0,606,609,5,18,0,0,
        607,608,5,61,0,0,608,610,5,82,0,0,609,607,1,0,0,0,609,610,1,0,0,
        0,610,613,1,0,0,0,611,612,5,62,0,0,612,614,5,82,0,0,613,611,1,0,
        0,0,613,614,1,0,0,0,614,97,1,0,0,0,615,619,5,110,0,0,616,617,5,24,
        0,0,617,618,5,113,0,0,618,620,5,79,0,0,619,616,1,0,0,0,619,620,1,
        0,0,0,620,624,1,0,0,0,621,623,3,100,50,0,622,621,1,0,0,0,623,626,
        1,0,0,0,624,622,1,0,0,0,624,625,1,0,0,0,625,99,1,0,0,0,626,624,1,
        0,0,0,627,628,5,82,0,0,628,633,3,102,51,0,629,630,5,111,0,0,630,
        631,5,82,0,0,631,632,5,112,0,0,632,634,5,82,0,0,633,629,1,0,0,0,
        633,634,1,0,0,0,634,101,1,0,0,0,635,636,5,113,0,0,636,638,5,79,0,
        0,637,635,1,0,0,0,637,638,1,0,0,0,638,640,1,0,0,0,639,641,5,114,
        0,0,640,639,1,0,0,0,640,641,1,0,0,0,641,647,1,0,0,0,642,644,5,29,
        0,0,643,645,5,2,0,0,644,643,1,0,0,0,644,645,1,0,0,0,645,646,1,0,
        0,0,646,648,5,71,0,0,647,642,1,0,0,0,647,648,1,0,0,0,648,650,1,0,
        0,0,649,651,5,79,0,0,650,649,1,0,0,0,651,652,1,0,0,0,652,650,1,0,
        0,0,652,653,1,0,0,0,653,103,1,0,0,0,90,118,124,126,129,132,143,150,
        155,163,165,170,176,181,187,194,209,213,217,222,225,232,236,240,
        247,250,259,264,268,271,281,290,292,296,305,311,315,318,324,328,
        338,343,347,357,361,374,385,387,394,397,401,408,416,423,431,440,
        447,449,456,459,463,473,484,487,492,497,501,503,509,518,524,533,
        542,550,564,572,584,589,591,600,604,609,613,619,624,633,637,640,
        644,647,652
    ]

class QrogueDungeonParser ( Parser ):

    grammarFileName = "QrogueDungeon.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'Name'", "'='", "'Description'", "'qubits'", 
                     "'['", "']'", "'o'", "'t'", "'m'", "'b'", "'c'", "'e'", 
                     "'r'", "'!'", "'$'", "'_'", "'('", "')'", "'input'", 
                     "'i'", "':'", "'@'", "'custom'", "'default'", "'rewards'", 
                     "'{'", "'}'", "'one way'", "'pos'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'[Robot]'", "'[StateVector Pools]'", 
                     "'[Reward Pools]'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'score'", "'key'", "'coin'", "'energy'", 
                     "'gate'", "'qubit'", "'none'", "'LevelEvent'", "'GlobalAchievement'", 
                     "'Unlocked'", "<INVALID>", "<INVALID>", "'tunnel'", 
                     "'teleport'", "'ordered'", "'random'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'tutorial'", 
                     "'trigger'", "'Qrogue<'", "'>Qrogue'", "'~'", "'|'", 
                     "','", "'#'", "'..'", "'__'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'[Layout]'", "<INVALID>", 
                     "'[Hallways]'", "'visible'", "'foggy'", "'World'", 
                     "'Level'", "'Spawn'", "'Wild'", "'Shop'", "'Riddle'", 
                     "'Boss'", "'Gate'", "'Treasure'", "'Challenge'", "'Pause'", 
                     "'Story'", "'open'", "'closed'", "'locked'", "'event'", 
                     "'permanent'", "'entangled'", "'[Messages]'", "'when'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "SR_TELEPORTER", "NO_TELEPORTER", 
                      "WITH_TELEPORTER", "SHOW_INDIV_QUBITS", "ROBOT", "STV_POOLS", 
                      "REWARD_POOLS", "MAX_ENERGY", "START_ENERGY", "CIRCUIT_SPACE", 
                      "BACKPACK_SPACE", "SCORE_LITERAL", "KEY_LITERAL", 
                      "COIN_LITERAL", "ENERGY_LITERAL", "GATE_LITERAL", 
                      "QUBIT_LITERAL", "NONE_LITERAL", "LEVEL_EVENT", "GLOBAL_ACHIEVEMENT", 
                      "UNLOCK", "GLOBAL_EVENT_REFERENCE", "UNLOCK_REFERENCE", 
                      "LOCAL_TUNNEL", "GLOBAL_TELEPORT", "ORDERED_DRAW", 
                      "RANDOM_DRAW", "NUM_QUBITS_SPECIFIER", "QUBIT_SPECIFIER", 
                      "GATE_SPECIFIER", "DIRECTION", "TUTORIAL_LITERAL", 
                      "TRIGGER_LITERAL", "HEADER", "ENDER", "HORIZONTAL_SEPARATOR", 
                      "VERTICAL_SEPARATOR", "LIST_SEPARATOR", "WALL", "EMPTY_HALLWAY", 
                      "EMPTY_ROOM", "DIGIT", "INTEGER", "FLOAT", "IMAG_NUMBER", 
                      "SIGN", "CHARACTER_LOW", "CHARACTER_UP", "CHARACTER", 
                      "TEXT", "ROOM_ID", "HALLWAY_ID", "REFERENCE", "WS", 
                      "UNIVERSAL_SEPARATOR", "COMMENT", "LINE_COMMENT", 
                      "LAYOUT", "ROOMS", "HALLWAYS", "VISIBLE_LITERAL", 
                      "FOGGY_LITERAL", "WORLD_LITERAL", "LEVEL_LITERAL", 
                      "SPAWN_LITERAL", "WILD_LITERAL", "SHOP_LITERAL", "RIDDLE_LITERAL", 
                      "BOSS_LITERAL", "GATE_ROOM_LITERAL", "TREASURE_LITERAL", 
                      "CHALLENGE_LITERAL", "PAUSE_LITERAL", "STORY_LITERAL", 
                      "OPEN_LITERAL", "CLOSED_LITERAL", "LOCKED_LITERAL", 
                      "EVENT_LITERAL", "PERMANENT_LITERAL", "ENTANGLED_LITERAL", 
                      "MESSAGES", "MSG_EVENT", "MSG_ALTERNATIVE", "MSG_SPEAKER", 
                      "MSG_PRIORITY" ]

    RULE_start = 0
    RULE_meta = 1
    RULE_robot = 2
    RULE_room_content = 3
    RULE_r_row = 4
    RULE_tile = 5
    RULE_tile_descriptor = 6
    RULE_t_descriptor = 7
    RULE_trigger_descriptor = 8
    RULE_teleport_descriptor = 9
    RULE_message_descriptor = 10
    RULE_collectible_descriptor = 11
    RULE_energy_descriptor = 12
    RULE_shop_descriptor = 13
    RULE_enemy_descriptor = 14
    RULE_boss_descriptor = 15
    RULE_riddle_descriptor = 16
    RULE_challenge_descriptor = 17
    RULE_puzzle_parameter = 18
    RULE_input_stv = 19
    RULE_boss_puzzle = 20
    RULE_circuit_stv = 21
    RULE_circuit_gate_single = 22
    RULE_circuit_gate_multi = 23
    RULE_draw_strategy = 24
    RULE_stv_pools = 25
    RULE_default_stv_pool = 26
    RULE_stv_pool = 27
    RULE_stvs = 28
    RULE_stv_ref = 29
    RULE_stv = 30
    RULE_reward_pools = 31
    RULE_default_reward_pool = 32
    RULE_reward_pool = 33
    RULE_collectibles = 34
    RULE_collectible = 35
    RULE_integer = 36
    RULE_complex_number = 37
    RULE_layout = 38
    RULE_l_room_row = 39
    RULE_l_hallway_row = 40
    RULE_rooms = 41
    RULE_room = 42
    RULE_r_attributes = 43
    RULE_r_visibility = 44
    RULE_r_type = 45
    RULE_hallways = 46
    RULE_hallway = 47
    RULE_h_attributes = 48
    RULE_messages = 49
    RULE_message = 50
    RULE_message_body = 51

    ruleNames =  [ "start", "meta", "robot", "room_content", "r_row", "tile", 
                   "tile_descriptor", "t_descriptor", "trigger_descriptor", 
                   "teleport_descriptor", "message_descriptor", "collectible_descriptor", 
                   "energy_descriptor", "shop_descriptor", "enemy_descriptor", 
                   "boss_descriptor", "riddle_descriptor", "challenge_descriptor", 
                   "puzzle_parameter", "input_stv", "boss_puzzle", "circuit_stv", 
                   "circuit_gate_single", "circuit_gate_multi", "draw_strategy", 
                   "stv_pools", "default_stv_pool", "stv_pool", "stvs", 
                   "stv_ref", "stv", "reward_pools", "default_reward_pool", 
                   "reward_pool", "collectibles", "collectible", "integer", 
                   "complex_number", "layout", "l_room_row", "l_hallway_row", 
                   "rooms", "room", "r_attributes", "r_visibility", "r_type", 
                   "hallways", "hallway", "h_attributes", "messages", "message", 
                   "message_body" ]

    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
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    T__26=27
    T__27=28
    T__28=29
    SR_TELEPORTER=30
    NO_TELEPORTER=31
    WITH_TELEPORTER=32
    SHOW_INDIV_QUBITS=33
    ROBOT=34
    STV_POOLS=35
    REWARD_POOLS=36
    MAX_ENERGY=37
    START_ENERGY=38
    CIRCUIT_SPACE=39
    BACKPACK_SPACE=40
    SCORE_LITERAL=41
    KEY_LITERAL=42
    COIN_LITERAL=43
    ENERGY_LITERAL=44
    GATE_LITERAL=45
    QUBIT_LITERAL=46
    NONE_LITERAL=47
    LEVEL_EVENT=48
    GLOBAL_ACHIEVEMENT=49
    UNLOCK=50
    GLOBAL_EVENT_REFERENCE=51
    UNLOCK_REFERENCE=52
    LOCAL_TUNNEL=53
    GLOBAL_TELEPORT=54
    ORDERED_DRAW=55
    RANDOM_DRAW=56
    NUM_QUBITS_SPECIFIER=57
    QUBIT_SPECIFIER=58
    GATE_SPECIFIER=59
    DIRECTION=60
    TUTORIAL_LITERAL=61
    TRIGGER_LITERAL=62
    HEADER=63
    ENDER=64
    HORIZONTAL_SEPARATOR=65
    VERTICAL_SEPARATOR=66
    LIST_SEPARATOR=67
    WALL=68
    EMPTY_HALLWAY=69
    EMPTY_ROOM=70
    DIGIT=71
    INTEGER=72
    FLOAT=73
    IMAG_NUMBER=74
    SIGN=75
    CHARACTER_LOW=76
    CHARACTER_UP=77
    CHARACTER=78
    TEXT=79
    ROOM_ID=80
    HALLWAY_ID=81
    REFERENCE=82
    WS=83
    UNIVERSAL_SEPARATOR=84
    COMMENT=85
    LINE_COMMENT=86
    LAYOUT=87
    ROOMS=88
    HALLWAYS=89
    VISIBLE_LITERAL=90
    FOGGY_LITERAL=91
    WORLD_LITERAL=92
    LEVEL_LITERAL=93
    SPAWN_LITERAL=94
    WILD_LITERAL=95
    SHOP_LITERAL=96
    RIDDLE_LITERAL=97
    BOSS_LITERAL=98
    GATE_ROOM_LITERAL=99
    TREASURE_LITERAL=100
    CHALLENGE_LITERAL=101
    PAUSE_LITERAL=102
    STORY_LITERAL=103
    OPEN_LITERAL=104
    CLOSED_LITERAL=105
    LOCKED_LITERAL=106
    EVENT_LITERAL=107
    PERMANENT_LITERAL=108
    ENTANGLED_LITERAL=109
    MESSAGES=110
    MSG_EVENT=111
    MSG_ALTERNATIVE=112
    MSG_SPEAKER=113
    MSG_PRIORITY=114

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




    class StartContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def meta(self):
            return self.getTypedRuleContext(QrogueDungeonParser.MetaContext,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 getRuleIndex(self):
            return QrogueDungeonParser.RULE_start

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

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

        def accept(self, visitor:ParseTreeVisitor):
            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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 104
            self.match(QrogueDungeonParser.HEADER)
            self.state = 105
            self.meta()
            self.state = 106
            self.robot()
            self.state = 107
            self.layout()
            self.state = 108
            self.rooms()
            self.state = 109
            self.hallways()
            self.state = 110
            self.stv_pools()
            self.state = 111
            self.reward_pools()
            self.state = 112
            self.messages()
            self.state = 113
            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 MetaContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

        def message_body(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Message_bodyContext,0)


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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_meta

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

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

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




    def meta(self):

        localctx = QrogueDungeonParser.MetaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_meta)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 118
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==1:
                self.state = 115
                self.match(QrogueDungeonParser.T__0)
                self.state = 116
                self.match(QrogueDungeonParser.T__1)
                self.state = 117
                self.match(QrogueDungeonParser.TEXT)


            self.state = 126
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==3:
                self.state = 120
                self.match(QrogueDungeonParser.T__2)
                self.state = 121
                self.match(QrogueDungeonParser.T__1)
                self.state = 124
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [29, 79, 113, 114]:
                    self.state = 122
                    self.message_body()
                    pass
                elif token in [82]:
                    self.state = 123
                    self.match(QrogueDungeonParser.REFERENCE)
                    pass
                else:
                    raise NoViableAltException(self)



            self.state = 129
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==31 or _la==32:
                self.state = 128
                _la = self._input.LA(1)
                if not(_la==31 or _la==32):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 132
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==33:
                self.state = 131
                self.match(QrogueDungeonParser.SHOW_INDIV_QUBITS)


        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):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:int=None):
            if i is None:
                return self.getTokens(QrogueDungeonParser.REFERENCE)
            else:
                return self.getToken(QrogueDungeonParser.REFERENCE, i)

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

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

        def integer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.IntegerContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.IntegerContext,i)


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

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

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_robot

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

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 4, self.RULE_robot)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 134
            self.match(QrogueDungeonParser.ROBOT)
            self.state = 135
            self.match(QrogueDungeonParser.DIGIT)
            self.state = 136
            self.match(QrogueDungeonParser.T__3)
            self.state = 137
            self.match(QrogueDungeonParser.T__4)
            self.state = 138
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 143
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==67:
                self.state = 139
                self.match(QrogueDungeonParser.LIST_SEPARATOR)
                self.state = 140
                self.match(QrogueDungeonParser.REFERENCE)
                self.state = 145
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 146
            self.match(QrogueDungeonParser.T__5)
            self.state = 150
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==39:
                self.state = 147
                self.match(QrogueDungeonParser.CIRCUIT_SPACE)
                self.state = 148
                self.match(QrogueDungeonParser.T__1)
                self.state = 149
                self.integer()


            self.state = 155
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==40:
                self.state = 152
                self.match(QrogueDungeonParser.BACKPACK_SPACE)
                self.state = 153
                self.match(QrogueDungeonParser.T__1)
                self.state = 154
                self.integer()


            self.state = 165
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==37:
                self.state = 157
                self.match(QrogueDungeonParser.MAX_ENERGY)
                self.state = 158
                self.match(QrogueDungeonParser.T__1)
                self.state = 159
                self.integer()
                self.state = 163
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==38:
                    self.state = 160
                    self.match(QrogueDungeonParser.START_ENERGY)
                    self.state = 161
                    self.match(QrogueDungeonParser.T__1)
                    self.state = 162
                    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 Room_contentContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def tile_descriptor(self, i:int=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_content

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

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

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




    def room_content(self):

        localctx = QrogueDungeonParser.Room_contentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_room_content)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 170
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,10,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 167
                    self.match(QrogueDungeonParser.WALL) 
                self.state = 172
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,10,self._ctx)

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

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

            self.state = 181
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==68:
                self.state = 178
                self.match(QrogueDungeonParser.WALL)
                self.state = 183
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 187
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 8)) & ~0x3f) == 0 and ((1 << (_la - 8)) & -9223372036854775553) != 0):
                self.state = 184
                self.tile_descriptor()
                self.state = 189
                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_rowContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def tile(self, i:int=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:ParseTreeListener):
            if hasattr( listener, "enterR_row" ):
                listener.enterR_row(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 8, self.RULE_r_row)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 190
            self.match(QrogueDungeonParser.WALL)
            self.state = 192 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 191
                self.tile()
                self.state = 194 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 130944) != 0) or _la==71):
                    break

            self.state = 196
            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):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:ParseTreeListener):
            if hasattr( listener, "enterTile" ):
                listener.enterTile(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 10, self.RULE_tile)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 198
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 130944) != 0) or _la==71):
                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):
        __slots__ = 'parser'

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

        def t_descriptor(self):
            return self.getTypedRuleContext(QrogueDungeonParser.T_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 boss_descriptor(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Boss_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 challenge_descriptor(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Challenge_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:int=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 GLOBAL_EVENT_REFERENCE(self):
            return self.getToken(QrogueDungeonParser.GLOBAL_EVENT_REFERENCE, 0)

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_tile_descriptor

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

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 12, self.RULE_tile_descriptor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 209
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [8]:
                self.state = 200
                self.t_descriptor()
                pass
            elif token in [9]:
                self.state = 201
                self.message_descriptor()
                pass
            elif token in [71]:
                self.state = 202
                self.enemy_descriptor()
                pass
            elif token in [10]:
                self.state = 203
                self.boss_descriptor()
                pass
            elif token in [11]:
                self.state = 204
                self.collectible_descriptor()
                pass
            elif token in [12]:
                self.state = 205
                self.energy_descriptor()
                pass
            elif token in [13]:
                self.state = 206
                self.riddle_descriptor()
                pass
            elif token in [14]:
                self.state = 207
                self.challenge_descriptor()
                pass
            elif token in [15]:
                self.state = 208
                self.shop_descriptor()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 213
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==61:
                self.state = 211
                self.match(QrogueDungeonParser.TUTORIAL_LITERAL)
                self.state = 212
                self.match(QrogueDungeonParser.REFERENCE)


            self.state = 217
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==62:
                self.state = 215
                self.match(QrogueDungeonParser.TRIGGER_LITERAL)
                self.state = 216
                _la = self._input.LA(1)
                if not(((((_la - 51)) & ~0x3f) == 0 and ((1 << (_la - 51)) & 2147483651) != 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 T_descriptorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def teleport_descriptor(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Teleport_descriptorContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_t_descriptor

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

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

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




    def t_descriptor(self):

        localctx = QrogueDungeonParser.T_descriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_t_descriptor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 219
            self.match(QrogueDungeonParser.T__7)
            self.state = 222
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [48, 49, 50, 82]:
                self.state = 220
                self.trigger_descriptor()
                pass
            elif token in [53, 54]:
                self.state = 221
                self.teleport_descriptor()
                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 Trigger_descriptorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_trigger_descriptor

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

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 16, self.RULE_trigger_descriptor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 225
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1970324836974592) != 0):
                self.state = 224
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 1970324836974592) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 227
            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 Teleport_descriptorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_teleport_descriptor

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

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

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




    def teleport_descriptor(self):

        localctx = QrogueDungeonParser.Teleport_descriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_teleport_descriptor)
        try:
            self.state = 236
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [53]:
                self.enterOuterAlt(localctx, 1)
                self.state = 229
                self.match(QrogueDungeonParser.LOCAL_TUNNEL)
                self.state = 230
                self.match(QrogueDungeonParser.ROOM_ID)
                self.state = 232
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
                if la_ == 1:
                    self.state = 231
                    self.integer()


                pass
            elif token in [54]:
                self.enterOuterAlt(localctx, 2)
                self.state = 234
                self.match(QrogueDungeonParser.GLOBAL_TELEPORT)
                self.state = 235
                self.match(QrogueDungeonParser.REFERENCE)
                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 Message_descriptorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_message_descriptor

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

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 20, self.RULE_message_descriptor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 238
            self.match(QrogueDungeonParser.T__8)
            self.state = 240
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & 1027) != 0):
                self.state = 239
                self.integer()


            self.state = 242
            _la = self._input.LA(1)
            if not(_la==79 or _la==82):
                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 Collectible_descriptorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        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:ParseTreeListener):
            if hasattr( listener, "enterCollectible_descriptor" ):
                listener.enterCollectible_descriptor(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 22, self.RULE_collectible_descriptor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 244
            self.match(QrogueDungeonParser.T__10)
            self.state = 250
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [82]:
                self.state = 245
                self.match(QrogueDungeonParser.REFERENCE)
                self.state = 247
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
                if la_ == 1:
                    self.state = 246
                    self.integer()


                pass
            elif token in [41, 42, 43, 44, 45, 46, 47]:
                self.state = 249
                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 Energy_descriptorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:ParseTreeListener):
            if hasattr( listener, "enterEnergy_descriptor" ):
                listener.enterEnergy_descriptor(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 24, self.RULE_energy_descriptor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 252
            self.match(QrogueDungeonParser.T__11)
            self.state = 253
            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 Shop_descriptorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:ParseTreeListener):
            if hasattr( listener, "enterShop_descriptor" ):
                listener.enterShop_descriptor(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 26, self.RULE_shop_descriptor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 255
            self.match(QrogueDungeonParser.T__14)
            self.state = 256
            self.integer()
            self.state = 259
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [82]:
                self.state = 257
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [5]:
                self.state = 258
                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 Enemy_descriptorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def REFERENCE(self, i:int=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 input_stv(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Input_stvContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_enemy_descriptor

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

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 28, self.RULE_enemy_descriptor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 261
            self.match(QrogueDungeonParser.DIGIT)
            self.state = 264
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [82]:
                self.state = 262
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [5, 26]:
                self.state = 263
                self.stv()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 268
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [82]:
                self.state = 266
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [41, 42, 43, 44, 45, 46, 47]:
                self.state = 267
                self.collectible()
                pass
            elif token in [8, 9, 10, 11, 12, 13, 14, 15, 19, 20, 61, 62, 71, 80, 89]:
                pass
            else:
                pass
            self.state = 271
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==19 or _la==20:
                self.state = 270
                self.input_stv()


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


    class Boss_descriptorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def boss_puzzle(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.Boss_puzzleContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.Boss_puzzleContext,i)


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


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

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

        def circuit_stv(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Circuit_stvContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_boss_descriptor

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

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

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




    def boss_descriptor(self):

        localctx = QrogueDungeonParser.Boss_descriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_boss_descriptor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 273
            self.match(QrogueDungeonParser.T__9)
            self.state = 292
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [82]:
                self.state = 274
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [5]:
                self.state = 275
                self.match(QrogueDungeonParser.T__4)
                self.state = 276
                self.boss_puzzle()
                self.state = 281
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==67:
                    self.state = 277
                    self.match(QrogueDungeonParser.LIST_SEPARATOR)
                    self.state = 278
                    self.boss_puzzle()
                    self.state = 283
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 284
                self.match(QrogueDungeonParser.T__5)
                self.state = 290
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
                if la_ == 1:
                    self.state = 285
                    self.match(QrogueDungeonParser.GATE_LITERAL)
                    self.state = 286
                    self.match(QrogueDungeonParser.T__16)
                    self.state = 287
                    self.circuit_stv()
                    self.state = 288
                    self.match(QrogueDungeonParser.T__17)


                pass
            else:
                raise NoViableAltException(self)

            self.state = 296
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [82]:
                self.state = 294
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [41, 42, 43, 44, 45, 46, 47]:
                self.state = 295
                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 Riddle_descriptorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def puzzle_parameter(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Puzzle_parameterContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_riddle_descriptor

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

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 32, self.RULE_riddle_descriptor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 298
            self.match(QrogueDungeonParser.T__12)
            self.state = 299
            self.integer()
            self.state = 300
            self.puzzle_parameter()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Challenge_descriptorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def integer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.IntegerContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.IntegerContext,i)


        def puzzle_parameter(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Puzzle_parameterContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_challenge_descriptor

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

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

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




    def challenge_descriptor(self):

        localctx = QrogueDungeonParser.Challenge_descriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_challenge_descriptor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 302
            self.match(QrogueDungeonParser.T__13)
            self.state = 303
            self.integer()
            self.state = 305
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & 1027) != 0):
                self.state = 304
                self.integer()


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


    class Puzzle_parameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def REFERENCE(self, i:int=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 input_stv(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Input_stvContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_puzzle_parameter

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

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

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




    def puzzle_parameter(self):

        localctx = QrogueDungeonParser.Puzzle_parameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_puzzle_parameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 311
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [82]:
                self.state = 309
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [5, 26]:
                self.state = 310
                self.stv()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 315
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [82]:
                self.state = 313
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [41, 42, 43, 44, 45, 46, 47]:
                self.state = 314
                self.collectible()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 318
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==19 or _la==20:
                self.state = 317
                self.input_stv()


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


    class Input_stvContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_input_stv

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

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

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




    def input_stv(self):

        localctx = QrogueDungeonParser.Input_stvContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_input_stv)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 320
            _la = self._input.LA(1)
            if not(_la==19 or _la==20):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 321
            self.match(QrogueDungeonParser.T__1)
            self.state = 324
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [82]:
                self.state = 322
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [5, 26]:
                self.state = 323
                self.stv()
                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 Boss_puzzleContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def input_stv(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Input_stvContext,0)


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

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


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_boss_puzzle

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

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

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




    def boss_puzzle(self):

        localctx = QrogueDungeonParser.Boss_puzzleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_boss_puzzle)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 328
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [82]:
                self.state = 326
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [5, 26]:
                self.state = 327
                self.stv()
                pass
            else:
                raise NoViableAltException(self)

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


    class Circuit_stvContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def circuit_gate_single(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.Circuit_gate_singleContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.Circuit_gate_singleContext,i)


        def circuit_gate_multi(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.Circuit_gate_multiContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.Circuit_gate_multiContext,i)


        def LIST_SEPARATOR(self, i:int=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_circuit_stv

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

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

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




    def circuit_stv(self):

        localctx = QrogueDungeonParser.Circuit_stvContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_circuit_stv)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 332
            self.match(QrogueDungeonParser.NUM_QUBITS_SPECIFIER)
            self.state = 333
            self.match(QrogueDungeonParser.T__1)
            self.state = 334
            self.match(QrogueDungeonParser.DIGIT)
            self.state = 335
            self.match(QrogueDungeonParser.T__20)
            self.state = 338
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
            if la_ == 1:
                self.state = 336
                self.circuit_gate_single()
                pass

            elif la_ == 2:
                self.state = 337
                self.circuit_gate_multi()
                pass


            self.state = 347
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==67:
                self.state = 340
                self.match(QrogueDungeonParser.LIST_SEPARATOR)
                self.state = 343
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
                if la_ == 1:
                    self.state = 341
                    self.circuit_gate_single()
                    pass

                elif la_ == 2:
                    self.state = 342
                    self.circuit_gate_multi()
                    pass


                self.state = 349
                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 Circuit_gate_singleContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def LIST_SEPARATOR(self, i:int=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_circuit_gate_single

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

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

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




    def circuit_gate_single(self):

        localctx = QrogueDungeonParser.Circuit_gate_singleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_circuit_gate_single)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 361
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [59]:
                self.state = 350
                self.match(QrogueDungeonParser.GATE_SPECIFIER)
                pass
            elif token in [5]:
                self.state = 351
                self.match(QrogueDungeonParser.T__4)
                self.state = 352
                self.match(QrogueDungeonParser.GATE_SPECIFIER)
                self.state = 357
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==67:
                    self.state = 353
                    self.match(QrogueDungeonParser.LIST_SEPARATOR)
                    self.state = 354
                    self.match(QrogueDungeonParser.GATE_SPECIFIER)
                    self.state = 359
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 360
                self.match(QrogueDungeonParser.T__5)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 363
            self.match(QrogueDungeonParser.T__21)
            self.state = 364
            self.match(QrogueDungeonParser.QUBIT_SPECIFIER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Circuit_gate_multiContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_circuit_gate_multi

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

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

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




    def circuit_gate_multi(self):

        localctx = QrogueDungeonParser.Circuit_gate_multiContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_circuit_gate_multi)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 366
            self.match(QrogueDungeonParser.GATE_SPECIFIER)
            self.state = 367
            self.match(QrogueDungeonParser.T__21)
            self.state = 368
            self.match(QrogueDungeonParser.T__4)
            self.state = 369
            self.match(QrogueDungeonParser.QUBIT_SPECIFIER)
            self.state = 370
            self.match(QrogueDungeonParser.LIST_SEPARATOR)
            self.state = 372 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 371
                self.match(QrogueDungeonParser.QUBIT_SPECIFIER)
                self.state = 374 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==58):
                    break

            self.state = 376
            self.match(QrogueDungeonParser.T__5)
        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):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:ParseTreeListener):
            if hasattr( listener, "enterDraw_strategy" ):
                listener.enterDraw_strategy(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 48, self.RULE_draw_strategy)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 378
            _la = self._input.LA(1)
            if not(_la==55 or _la==56):
                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):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:int=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:ParseTreeListener):
            if hasattr( listener, "enterStv_pools" ):
                listener.enterStv_pools(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 50, self.RULE_stv_pools)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 380
            self.match(QrogueDungeonParser.STV_POOLS)
            self.state = 387
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==23:
                self.state = 381
                self.match(QrogueDungeonParser.T__22)
                self.state = 383 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 382
                    self.stv_pool()
                    self.state = 385 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==82):
                        break



            self.state = 389
            self.match(QrogueDungeonParser.T__23)
            self.state = 390
            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):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:ParseTreeListener):
            if hasattr( listener, "enterDefault_stv_pool" ):
                listener.enterDefault_stv_pool(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 52, self.RULE_default_stv_pool)
        self._la = 0 # Token type
        try:
            self.state = 397
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [82]:
                self.enterOuterAlt(localctx, 1)
                self.state = 392
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [5, 55, 56]:
                self.enterOuterAlt(localctx, 2)
                self.state = 394
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==55 or _la==56:
                    self.state = 393
                    self.draw_strategy()


                self.state = 396
                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):
        __slots__ = 'parser'

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

        def REFERENCE(self, i:int=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:ParseTreeListener):
            if hasattr( listener, "enterStv_pool" ):
                listener.enterStv_pool(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 54, self.RULE_stv_pool)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 399
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 401
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==55 or _la==56:
                self.state = 400
                self.draw_strategy()


            self.state = 403
            self.stvs()
            self.state = 408
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
            if la_ == 1:
                self.state = 404
                self.match(QrogueDungeonParser.T__23)
                self.state = 405
                self.match(QrogueDungeonParser.T__24)
                self.state = 406
                self.match(QrogueDungeonParser.T__20)
                self.state = 407
                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):
        __slots__ = 'parser'

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

        def stv_ref(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.Stv_refContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.Stv_refContext,i)


        def LIST_SEPARATOR(self, i:int=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:ParseTreeListener):
            if hasattr( listener, "enterStvs" ):
                listener.enterStvs(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 56, self.RULE_stvs)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 410
            self.match(QrogueDungeonParser.T__4)
            self.state = 411
            self.stv_ref()
            self.state = 416
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==67:
                self.state = 412
                self.match(QrogueDungeonParser.LIST_SEPARATOR)
                self.state = 413
                self.stv_ref()
                self.state = 418
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Stv_refContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_stv_ref

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

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

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




    def stv_ref(self):

        localctx = QrogueDungeonParser.Stv_refContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_stv_ref)
        try:
            self.state = 423
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5, 26]:
                self.enterOuterAlt(localctx, 1)
                self.state = 421
                self.stv()
                pass
            elif token in [82]:
                self.enterOuterAlt(localctx, 2)
                self.state = 422
                self.match(QrogueDungeonParser.REFERENCE)
                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 StvContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def circuit_stv(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Circuit_stvContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_stv

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

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

        def accept(self, visitor:ParseTreeVisitor):
            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.state = 440
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5]:
                self.enterOuterAlt(localctx, 1)
                self.state = 425
                self.match(QrogueDungeonParser.T__4)
                self.state = 426
                self.complex_number()
                self.state = 431
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==67:
                    self.state = 427
                    self.match(QrogueDungeonParser.LIST_SEPARATOR)
                    self.state = 428
                    self.complex_number()
                    self.state = 433
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 434
                self.match(QrogueDungeonParser.T__5)
                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 2)
                self.state = 436
                self.match(QrogueDungeonParser.T__25)
                self.state = 437
                self.circuit_stv()
                self.state = 438
                self.match(QrogueDungeonParser.T__26)
                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_poolsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:int=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:ParseTreeListener):
            if hasattr( listener, "enterReward_pools" ):
                listener.enterReward_pools(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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 = 442
            self.match(QrogueDungeonParser.REWARD_POOLS)
            self.state = 449
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==23:
                self.state = 443
                self.match(QrogueDungeonParser.T__22)
                self.state = 445 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 444
                    self.reward_pool()
                    self.state = 447 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==82):
                        break



            self.state = 451
            self.match(QrogueDungeonParser.T__23)
            self.state = 452
            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):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:ParseTreeListener):
            if hasattr( listener, "enterDefault_reward_pool" ):
                listener.enterDefault_reward_pool(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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 = 459
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [82]:
                self.enterOuterAlt(localctx, 1)
                self.state = 454
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [5, 55, 56]:
                self.enterOuterAlt(localctx, 2)
                self.state = 456
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==55 or _la==56:
                    self.state = 455
                    self.draw_strategy()


                self.state = 458
                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):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:ParseTreeListener):
            if hasattr( listener, "enterReward_pool" ):
                listener.enterReward_pool(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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 = 461
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 463
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==55 or _la==56:
                self.state = 462
                self.draw_strategy()


            self.state = 465
            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):
        __slots__ = 'parser'

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

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


        def LIST_SEPARATOR(self, i:int=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:ParseTreeListener):
            if hasattr( listener, "enterCollectibles" ):
                listener.enterCollectibles(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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 = 467
            self.match(QrogueDungeonParser.T__4)
            self.state = 468
            self.collectible()
            self.state = 473
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==67:
                self.state = 469
                self.match(QrogueDungeonParser.LIST_SEPARATOR)
                self.state = 470
                self.collectible()
                self.state = 475
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 476
            self.match(QrogueDungeonParser.T__5)
        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):
        __slots__ = 'parser'

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

        def integer(self):
            return self.getTypedRuleContext(QrogueDungeonParser.IntegerContext,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 NONE_LITERAL(self):
            return self.getToken(QrogueDungeonParser.NONE_LITERAL, 0)

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

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

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

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_collectible

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

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

        def accept(self, visitor:ParseTreeVisitor):
            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)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 487
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [41, 42, 43, 44]:
                self.state = 478
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 32985348833280) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 479
                self.integer()
                pass
            elif token in [45]:
                self.state = 480
                self.match(QrogueDungeonParser.GATE_LITERAL)
                self.state = 481
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [46]:
                self.state = 482
                self.match(QrogueDungeonParser.QUBIT_LITERAL)
                self.state = 484
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
                if la_ == 1:
                    self.state = 483
                    self.integer()


                pass
            elif token in [47]:
                self.state = 486
                self.match(QrogueDungeonParser.NONE_LITERAL)
                pass
            else:
                raise NoViableAltException(self)

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


    class IntegerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:ParseTreeListener):
            if hasattr( listener, "enterInteger" ):
                listener.enterInteger(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 72, self.RULE_integer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 489
            _la = self._input.LA(1)
            if not(((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & 1027) != 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):
        __slots__ = 'parser'

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

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

        def SIGN(self, i:int=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:ParseTreeListener):
            if hasattr( listener, "enterComplex_number" ):
                listener.enterComplex_number(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 74, self.RULE_complex_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 492
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==75:
                self.state = 491
                self.match(QrogueDungeonParser.SIGN)


            self.state = 503
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [74]:
                self.state = 494
                self.match(QrogueDungeonParser.IMAG_NUMBER)
                pass
            elif token in [71, 72, 73, 81]:
                self.state = 497
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [71, 72, 81]:
                    self.state = 495
                    self.integer()
                    pass
                elif token in [73]:
                    self.state = 496
                    self.match(QrogueDungeonParser.FLOAT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 501
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==75:
                    self.state = 499
                    self.match(QrogueDungeonParser.SIGN)
                    self.state = 500
                    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 LayoutContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def l_room_row(self, i:int=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:int=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:int=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:ParseTreeListener):
            if hasattr( listener, "enterLayout" ):
                listener.enterLayout(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 76, self.RULE_layout)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 505
            self.match(QrogueDungeonParser.LAYOUT)
            self.state = 509
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==65:
                self.state = 506
                self.match(QrogueDungeonParser.HORIZONTAL_SEPARATOR)
                self.state = 511
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 512
            self.l_room_row()
            self.state = 518
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==66:
                self.state = 513
                self.l_hallway_row()
                self.state = 514
                self.l_room_row()
                self.state = 520
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 524
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==65:
                self.state = 521
                self.match(QrogueDungeonParser.HORIZONTAL_SEPARATOR)
                self.state = 526
                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):
        __slots__ = 'parser'

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

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

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

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

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

        def EMPTY_HALLWAY(self, i:int=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:ParseTreeListener):
            if hasattr( listener, "enterL_room_row" ):
                listener.enterL_room_row(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 78, self.RULE_l_room_row)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 527
            self.match(QrogueDungeonParser.VERTICAL_SEPARATOR)
            self.state = 528
            _la = self._input.LA(1)
            if not(_la==70 or _la==80):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 533
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==69 or _la==81:
                self.state = 529
                _la = self._input.LA(1)
                if not(_la==69 or _la==81):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 530
                _la = self._input.LA(1)
                if not(_la==70 or _la==80):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 535
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 536
            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):
        __slots__ = 'parser'

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

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

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

        def EMPTY_HALLWAY(self, i:int=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:ParseTreeListener):
            if hasattr( listener, "enterL_hallway_row" ):
                listener.enterL_hallway_row(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 80, self.RULE_l_hallway_row)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 538
            self.match(QrogueDungeonParser.VERTICAL_SEPARATOR)
            self.state = 540 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 539
                _la = self._input.LA(1)
                if not(_la==69 or _la==81):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 542 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==69 or _la==81):
                    break

            self.state = 544
            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):
        __slots__ = 'parser'

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

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

        def room(self, i:int=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:ParseTreeListener):
            if hasattr( listener, "enterRooms" ):
                listener.enterRooms(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 82, self.RULE_rooms)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 546
            self.match(QrogueDungeonParser.ROOMS)
            self.state = 550
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==80:
                self.state = 547
                self.room()
                self.state = 552
                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):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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 room_content(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Room_contentContext,0)


        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_room

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

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 84, self.RULE_room)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 553
            self.match(QrogueDungeonParser.ROOM_ID)
            self.state = 554
            self.r_attributes()
            self.state = 555
            self.match(QrogueDungeonParser.T__20)
            self.state = 556
            self.room_content()
        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):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:ParseTreeListener):
            if hasattr( listener, "enterR_attributes" ):
                listener.enterR_attributes(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 86, self.RULE_r_attributes)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 558
            self.match(QrogueDungeonParser.T__16)
            self.state = 559
            self.r_visibility()
            self.state = 560
            self.r_type()
            self.state = 561
            self.match(QrogueDungeonParser.T__17)
        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):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:ParseTreeListener):
            if hasattr( listener, "enterR_visibility" ):
                listener.enterR_visibility(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 88, self.RULE_r_visibility)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 564
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==90 or _la==91:
                self.state = 563
                _la = self._input.LA(1)
                if not(_la==90 or _la==91):
                    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):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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 CHALLENGE_LITERAL(self):
            return self.getToken(QrogueDungeonParser.CHALLENGE_LITERAL, 0)

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

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_r_type

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

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 90, self.RULE_r_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 566
            _la = self._input.LA(1)
            if not(((((_la - 94)) & ~0x3f) == 0 and ((1 << (_la - 94)) & 1023) != 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 HallwaysContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def hallway(self, i:int=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:ParseTreeListener):
            if hasattr( listener, "enterHallways" ):
                listener.enterHallways(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 92, self.RULE_hallways)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 568
            self.match(QrogueDungeonParser.HALLWAYS)
            self.state = 572
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==81:
                self.state = 569
                self.hallway()
                self.state = 574
                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):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:ParseTreeListener):
            if hasattr( listener, "enterHallway" ):
                listener.enterHallway(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 94, self.RULE_hallway)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 575
            self.match(QrogueDungeonParser.HALLWAY_ID)
            self.state = 576
            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):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__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:int=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 ENTANGLED_LITERAL(self):
            return self.getToken(QrogueDungeonParser.ENTANGLED_LITERAL, 0)

        def HALLWAY_ID(self, i:int=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:int=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:ParseTreeListener):
            if hasattr( listener, "enterH_attributes" ):
                listener.enterH_attributes(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 96, self.RULE_h_attributes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 578
            self.match(QrogueDungeonParser.T__16)
            self.state = 584
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [104]:
                self.state = 579
                self.match(QrogueDungeonParser.OPEN_LITERAL)
                pass
            elif token in [105]:
                self.state = 580
                self.match(QrogueDungeonParser.CLOSED_LITERAL)
                pass
            elif token in [106]:
                self.state = 581
                self.match(QrogueDungeonParser.LOCKED_LITERAL)
                pass
            elif token in [107]:
                self.state = 582
                self.match(QrogueDungeonParser.EVENT_LITERAL)
                self.state = 583
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 591
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==28:
                self.state = 586
                self.match(QrogueDungeonParser.T__27)
                self.state = 587
                self.match(QrogueDungeonParser.DIRECTION)
                self.state = 589
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==108:
                    self.state = 588
                    self.match(QrogueDungeonParser.PERMANENT_LITERAL)




            self.state = 604
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==109:
                self.state = 593
                self.match(QrogueDungeonParser.ENTANGLED_LITERAL)
                self.state = 594
                self.match(QrogueDungeonParser.T__4)
                self.state = 595
                self.match(QrogueDungeonParser.HALLWAY_ID)
                self.state = 600
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==67:
                    self.state = 596
                    self.match(QrogueDungeonParser.LIST_SEPARATOR)
                    self.state = 597
                    self.match(QrogueDungeonParser.HALLWAY_ID)
                    self.state = 602
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 603
                self.match(QrogueDungeonParser.T__5)


            self.state = 606
            self.match(QrogueDungeonParser.T__17)
            self.state = 609
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==61:
                self.state = 607
                self.match(QrogueDungeonParser.TUTORIAL_LITERAL)
                self.state = 608
                self.match(QrogueDungeonParser.REFERENCE)


            self.state = 613
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==62:
                self.state = 611
                self.match(QrogueDungeonParser.TRIGGER_LITERAL)
                self.state = 612
                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 MessagesContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def message(self, i:int=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:ParseTreeListener):
            if hasattr( listener, "enterMessages" ):
                listener.enterMessages(self)

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 98, self.RULE_messages)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 615
            self.match(QrogueDungeonParser.MESSAGES)
            self.state = 619
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==24:
                self.state = 616
                self.match(QrogueDungeonParser.T__23)
                self.state = 617
                self.match(QrogueDungeonParser.MSG_SPEAKER)
                self.state = 618
                self.match(QrogueDungeonParser.TEXT)


            self.state = 624
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==82:
                self.state = 621
                self.message()
                self.state = 626
                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):
        __slots__ = 'parser'

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

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

        def message_body(self):
            return self.getTypedRuleContext(QrogueDungeonParser.Message_bodyContext,0)


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

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_message

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

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

        def accept(self, visitor:ParseTreeVisitor):
            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, 100, self.RULE_message)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 627
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 628
            self.message_body()
            self.state = 633
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==111:
                self.state = 629
                self.match(QrogueDungeonParser.MSG_EVENT)
                self.state = 630
                self.match(QrogueDungeonParser.REFERENCE)
                self.state = 631
                self.match(QrogueDungeonParser.MSG_ALTERNATIVE)
                self.state = 632
                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_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

        def getRuleIndex(self):
            return QrogueDungeonParser.RULE_message_body

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

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

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




    def message_body(self):

        localctx = QrogueDungeonParser.Message_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_message_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 637
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==113:
                self.state = 635
                self.match(QrogueDungeonParser.MSG_SPEAKER)
                self.state = 636
                self.match(QrogueDungeonParser.TEXT)


            self.state = 640
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==114:
                self.state = 639
                self.match(QrogueDungeonParser.MSG_PRIORITY)


            self.state = 647
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==29:
                self.state = 642
                self.match(QrogueDungeonParser.T__28)
                self.state = 644
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==2:
                    self.state = 643
                    self.match(QrogueDungeonParser.T__1)


                self.state = 646
                self.match(QrogueDungeonParser.DIGIT)


            self.state = 650 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 649
                self.match(QrogueDungeonParser.TEXT)
                self.state = 652 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==79):
                    break

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





