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

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'", "'='", "'qubits'", "'['", "']'", 
                     "'o'", "'t'", "'m'", "'b'", "'c'", "'e'", "'r'", "'!'", 
                     "'_'", "'input'", "'i'", "':'", "'@'", "'custom'", 
                     "'default'", "'rewards'", "'{'", "'}'", "'('", "')'", 
                     "'one way'", "'pos'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'Description'", "'Closing'", "'[Robot]'", 
                     "'[StateVector Pools]'", "'[Reward Pools]'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'score'", "'key'", 
                     "'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'", "'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>", 
                      "SR_TELEPORTER", "NO_TELEPORTER", "WITH_TELEPORTER", 
                      "SHOW_INDIV_QUBITS", "INTRO_MSG", "END_MSG", "ROBOT", 
                      "STV_POOLS", "REWARD_POOLS", "MAX_ENERGY", "START_ENERGY", 
                      "CIRCUIT_SPACE", "BACKPACK_SPACE", "SCORE_LITERAL", 
                      "KEY_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", "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_enemy_descriptor = 13
    RULE_boss_descriptor = 14
    RULE_riddle_descriptor = 15
    RULE_challenge_descriptor = 16
    RULE_puzzle_parameter = 17
    RULE_input_stv = 18
    RULE_boss_puzzle = 19
    RULE_circuit_stv = 20
    RULE_circuit_gate_single = 21
    RULE_circuit_gate_multi = 22
    RULE_draw_strategy = 23
    RULE_stv_pools = 24
    RULE_default_stv_pool = 25
    RULE_stv_pool = 26
    RULE_stvs = 27
    RULE_stv_ref = 28
    RULE_stv = 29
    RULE_reward_pools = 30
    RULE_default_reward_pool = 31
    RULE_reward_pool = 32
    RULE_collectibles = 33
    RULE_collectible = 34
    RULE_integer = 35
    RULE_complex_number = 36
    RULE_layout = 37
    RULE_l_room_row = 38
    RULE_l_hallway_row = 39
    RULE_rooms = 40
    RULE_room = 41
    RULE_r_attributes = 42
    RULE_r_visibility = 43
    RULE_r_type = 44
    RULE_hallways = 45
    RULE_hallway = 46
    RULE_h_attributes = 47
    RULE_messages = 48
    RULE_message = 49
    RULE_message_body = 50

    ruleNames =  [ "start", "meta", "robot", "room_content", "r_row", "tile", 
                   "tile_descriptor", "t_descriptor", "trigger_descriptor", 
                   "teleport_descriptor", "message_descriptor", "collectible_descriptor", 
                   "energy_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
    SR_TELEPORTER=28
    NO_TELEPORTER=29
    WITH_TELEPORTER=30
    SHOW_INDIV_QUBITS=31
    INTRO_MSG=32
    END_MSG=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
    ENERGY_LITERAL=43
    GATE_LITERAL=44
    QUBIT_LITERAL=45
    NONE_LITERAL=46
    LEVEL_EVENT=47
    GLOBAL_ACHIEVEMENT=48
    UNLOCK=49
    GLOBAL_EVENT_REFERENCE=50
    UNLOCK_REFERENCE=51
    LOCAL_TUNNEL=52
    GLOBAL_TELEPORT=53
    ORDERED_DRAW=54
    RANDOM_DRAW=55
    NUM_QUBITS_SPECIFIER=56
    QUBIT_SPECIFIER=57
    GATE_SPECIFIER=58
    DIRECTION=59
    TUTORIAL_LITERAL=60
    TRIGGER_LITERAL=61
    HEADER=62
    ENDER=63
    HORIZONTAL_SEPARATOR=64
    VERTICAL_SEPARATOR=65
    LIST_SEPARATOR=66
    WALL=67
    EMPTY_HALLWAY=68
    EMPTY_ROOM=69
    DIGIT=70
    INTEGER=71
    FLOAT=72
    IMAG_NUMBER=73
    SIGN=74
    CHARACTER_LOW=75
    CHARACTER_UP=76
    CHARACTER=77
    TEXT=78
    ROOM_ID=79
    HALLWAY_ID=80
    REFERENCE=81
    WS=82
    UNIVERSAL_SEPARATOR=83
    COMMENT=84
    LINE_COMMENT=85
    LAYOUT=86
    ROOMS=87
    HALLWAYS=88
    VISIBLE_LITERAL=89
    FOGGY_LITERAL=90
    WORLD_LITERAL=91
    LEVEL_LITERAL=92
    SPAWN_LITERAL=93
    WILD_LITERAL=94
    RIDDLE_LITERAL=95
    BOSS_LITERAL=96
    GATE_ROOM_LITERAL=97
    TREASURE_LITERAL=98
    CHALLENGE_LITERAL=99
    PAUSE_LITERAL=100
    STORY_LITERAL=101
    OPEN_LITERAL=102
    CLOSED_LITERAL=103
    LOCKED_LITERAL=104
    EVENT_LITERAL=105
    PERMANENT_LITERAL=106
    ENTANGLED_LITERAL=107
    MESSAGES=108
    MSG_EVENT=109
    MSG_ALTERNATIVE=110
    MSG_SPEAKER=111
    MSG_PRIORITY=112

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.13.1")
        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 = 102
            self.match(QrogueDungeonParser.HEADER)
            self.state = 103
            self.meta()
            self.state = 104
            self.robot()
            self.state = 105
            self.layout()
            self.state = 106
            self.rooms()
            self.state = 107
            self.hallways()
            self.state = 108
            self.stv_pools()
            self.state = 109
            self.reward_pools()
            self.state = 110
            self.messages()
            self.state = 111
            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 INTRO_MSG(self):
            return self.getToken(QrogueDungeonParser.INTRO_MSG, 0)

        def END_MSG(self):
            return self.getToken(QrogueDungeonParser.END_MSG, 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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(QrogueDungeonParser.Message_bodyContext)
            else:
                return self.getTypedRuleContext(QrogueDungeonParser.Message_bodyContext,i)


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

        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 = 116
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==1:
                self.state = 113
                self.match(QrogueDungeonParser.T__0)
                self.state = 114
                self.match(QrogueDungeonParser.T__1)
                self.state = 115
                self.match(QrogueDungeonParser.TEXT)


            self.state = 124
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==32:
                self.state = 118
                self.match(QrogueDungeonParser.INTRO_MSG)
                self.state = 119
                self.match(QrogueDungeonParser.T__1)
                self.state = 122
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [27, 78, 111, 112]:
                    self.state = 120
                    self.message_body()
                    pass
                elif token in [81]:
                    self.state = 121
                    self.match(QrogueDungeonParser.REFERENCE)
                    pass
                else:
                    raise NoViableAltException(self)



            self.state = 132
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==33:
                self.state = 126
                self.match(QrogueDungeonParser.END_MSG)
                self.state = 127
                self.match(QrogueDungeonParser.T__1)
                self.state = 130
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [27, 78, 111, 112]:
                    self.state = 128
                    self.message_body()
                    pass
                elif token in [81]:
                    self.state = 129
                    self.match(QrogueDungeonParser.REFERENCE)
                    pass
                else:
                    raise NoViableAltException(self)



            self.state = 135
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==29 or _la==30:
                self.state = 134
                _la = self._input.LA(1)
                if not(_la==29 or _la==30):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 138
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==31:
                self.state = 137
                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 = 140
            self.match(QrogueDungeonParser.ROBOT)
            self.state = 141
            self.match(QrogueDungeonParser.DIGIT)
            self.state = 142
            self.match(QrogueDungeonParser.T__2)
            self.state = 143
            self.match(QrogueDungeonParser.T__3)
            self.state = 144
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 149
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==66:
                self.state = 145
                self.match(QrogueDungeonParser.LIST_SEPARATOR)
                self.state = 146
                self.match(QrogueDungeonParser.REFERENCE)
                self.state = 151
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 152
            self.match(QrogueDungeonParser.T__4)
            self.state = 156
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==39:
                self.state = 153
                self.match(QrogueDungeonParser.CIRCUIT_SPACE)
                self.state = 154
                self.match(QrogueDungeonParser.T__1)
                self.state = 155
                self.integer()


            self.state = 161
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==40:
                self.state = 158
                self.match(QrogueDungeonParser.BACKPACK_SPACE)
                self.state = 159
                self.match(QrogueDungeonParser.T__1)
                self.state = 160
                self.integer()


            self.state = 171
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==37:
                self.state = 163
                self.match(QrogueDungeonParser.MAX_ENERGY)
                self.state = 164
                self.match(QrogueDungeonParser.T__1)
                self.state = 165
                self.integer()
                self.state = 169
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==38:
                    self.state = 166
                    self.match(QrogueDungeonParser.START_ENERGY)
                    self.state = 167
                    self.match(QrogueDungeonParser.T__1)
                    self.state = 168
                    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 = 176
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 173
                    self.match(QrogueDungeonParser.WALL) 
                self.state = 178
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,12,self._ctx)

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

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

            self.state = 187
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==67:
                self.state = 184
                self.match(QrogueDungeonParser.WALL)
                self.state = 189
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 193
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 7)) & ~0x3f) == 0 and ((1 << (_la - 7)) & -9223372036854775681) != 0):
                self.state = 190
                self.tile_descriptor()
                self.state = 195
                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 = 196
            self.match(QrogueDungeonParser.WALL)
            self.state = 198 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 197
                self.tile()
                self.state = 200 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 32704) != 0) or _la==70):
                    break

            self.state = 202
            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 = 204
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 32704) != 0) or _la==70):
                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 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 = 214
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [7]:
                self.state = 206
                self.t_descriptor()
                pass
            elif token in [8]:
                self.state = 207
                self.message_descriptor()
                pass
            elif token in [70]:
                self.state = 208
                self.enemy_descriptor()
                pass
            elif token in [9]:
                self.state = 209
                self.boss_descriptor()
                pass
            elif token in [10]:
                self.state = 210
                self.collectible_descriptor()
                pass
            elif token in [11]:
                self.state = 211
                self.energy_descriptor()
                pass
            elif token in [12]:
                self.state = 212
                self.riddle_descriptor()
                pass
            elif token in [13]:
                self.state = 213
                self.challenge_descriptor()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 218
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==60:
                self.state = 216
                self.match(QrogueDungeonParser.TUTORIAL_LITERAL)
                self.state = 217
                self.match(QrogueDungeonParser.REFERENCE)


            self.state = 222
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==61:
                self.state = 220
                self.match(QrogueDungeonParser.TRIGGER_LITERAL)
                self.state = 221
                _la = self._input.LA(1)
                if not(((((_la - 50)) & ~0x3f) == 0 and ((1 << (_la - 50)) & 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 = 224
            self.match(QrogueDungeonParser.T__6)
            self.state = 227
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [47, 48, 49, 81]:
                self.state = 225
                self.trigger_descriptor()
                pass
            elif token in [52, 53]:
                self.state = 226
                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 = 230
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 985162418487296) != 0):
                self.state = 229
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 985162418487296) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 232
            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 = 241
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [52]:
                self.enterOuterAlt(localctx, 1)
                self.state = 234
                self.match(QrogueDungeonParser.LOCAL_TUNNEL)
                self.state = 235
                self.match(QrogueDungeonParser.ROOM_ID)
                self.state = 237
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
                if la_ == 1:
                    self.state = 236
                    self.integer()


                pass
            elif token in [53]:
                self.enterOuterAlt(localctx, 2)
                self.state = 239
                self.match(QrogueDungeonParser.GLOBAL_TELEPORT)
                self.state = 240
                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 = 243
            self.match(QrogueDungeonParser.T__7)
            self.state = 245
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 1027) != 0):
                self.state = 244
                self.integer()


            self.state = 247
            _la = self._input.LA(1)
            if not(_la==78 or _la==81):
                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 = 249
            self.match(QrogueDungeonParser.T__9)
            self.state = 255
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [81]:
                self.state = 250
                self.match(QrogueDungeonParser.REFERENCE)
                self.state = 252
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
                if la_ == 1:
                    self.state = 251
                    self.integer()


                pass
            elif token in [41, 42, 43, 44, 45, 46]:
                self.state = 254
                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 = 257
            self.match(QrogueDungeonParser.T__10)
            self.state = 258
            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 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, 26, self.RULE_enemy_descriptor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 260
            self.match(QrogueDungeonParser.DIGIT)
            self.state = 263
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [81]:
                self.state = 261
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [4, 22]:
                self.state = 262
                self.stv()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 267
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [81]:
                self.state = 265
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [41, 42, 43, 44, 45, 46]:
                self.state = 266
                self.collectible()
                pass
            elif token in [7, 8, 9, 10, 11, 12, 13, 15, 16, 60, 61, 70, 79, 88]:
                pass
            else:
                pass
            self.state = 270
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==15 or _la==16:
                self.state = 269
                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 integer(self):
            return self.getTypedRuleContext(QrogueDungeonParser.IntegerContext,0)


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


        def GATE_LITERAL(self):
            return self.getToken(QrogueDungeonParser.GATE_LITERAL, 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, 28, self.RULE_boss_descriptor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 272
            self.match(QrogueDungeonParser.T__8)
            self.state = 273
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 276
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.state = 274
                self.match(QrogueDungeonParser.GATE_LITERAL)
                self.state = 275
                self.match(QrogueDungeonParser.REFERENCE)


            self.state = 280
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [81]:
                self.state = 278
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [41, 42, 43, 44, 45, 46]:
                self.state = 279
                self.collectible()
                pass
            else:
                raise NoViableAltException(self)

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


    class Riddle_descriptorContext(ParserRuleContext):
        __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, 30, self.RULE_riddle_descriptor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 284
            self.match(QrogueDungeonParser.T__11)
            self.state = 285
            self.integer()
            self.state = 286
            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, 32, self.RULE_challenge_descriptor)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 288
            self.match(QrogueDungeonParser.T__12)
            self.state = 289
            self.integer()
            self.state = 291
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 1027) != 0):
                self.state = 290
                self.integer()


            self.state = 293
            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, 34, self.RULE_puzzle_parameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 297
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [81]:
                self.state = 295
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [4, 22]:
                self.state = 296
                self.stv()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 301
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [81]:
                self.state = 299
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [41, 42, 43, 44, 45, 46]:
                self.state = 300
                self.collectible()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 304
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==15 or _la==16:
                self.state = 303
                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, 36, self.RULE_input_stv)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 306
            _la = self._input.LA(1)
            if not(_la==15 or _la==16):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 307
            self.match(QrogueDungeonParser.T__1)
            self.state = 310
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [81]:
                self.state = 308
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [4, 22]:
                self.state = 309
                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, 38, self.RULE_boss_puzzle)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 314
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [81]:
                self.state = 312
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [4, 22]:
                self.state = 313
                self.stv()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 316
            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, 40, self.RULE_circuit_stv)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 318
            self.match(QrogueDungeonParser.NUM_QUBITS_SPECIFIER)
            self.state = 319
            self.match(QrogueDungeonParser.T__1)
            self.state = 320
            self.match(QrogueDungeonParser.DIGIT)
            self.state = 321
            self.match(QrogueDungeonParser.T__16)
            self.state = 324
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
            if la_ == 1:
                self.state = 322
                self.circuit_gate_single()
                pass

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


            self.state = 333
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==66:
                self.state = 326
                self.match(QrogueDungeonParser.LIST_SEPARATOR)
                self.state = 329
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
                if la_ == 1:
                    self.state = 327
                    self.circuit_gate_single()
                    pass

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


                self.state = 335
                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, 42, self.RULE_circuit_gate_single)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 347
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [58]:
                self.state = 336
                self.match(QrogueDungeonParser.GATE_SPECIFIER)
                pass
            elif token in [4]:
                self.state = 337
                self.match(QrogueDungeonParser.T__3)
                self.state = 338
                self.match(QrogueDungeonParser.GATE_SPECIFIER)
                self.state = 343
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==66:
                    self.state = 339
                    self.match(QrogueDungeonParser.LIST_SEPARATOR)
                    self.state = 340
                    self.match(QrogueDungeonParser.GATE_SPECIFIER)
                    self.state = 345
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 346
                self.match(QrogueDungeonParser.T__4)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 349
            self.match(QrogueDungeonParser.T__17)
            self.state = 350
            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, 44, self.RULE_circuit_gate_multi)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 352
            self.match(QrogueDungeonParser.GATE_SPECIFIER)
            self.state = 353
            self.match(QrogueDungeonParser.T__17)
            self.state = 354
            self.match(QrogueDungeonParser.T__3)
            self.state = 355
            self.match(QrogueDungeonParser.QUBIT_SPECIFIER)
            self.state = 356
            self.match(QrogueDungeonParser.LIST_SEPARATOR)
            self.state = 358 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 357
                self.match(QrogueDungeonParser.QUBIT_SPECIFIER)
                self.state = 360 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==57):
                    break

            self.state = 362
            self.match(QrogueDungeonParser.T__4)
        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, 46, self.RULE_draw_strategy)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 364
            _la = self._input.LA(1)
            if not(_la==54 or _la==55):
                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, 48, self.RULE_stv_pools)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 366
            self.match(QrogueDungeonParser.STV_POOLS)
            self.state = 373
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==19:
                self.state = 367
                self.match(QrogueDungeonParser.T__18)
                self.state = 369 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 368
                    self.stv_pool()
                    self.state = 371 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==81):
                        break



            self.state = 375
            self.match(QrogueDungeonParser.T__19)
            self.state = 376
            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, 50, self.RULE_default_stv_pool)
        self._la = 0 # Token type
        try:
            self.state = 383
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [81]:
                self.enterOuterAlt(localctx, 1)
                self.state = 378
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [4, 54, 55]:
                self.enterOuterAlt(localctx, 2)
                self.state = 380
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==54 or _la==55:
                    self.state = 379
                    self.draw_strategy()


                self.state = 382
                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, 52, self.RULE_stv_pool)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 385
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 387
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==54 or _la==55:
                self.state = 386
                self.draw_strategy()


            self.state = 389
            self.stvs()
            self.state = 394
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
            if la_ == 1:
                self.state = 390
                self.match(QrogueDungeonParser.T__19)
                self.state = 391
                self.match(QrogueDungeonParser.T__20)
                self.state = 392
                self.match(QrogueDungeonParser.T__16)
                self.state = 393
                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, 54, self.RULE_stvs)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 396
            self.match(QrogueDungeonParser.T__3)
            self.state = 397
            self.stv_ref()
            self.state = 402
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==66:
                self.state = 398
                self.match(QrogueDungeonParser.LIST_SEPARATOR)
                self.state = 399
                self.stv_ref()
                self.state = 404
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 405
            self.match(QrogueDungeonParser.T__4)
        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, 56, self.RULE_stv_ref)
        try:
            self.state = 409
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4, 22]:
                self.enterOuterAlt(localctx, 1)
                self.state = 407
                self.stv()
                pass
            elif token in [81]:
                self.enterOuterAlt(localctx, 2)
                self.state = 408
                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, 58, self.RULE_stv)
        self._la = 0 # Token type
        try:
            self.state = 426
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 411
                self.match(QrogueDungeonParser.T__3)
                self.state = 412
                self.complex_number()
                self.state = 417
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==66:
                    self.state = 413
                    self.match(QrogueDungeonParser.LIST_SEPARATOR)
                    self.state = 414
                    self.complex_number()
                    self.state = 419
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 420
                self.match(QrogueDungeonParser.T__4)
                pass
            elif token in [22]:
                self.enterOuterAlt(localctx, 2)
                self.state = 422
                self.match(QrogueDungeonParser.T__21)
                self.state = 423
                self.circuit_stv()
                self.state = 424
                self.match(QrogueDungeonParser.T__22)
                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, 60, self.RULE_reward_pools)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 428
            self.match(QrogueDungeonParser.REWARD_POOLS)
            self.state = 435
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==19:
                self.state = 429
                self.match(QrogueDungeonParser.T__18)
                self.state = 431 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 430
                    self.reward_pool()
                    self.state = 433 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==81):
                        break



            self.state = 437
            self.match(QrogueDungeonParser.T__19)
            self.state = 438
            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, 62, self.RULE_default_reward_pool)
        self._la = 0 # Token type
        try:
            self.state = 445
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [81]:
                self.enterOuterAlt(localctx, 1)
                self.state = 440
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [4, 54, 55]:
                self.enterOuterAlt(localctx, 2)
                self.state = 442
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==54 or _la==55:
                    self.state = 441
                    self.draw_strategy()


                self.state = 444
                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, 64, self.RULE_reward_pool)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 447
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 449
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==54 or _la==55:
                self.state = 448
                self.draw_strategy()


            self.state = 451
            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, 66, self.RULE_collectibles)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 453
            self.match(QrogueDungeonParser.T__3)
            self.state = 454
            self.collectible()
            self.state = 459
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==66:
                self.state = 455
                self.match(QrogueDungeonParser.LIST_SEPARATOR)
                self.state = 456
                self.collectible()
                self.state = 461
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 462
            self.match(QrogueDungeonParser.T__4)
        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 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, 68, self.RULE_collectible)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 473
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [41, 42, 43]:
                self.state = 464
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 15393162788864) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 465
                self.integer()
                pass
            elif token in [44]:
                self.state = 466
                self.match(QrogueDungeonParser.GATE_LITERAL)
                self.state = 467
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            elif token in [45]:
                self.state = 468
                self.match(QrogueDungeonParser.QUBIT_LITERAL)
                self.state = 470
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,60,self._ctx)
                if la_ == 1:
                    self.state = 469
                    self.integer()


                pass
            elif token in [46]:
                self.state = 472
                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, 70, self.RULE_integer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 475
            _la = self._input.LA(1)
            if not(((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 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, 72, self.RULE_complex_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 478
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==74:
                self.state = 477
                self.match(QrogueDungeonParser.SIGN)


            self.state = 489
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [73]:
                self.state = 480
                self.match(QrogueDungeonParser.IMAG_NUMBER)
                pass
            elif token in [70, 71, 72, 80]:
                self.state = 483
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [70, 71, 80]:
                    self.state = 481
                    self.integer()
                    pass
                elif token in [72]:
                    self.state = 482
                    self.match(QrogueDungeonParser.FLOAT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 487
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==74:
                    self.state = 485
                    self.match(QrogueDungeonParser.SIGN)
                    self.state = 486
                    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, 74, self.RULE_layout)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 491
            self.match(QrogueDungeonParser.LAYOUT)
            self.state = 495
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==64:
                self.state = 492
                self.match(QrogueDungeonParser.HORIZONTAL_SEPARATOR)
                self.state = 497
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 498
            self.l_room_row()
            self.state = 504
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==65:
                self.state = 499
                self.l_hallway_row()
                self.state = 500
                self.l_room_row()
                self.state = 506
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 510
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==64:
                self.state = 507
                self.match(QrogueDungeonParser.HORIZONTAL_SEPARATOR)
                self.state = 512
                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, 76, self.RULE_l_room_row)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 513
            self.match(QrogueDungeonParser.VERTICAL_SEPARATOR)
            self.state = 514
            _la = self._input.LA(1)
            if not(_la==69 or _la==79):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 519
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==68 or _la==80:
                self.state = 515
                _la = self._input.LA(1)
                if not(_la==68 or _la==80):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 516
                _la = self._input.LA(1)
                if not(_la==69 or _la==79):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 521
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 522
            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, 78, self.RULE_l_hallway_row)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 524
            self.match(QrogueDungeonParser.VERTICAL_SEPARATOR)
            self.state = 526 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 525
                _la = self._input.LA(1)
                if not(_la==68 or _la==80):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 528 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==68 or _la==80):
                    break

            self.state = 530
            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, 80, self.RULE_rooms)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 532
            self.match(QrogueDungeonParser.ROOMS)
            self.state = 536
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==79:
                self.state = 533
                self.room()
                self.state = 538
                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, 82, self.RULE_room)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 539
            self.match(QrogueDungeonParser.ROOM_ID)
            self.state = 540
            self.r_attributes()
            self.state = 541
            self.match(QrogueDungeonParser.T__16)
            self.state = 542
            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, 84, self.RULE_r_attributes)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 544
            self.match(QrogueDungeonParser.T__23)
            self.state = 545
            self.r_visibility()
            self.state = 546
            self.r_type()
            self.state = 547
            self.match(QrogueDungeonParser.T__24)
        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, 86, self.RULE_r_visibility)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 550
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==89 or _la==90:
                self.state = 549
                _la = self._input.LA(1)
                if not(_la==89 or _la==90):
                    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 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, 88, self.RULE_r_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 552
            _la = self._input.LA(1)
            if not(((((_la - 93)) & ~0x3f) == 0 and ((1 << (_la - 93)) & 511) != 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, 90, self.RULE_hallways)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 554
            self.match(QrogueDungeonParser.HALLWAYS)
            self.state = 558
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==80:
                self.state = 555
                self.hallway()
                self.state = 560
                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, 92, self.RULE_hallway)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 561
            self.match(QrogueDungeonParser.HALLWAY_ID)
            self.state = 562
            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, 94, self.RULE_h_attributes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 564
            self.match(QrogueDungeonParser.T__23)
            self.state = 570
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [102]:
                self.state = 565
                self.match(QrogueDungeonParser.OPEN_LITERAL)
                pass
            elif token in [103]:
                self.state = 566
                self.match(QrogueDungeonParser.CLOSED_LITERAL)
                pass
            elif token in [104]:
                self.state = 567
                self.match(QrogueDungeonParser.LOCKED_LITERAL)
                pass
            elif token in [105]:
                self.state = 568
                self.match(QrogueDungeonParser.EVENT_LITERAL)
                self.state = 569
                self.match(QrogueDungeonParser.REFERENCE)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 577
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==26:
                self.state = 572
                self.match(QrogueDungeonParser.T__25)
                self.state = 573
                self.match(QrogueDungeonParser.DIRECTION)
                self.state = 575
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==106:
                    self.state = 574
                    self.match(QrogueDungeonParser.PERMANENT_LITERAL)




            self.state = 590
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==107:
                self.state = 579
                self.match(QrogueDungeonParser.ENTANGLED_LITERAL)
                self.state = 580
                self.match(QrogueDungeonParser.T__3)
                self.state = 581
                self.match(QrogueDungeonParser.HALLWAY_ID)
                self.state = 586
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==66:
                    self.state = 582
                    self.match(QrogueDungeonParser.LIST_SEPARATOR)
                    self.state = 583
                    self.match(QrogueDungeonParser.HALLWAY_ID)
                    self.state = 588
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 589
                self.match(QrogueDungeonParser.T__4)


            self.state = 592
            self.match(QrogueDungeonParser.T__24)
            self.state = 595
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==60:
                self.state = 593
                self.match(QrogueDungeonParser.TUTORIAL_LITERAL)
                self.state = 594
                self.match(QrogueDungeonParser.REFERENCE)


            self.state = 599
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==61:
                self.state = 597
                self.match(QrogueDungeonParser.TRIGGER_LITERAL)
                self.state = 598
                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, 96, self.RULE_messages)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 601
            self.match(QrogueDungeonParser.MESSAGES)
            self.state = 605
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==20:
                self.state = 602
                self.match(QrogueDungeonParser.T__19)
                self.state = 603
                self.match(QrogueDungeonParser.MSG_SPEAKER)
                self.state = 604
                self.match(QrogueDungeonParser.TEXT)


            self.state = 610
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==81:
                self.state = 607
                self.message()
                self.state = 612
                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, 98, self.RULE_message)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 613
            self.match(QrogueDungeonParser.REFERENCE)
            self.state = 614
            self.message_body()
            self.state = 619
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==109:
                self.state = 615
                self.match(QrogueDungeonParser.MSG_EVENT)
                self.state = 616
                self.match(QrogueDungeonParser.REFERENCE)
                self.state = 617
                self.match(QrogueDungeonParser.MSG_ALTERNATIVE)
                self.state = 618
                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, 100, self.RULE_message_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 623
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==111:
                self.state = 621
                self.match(QrogueDungeonParser.MSG_SPEAKER)
                self.state = 622
                self.match(QrogueDungeonParser.TEXT)


            self.state = 626
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==112:
                self.state = 625
                self.match(QrogueDungeonParser.MSG_PRIORITY)


            self.state = 633
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==27:
                self.state = 628
                self.match(QrogueDungeonParser.T__26)
                self.state = 630
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==2:
                    self.state = 629
                    self.match(QrogueDungeonParser.T__1)


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


            self.state = 636 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 635
                self.match(QrogueDungeonParser.TEXT)
                self.state = 638 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==78):
                    break

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





