
import * as antlr from "antlr4ng";
import { Token } from "antlr4ng";

import { GremlinListener } from "./GremlinListener.js";
// for running tests with parameters, TODO: discuss strategy for typed parameters in CI
// eslint-disable-next-line no-unused-vars
type int = number;


export class GremlinParser extends antlr.Parser {
    public static readonly K_ADDALL = 1;
    public static readonly K_ADDE = 2;
    public static readonly K_ADDLABEL = 3;
    public static readonly K_ADDV = 4;
    public static readonly K_AGGREGATE = 5;
    public static readonly K_ALL = 6;
    public static readonly K_AND = 7;
    public static readonly K_ANY = 8;
    public static readonly K_AS = 9;
    public static readonly K_ASBOOL = 10;
    public static readonly K_ASC = 11;
    public static readonly K_ASDATE = 12;
    public static readonly K_ASNUMBER = 13;
    public static readonly K_ASSTRING = 14;
    public static readonly K_ASSIGN = 15;
    public static readonly K_BARRIER = 16;
    public static readonly K_BARRIERU = 17;
    public static readonly K_BEGIN = 18;
    public static readonly K_BETWEEN = 19;
    public static readonly K_BIGDECIMAL = 20;
    public static readonly K_BIGDECIMALU = 21;
    public static readonly K_BIGINT = 22;
    public static readonly K_BIGINTU = 23;
    public static readonly K_BINARY = 24;
    public static readonly K_BINARYC = 25;
    public static readonly K_BINARYU = 26;
    public static readonly K_BOOLEAN = 27;
    public static readonly K_BOOLEANU = 28;
    public static readonly K_BOTH = 29;
    public static readonly K_BOTHU = 30;
    public static readonly K_BOTHE = 31;
    public static readonly K_BOTHV = 32;
    public static readonly K_BRANCH = 33;
    public static readonly K_BY = 34;
    public static readonly K_BYTE = 35;
    public static readonly K_BYTEU = 36;
    public static readonly K_CALL = 37;
    public static readonly K_CAP = 38;
    public static readonly K_CARDINALITY = 39;
    public static readonly K_CHAR = 40;
    public static readonly K_CHARU = 41;
    public static readonly K_CHOOSE = 42;
    public static readonly K_COALESCE = 43;
    public static readonly K_COIN = 44;
    public static readonly K_COLUMN = 45;
    public static readonly K_COMBINE = 46;
    public static readonly K_COMMIT = 47;
    public static readonly K_COMPONENT = 48;
    public static readonly K_CONCAT = 49;
    public static readonly K_CONJOIN = 50;
    public static readonly K_CONNECTEDCOMPONENT = 51;
    public static readonly K_CONNECTEDCOMPONENTU = 52;
    public static readonly K_CONSTANT = 53;
    public static readonly K_CONTAINING = 54;
    public static readonly K_COUNT = 55;
    public static readonly K_CYCLICPATH = 56;
    public static readonly K_DAY = 57;
    public static readonly K_DATEADD = 58;
    public static readonly K_DATEDIFF = 59;
    public static readonly K_DATETIME = 60;
    public static readonly K_DATETIMEC = 61;
    public static readonly K_DATETIMEU = 62;
    public static readonly K_DECR = 63;
    public static readonly K_DEDUP = 64;
    public static readonly K_DESC = 65;
    public static readonly K_DIFFERENCE = 66;
    public static readonly K_DISCARD = 67;
    public static readonly K_DIRECTION = 68;
    public static readonly K_DISJUNCT = 69;
    public static readonly K_DISTANCE = 70;
    public static readonly K_DIV = 71;
    public static readonly K_DOUBLE = 72;
    public static readonly K_DOUBLEU = 73;
    public static readonly K_DROP = 74;
    public static readonly K_DROPLABEL = 75;
    public static readonly K_DROPLABELS = 76;
    public static readonly K_DT = 77;
    public static readonly K_DURATION = 78;
    public static readonly K_DURATIONC = 79;
    public static readonly K_DURATIONU = 80;
    public static readonly K_E = 81;
    public static readonly K_EDGE = 82;
    public static readonly K_EDGEU = 83;
    public static readonly K_EDGES = 84;
    public static readonly K_ELEMENTMAP = 85;
    public static readonly K_ELEMENT = 86;
    public static readonly K_EMIT = 87;
    public static readonly K_ENDINGWITH = 88;
    public static readonly K_EQ = 89;
    public static readonly K_EXPLAIN = 90;
    public static readonly K_FAIL = 91;
    public static readonly K_FALSE = 92;
    public static readonly K_FILTER = 93;
    public static readonly K_FIRST = 94;
    public static readonly K_FLATMAP = 95;
    public static readonly K_FLOAT = 96;
    public static readonly K_FLOATU = 97;
    public static readonly K_FOLD = 98;
    public static readonly K_FORMAT = 99;
    public static readonly K_FROM = 100;
    public static readonly K_GLOBAL = 101;
    public static readonly K_GT = 102;
    public static readonly K_GTE = 103;
    public static readonly K_GTYPE = 104;
    public static readonly K_GRAPHML = 105;
    public static readonly K_GRAPHSON = 106;
    public static readonly K_GROUPCOUNT = 107;
    public static readonly K_GROUP = 108;
    public static readonly K_GRYO = 109;
    public static readonly K_GRAPH = 110;
    public static readonly K_GRAPHU = 111;
    public static readonly K_HAS = 112;
    public static readonly K_HASID = 113;
    public static readonly K_HASKEY = 114;
    public static readonly K_HASLABEL = 115;
    public static readonly K_HASNEXT = 116;
    public static readonly K_HASNOT = 117;
    public static readonly K_HASVALUE = 118;
    public static readonly K_HOUR = 119;
    public static readonly K_ID = 120;
    public static readonly K_IDENTITY = 121;
    public static readonly K_IDS = 122;
    public static readonly K_IN = 123;
    public static readonly K_INU = 124;
    public static readonly K_INE = 125;
    public static readonly K_INCLUDEEDGES = 126;
    public static readonly K_INCR = 127;
    public static readonly K_INDEXER = 128;
    public static readonly K_INDEX = 129;
    public static readonly K_INFINITY = 130;
    public static readonly K_INJECT = 131;
    public static readonly K_INSIDE = 132;
    public static readonly K_INT = 133;
    public static readonly K_INTU = 134;
    public static readonly K_INTERSECT = 135;
    public static readonly K_INV = 136;
    public static readonly K_IOU = 137;
    public static readonly K_IO = 138;
    public static readonly K_IS = 139;
    public static readonly K_ITERATE = 140;
    public static readonly K_KEY = 141;
    public static readonly K_KEYS = 142;
    public static readonly K_LABELS = 143;
    public static readonly K_LABEL = 144;
    public static readonly K_LAST = 145;
    public static readonly K_LENGTH = 146;
    public static readonly K_LIMIT = 147;
    public static readonly K_LIST = 148;
    public static readonly K_LISTU = 149;
    public static readonly K_LOCAL = 150;
    public static readonly K_LONG = 151;
    public static readonly K_LONGU = 152;
    public static readonly K_LOOPS = 153;
    public static readonly K_LT = 154;
    public static readonly K_LTE = 155;
    public static readonly K_LTRIM = 156;
    public static readonly K_MAP = 157;
    public static readonly K_MAPU = 158;
    public static readonly K_MATCH = 159;
    public static readonly K_MATH = 160;
    public static readonly K_MAX = 161;
    public static readonly K_MAXDISTANCE = 162;
    public static readonly K_MEAN = 163;
    public static readonly K_MERGEU = 164;
    public static readonly K_MERGE = 165;
    public static readonly K_MERGEE = 166;
    public static readonly K_MERGEV = 167;
    public static readonly K_MIN = 168;
    public static readonly K_MINUTE = 169;
    public static readonly K_MINUS = 170;
    public static readonly K_MIXED = 171;
    public static readonly K_MULT = 172;
    public static readonly K_N = 173;
    public static readonly K_NAN = 174;
    public static readonly K_NEGATE = 175;
    public static readonly K_NEXT = 176;
    public static readonly K_NONE = 177;
    public static readonly K_NOTREGEX = 178;
    public static readonly K_NOTCONTAINING = 179;
    public static readonly K_NOTENDINGWITH = 180;
    public static readonly K_NOTSTARTINGWITH = 181;
    public static readonly K_NOT = 182;
    public static readonly K_NEQ = 183;
    public static readonly K_NEW = 184;
    public static readonly K_NORMSACK = 185;
    public static readonly K_NULL = 186;
    public static readonly K_NULLU = 187;
    public static readonly K_NUMBER = 188;
    public static readonly K_NUMBERU = 189;
    public static readonly K_ONCREATE = 190;
    public static readonly K_ONMATCH = 191;
    public static readonly K_OPERATOR = 192;
    public static readonly K_OPTION = 193;
    public static readonly K_OPTIONAL = 194;
    public static readonly K_ORDERU = 195;
    public static readonly K_ORDER = 196;
    public static readonly K_OR = 197;
    public static readonly K_OTHERV = 198;
    public static readonly K_OUTU = 199;
    public static readonly K_OUT = 200;
    public static readonly K_OUTE = 201;
    public static readonly K_OUTSIDE = 202;
    public static readonly K_OUTV = 203;
    public static readonly K_P = 204;
    public static readonly K_PAGERANKU = 205;
    public static readonly K_PAGERANK = 206;
    public static readonly K_PATH = 207;
    public static readonly K_PATHU = 208;
    public static readonly K_PDT = 209;
    public static readonly K_PEERPRESSUREU = 210;
    public static readonly K_PEERPRESSURE = 211;
    public static readonly K_PICK = 212;
    public static readonly K_POP = 213;
    public static readonly K_PROFILE = 214;
    public static readonly K_PROJECT = 215;
    public static readonly K_PROPERTIES = 216;
    public static readonly K_PROPERTYMAP = 217;
    public static readonly K_PROPERTYNAME = 218;
    public static readonly K_PROPERTY = 219;
    public static readonly K_PROPERTYU = 220;
    public static readonly K_PRODUCT = 221;
    public static readonly K_RANGE = 222;
    public static readonly K_READ = 223;
    public static readonly K_READER = 224;
    public static readonly K_REGEX = 225;
    public static readonly K_REPLACE = 226;
    public static readonly K_REPEAT = 227;
    public static readonly K_REVERSE = 228;
    public static readonly K_ROLLBACK = 229;
    public static readonly K_RTRIM = 230;
    public static readonly K_SACK = 231;
    public static readonly K_SAMPLE = 232;
    public static readonly K_SCOPE = 233;
    public static readonly K_SECOND = 234;
    public static readonly K_SELECT = 235;
    public static readonly K_SET = 236;
    public static readonly K_SETU = 237;
    public static readonly K_SHORTESTPATHU = 238;
    public static readonly K_SHORTESTPATH = 239;
    public static readonly K_SHUFFLE = 240;
    public static readonly K_SHORT = 241;
    public static readonly K_SHORTU = 242;
    public static readonly K_SIDEEFFECT = 243;
    public static readonly K_SIMPLEPATH = 244;
    public static readonly K_SINGLE = 245;
    public static readonly K_SKIP = 246;
    public static readonly K_SPLIT = 247;
    public static readonly K_STARTINGWITH = 248;
    public static readonly K_STRING = 249;
    public static readonly K_STRINGU = 250;
    public static readonly K_SUBGRAPH = 251;
    public static readonly K_SUBSTRING = 252;
    public static readonly K_SUM = 253;
    public static readonly K_SUMLONG = 254;
    public static readonly K_T = 255;
    public static readonly K_TAIL = 256;
    public static readonly K_TARGET = 257;
    public static readonly K_TEXTP = 258;
    public static readonly K_TIMELIMIT = 259;
    public static readonly K_TIMES = 260;
    public static readonly K_TO = 261;
    public static readonly K_TOBULKSET = 262;
    public static readonly K_TOKENS = 263;
    public static readonly K_TOLIST = 264;
    public static readonly K_TOLOWER = 265;
    public static readonly K_TOSET = 266;
    public static readonly K_TOSTRING = 267;
    public static readonly K_TOUPPER = 268;
    public static readonly K_TOE = 269;
    public static readonly K_TOV = 270;
    public static readonly K_TREE = 271;
    public static readonly K_TREEU = 272;
    public static readonly K_TRIM = 273;
    public static readonly K_TRUE = 274;
    public static readonly K_TRYNEXT = 275;
    public static readonly K_TYPEOF = 276;
    public static readonly K_TX = 277;
    public static readonly K_UNFOLD = 278;
    public static readonly K_UNION = 279;
    public static readonly K_UNPRODUCTIVE = 280;
    public static readonly K_UNTIL = 281;
    public static readonly K_UUID = 282;
    public static readonly K_UUIDL = 283;
    public static readonly K_V = 284;
    public static readonly K_VALUEMAP = 285;
    public static readonly K_VALUES = 286;
    public static readonly K_VALUE = 287;
    public static readonly K_VERTEX = 288;
    public static readonly K_VERTEXU = 289;
    public static readonly K_VPROPERTY = 290;
    public static readonly K_VPROPERTYU = 291;
    public static readonly K_WHERE = 292;
    public static readonly K_WITH = 293;
    public static readonly K_WITHBULK = 294;
    public static readonly K_WITHIN = 295;
    public static readonly K_WITHOPTOPTIONS = 296;
    public static readonly K_WITHOUT = 297;
    public static readonly K_WITHOUTSTRATEGIES = 298;
    public static readonly K_WITHPATH = 299;
    public static readonly K_WITHSACK = 300;
    public static readonly K_WITHSIDEEFFECT = 301;
    public static readonly K_WITHSTRATEGIES = 302;
    public static readonly K_WRITE = 303;
    public static readonly K_WRITER = 304;
    public static readonly IntegerLiteral = 305;
    public static readonly FloatingPointLiteral = 306;
    public static readonly SignedInfLiteral = 307;
    public static readonly CharacterLiteral = 308;
    public static readonly StringSuffixLiteral = 309;
    public static readonly EmptyStringSuffixLiteral = 310;
    public static readonly NonEmptyStringLiteral = 311;
    public static readonly EmptyStringLiteral = 312;
    public static readonly LPAREN = 313;
    public static readonly RPAREN = 314;
    public static readonly LBRACE = 315;
    public static readonly RBRACE = 316;
    public static readonly LBRACK = 317;
    public static readonly RBRACK = 318;
    public static readonly SEMI = 319;
    public static readonly COMMA = 320;
    public static readonly DOT = 321;
    public static readonly COLON = 322;
    public static readonly TRAVERSAL_ROOT = 323;
    public static readonly ANON_TRAVERSAL_ROOT = 324;
    public static readonly WS = 325;
    public static readonly LINE_COMMENT = 326;
    public static readonly Identifier = 327;
    public static readonly RULE_queryList = 0;
    public static readonly RULE_query = 1;
    public static readonly RULE_emptyQuery = 2;
    public static readonly RULE_traversalSource = 3;
    public static readonly RULE_transactionPart = 4;
    public static readonly RULE_rootTraversal = 5;
    public static readonly RULE_traversalSourceSelfMethod = 6;
    public static readonly RULE_traversalSourceSelfMethod_withBulk = 7;
    public static readonly RULE_traversalSourceSelfMethod_withPath = 8;
    public static readonly RULE_traversalSourceSelfMethod_withSack = 9;
    public static readonly RULE_traversalSourceSelfMethod_withSideEffect = 10;
    public static readonly RULE_traversalSourceSelfMethod_withStrategies = 11;
    public static readonly RULE_traversalSourceSelfMethod_withoutStrategies = 12;
    public static readonly RULE_traversalSourceSelfMethod_with = 13;
    public static readonly RULE_traversalSourceSpawnMethod = 14;
    public static readonly RULE_traversalSourceSpawnMethod_addE = 15;
    public static readonly RULE_traversalSourceSpawnMethod_addV = 16;
    public static readonly RULE_traversalSourceSpawnMethod_E = 17;
    public static readonly RULE_traversalSourceSpawnMethod_V = 18;
    public static readonly RULE_traversalSourceSpawnMethod_inject = 19;
    public static readonly RULE_traversalSourceSpawnMethod_io = 20;
    public static readonly RULE_traversalSourceSpawnMethod_mergeV = 21;
    public static readonly RULE_traversalSourceSpawnMethod_mergeE = 22;
    public static readonly RULE_traversalSourceSpawnMethod_call = 23;
    public static readonly RULE_traversalSourceSpawnMethod_union = 24;
    public static readonly RULE_traversalSourceSpawnMethod_match = 25;
    public static readonly RULE_chainedTraversal = 26;
    public static readonly RULE_nestedTraversal = 27;
    public static readonly RULE_terminatedTraversal = 28;
    public static readonly RULE_traversalMethod = 29;
    public static readonly RULE_traversalMethod_V = 30;
    public static readonly RULE_traversalMethod_E = 31;
    public static readonly RULE_traversalMethod_addE = 32;
    public static readonly RULE_traversalMethod_addV = 33;
    public static readonly RULE_traversalMethod_aggregate = 34;
    public static readonly RULE_traversalMethod_all = 35;
    public static readonly RULE_traversalMethod_and = 36;
    public static readonly RULE_traversalMethod_any = 37;
    public static readonly RULE_traversalMethod_as = 38;
    public static readonly RULE_traversalMethod_asBool = 39;
    public static readonly RULE_traversalMethod_asDate = 40;
    public static readonly RULE_traversalMethod_asNumber = 41;
    public static readonly RULE_traversalMethod_asString = 42;
    public static readonly RULE_traversalMethod_barrier = 43;
    public static readonly RULE_traversalMethod_both = 44;
    public static readonly RULE_traversalMethod_bothE = 45;
    public static readonly RULE_traversalMethod_bothV = 46;
    public static readonly RULE_traversalMethod_branch = 47;
    public static readonly RULE_traversalMethod_by = 48;
    public static readonly RULE_traversalMethod_call = 49;
    public static readonly RULE_traversalMethod_cap = 50;
    public static readonly RULE_traversalMethod_choose = 51;
    public static readonly RULE_traversalMethod_coalesce = 52;
    public static readonly RULE_traversalMethod_coin = 53;
    public static readonly RULE_traversalMethod_combine = 54;
    public static readonly RULE_traversalMethod_concat = 55;
    public static readonly RULE_traversalMethod_conjoin = 56;
    public static readonly RULE_traversalMethod_connectedComponent = 57;
    public static readonly RULE_traversalMethod_constant = 58;
    public static readonly RULE_traversalMethod_count = 59;
    public static readonly RULE_traversalMethod_cyclicPath = 60;
    public static readonly RULE_traversalMethod_dateAdd = 61;
    public static readonly RULE_traversalMethod_dateDiff = 62;
    public static readonly RULE_traversalMethod_dedup = 63;
    public static readonly RULE_traversalMethod_difference = 64;
    public static readonly RULE_traversalMethod_discard = 65;
    public static readonly RULE_traversalMethod_disjunct = 66;
    public static readonly RULE_traversalMethod_drop = 67;
    public static readonly RULE_traversalMethod_element = 68;
    public static readonly RULE_traversalMethod_elementMap = 69;
    public static readonly RULE_traversalMethod_emit = 70;
    public static readonly RULE_traversalMethod_fail = 71;
    public static readonly RULE_traversalMethod_filter = 72;
    public static readonly RULE_traversalMethod_flatMap = 73;
    public static readonly RULE_traversalMethod_fold = 74;
    public static readonly RULE_traversalMethod_format = 75;
    public static readonly RULE_traversalMethod_from = 76;
    public static readonly RULE_traversalMethod_group = 77;
    public static readonly RULE_traversalMethod_groupCount = 78;
    public static readonly RULE_traversalMethod_has = 79;
    public static readonly RULE_traversalMethod_hasId = 80;
    public static readonly RULE_traversalMethod_hasKey = 81;
    public static readonly RULE_traversalMethod_hasLabel = 82;
    public static readonly RULE_traversalMethod_hasNot = 83;
    public static readonly RULE_traversalMethod_hasValue = 84;
    public static readonly RULE_traversalMethod_id = 85;
    public static readonly RULE_traversalMethod_identity = 86;
    public static readonly RULE_traversalMethod_in = 87;
    public static readonly RULE_traversalMethod_inE = 88;
    public static readonly RULE_traversalMethod_intersect = 89;
    public static readonly RULE_traversalMethod_inV = 90;
    public static readonly RULE_traversalMethod_index = 91;
    public static readonly RULE_traversalMethod_inject = 92;
    public static readonly RULE_traversalMethod_is = 93;
    public static readonly RULE_traversalMethod_key = 94;
    public static readonly RULE_traversalMethod_label = 95;
    public static readonly RULE_traversalMethod_labels = 96;
    public static readonly RULE_traversalMethod_addLabel = 97;
    public static readonly RULE_traversalMethod_dropLabels = 98;
    public static readonly RULE_traversalMethod_dropLabel = 99;
    public static readonly RULE_traversalMethod_length = 100;
    public static readonly RULE_traversalMethod_limit = 101;
    public static readonly RULE_traversalMethod_local = 102;
    public static readonly RULE_traversalMethod_loops = 103;
    public static readonly RULE_traversalMethod_lTrim = 104;
    public static readonly RULE_traversalMethod_map = 105;
    public static readonly RULE_traversalMethod_match = 106;
    public static readonly RULE_traversalMethod_math = 107;
    public static readonly RULE_traversalMethod_max = 108;
    public static readonly RULE_traversalMethod_mean = 109;
    public static readonly RULE_traversalMethod_merge = 110;
    public static readonly RULE_traversalMethod_mergeV = 111;
    public static readonly RULE_traversalMethod_mergeE = 112;
    public static readonly RULE_traversalMethod_min = 113;
    public static readonly RULE_traversalMethod_none = 114;
    public static readonly RULE_traversalMethod_not = 115;
    public static readonly RULE_traversalMethod_option = 116;
    public static readonly RULE_traversalMethod_optional = 117;
    public static readonly RULE_traversalMethod_or = 118;
    public static readonly RULE_traversalMethod_order = 119;
    public static readonly RULE_traversalMethod_otherV = 120;
    public static readonly RULE_traversalMethod_out = 121;
    public static readonly RULE_traversalMethod_outE = 122;
    public static readonly RULE_traversalMethod_outV = 123;
    public static readonly RULE_traversalMethod_pageRank = 124;
    public static readonly RULE_traversalMethod_path = 125;
    public static readonly RULE_traversalMethod_peerPressure = 126;
    public static readonly RULE_traversalMethod_product = 127;
    public static readonly RULE_traversalMethod_profile = 128;
    public static readonly RULE_traversalMethod_project = 129;
    public static readonly RULE_traversalMethod_properties = 130;
    public static readonly RULE_traversalMethod_property = 131;
    public static readonly RULE_traversalMethod_propertyMap = 132;
    public static readonly RULE_traversalMethod_range = 133;
    public static readonly RULE_traversalMethod_read = 134;
    public static readonly RULE_traversalMethod_repeat = 135;
    public static readonly RULE_traversalMethod_replace = 136;
    public static readonly RULE_traversalMethod_reverse = 137;
    public static readonly RULE_traversalMethod_rTrim = 138;
    public static readonly RULE_traversalMethod_sack = 139;
    public static readonly RULE_traversalMethod_sample = 140;
    public static readonly RULE_traversalMethod_select = 141;
    public static readonly RULE_traversalMethod_shortestPath = 142;
    public static readonly RULE_traversalMethod_sideEffect = 143;
    public static readonly RULE_traversalMethod_simplePath = 144;
    public static readonly RULE_traversalMethod_skip = 145;
    public static readonly RULE_traversalMethod_split = 146;
    public static readonly RULE_traversalMethod_subgraph = 147;
    public static readonly RULE_traversalMethod_substring = 148;
    public static readonly RULE_traversalMethod_sum = 149;
    public static readonly RULE_traversalMethod_tail = 150;
    public static readonly RULE_traversalMethod_timeLimit = 151;
    public static readonly RULE_traversalMethod_times = 152;
    public static readonly RULE_traversalMethod_to = 153;
    public static readonly RULE_traversalMethod_toE = 154;
    public static readonly RULE_traversalMethod_toLower = 155;
    public static readonly RULE_traversalMethod_toUpper = 156;
    public static readonly RULE_traversalMethod_toV = 157;
    public static readonly RULE_traversalMethod_tree = 158;
    public static readonly RULE_traversalMethod_trim = 159;
    public static readonly RULE_traversalMethod_unfold = 160;
    public static readonly RULE_traversalMethod_union = 161;
    public static readonly RULE_traversalMethod_until = 162;
    public static readonly RULE_traversalMethod_value = 163;
    public static readonly RULE_traversalMethod_valueMap = 164;
    public static readonly RULE_traversalMethod_values = 165;
    public static readonly RULE_traversalMethod_where = 166;
    public static readonly RULE_traversalMethod_with = 167;
    public static readonly RULE_traversalMethod_write = 168;
    public static readonly RULE_traversalStrategy = 169;
    public static readonly RULE_configuration = 170;
    public static readonly RULE_traversalScope = 171;
    public static readonly RULE_traversalBarrier = 172;
    public static readonly RULE_traversalT = 173;
    public static readonly RULE_traversalTShort = 174;
    public static readonly RULE_traversalTLong = 175;
    public static readonly RULE_traversalMerge = 176;
    public static readonly RULE_traversalOrder = 177;
    public static readonly RULE_traversalDirection = 178;
    public static readonly RULE_traversalDirectionShort = 179;
    public static readonly RULE_traversalDirectionLong = 180;
    public static readonly RULE_traversalCardinality = 181;
    public static readonly RULE_traversalColumn = 182;
    public static readonly RULE_traversalPop = 183;
    public static readonly RULE_traversalOperator = 184;
    public static readonly RULE_traversalPick = 185;
    public static readonly RULE_traversalDT = 186;
    public static readonly RULE_traversalGType = 187;
    public static readonly RULE_traversalPredicate = 188;
    public static readonly RULE_traversalTerminalMethod = 189;
    public static readonly RULE_traversalSackMethod = 190;
    public static readonly RULE_traversalComparator = 191;
    public static readonly RULE_traversalFunction = 192;
    public static readonly RULE_traversalBiFunction = 193;
    public static readonly RULE_traversalPredicate_eq = 194;
    public static readonly RULE_traversalPredicate_neq = 195;
    public static readonly RULE_traversalPredicate_typeOf = 196;
    public static readonly RULE_traversalPredicate_lt = 197;
    public static readonly RULE_traversalPredicate_lte = 198;
    public static readonly RULE_traversalPredicate_gt = 199;
    public static readonly RULE_traversalPredicate_gte = 200;
    public static readonly RULE_traversalPredicate_inside = 201;
    public static readonly RULE_traversalPredicate_outside = 202;
    public static readonly RULE_traversalPredicate_between = 203;
    public static readonly RULE_traversalPredicate_within = 204;
    public static readonly RULE_traversalPredicate_without = 205;
    public static readonly RULE_traversalPredicate_not = 206;
    public static readonly RULE_traversalPredicate_containing = 207;
    public static readonly RULE_traversalPredicate_notContaining = 208;
    public static readonly RULE_traversalPredicate_startingWith = 209;
    public static readonly RULE_traversalPredicate_notStartingWith = 210;
    public static readonly RULE_traversalPredicate_endingWith = 211;
    public static readonly RULE_traversalPredicate_notEndingWith = 212;
    public static readonly RULE_traversalPredicate_regex = 213;
    public static readonly RULE_traversalPredicate_notRegex = 214;
    public static readonly RULE_traversalTerminalMethod_explain = 215;
    public static readonly RULE_traversalTerminalMethod_hasNext = 216;
    public static readonly RULE_traversalTerminalMethod_iterate = 217;
    public static readonly RULE_traversalTerminalMethod_tryNext = 218;
    public static readonly RULE_traversalTerminalMethod_next = 219;
    public static readonly RULE_traversalTerminalMethod_toList = 220;
    public static readonly RULE_traversalTerminalMethod_toSet = 221;
    public static readonly RULE_traversalTerminalMethod_toBulkSet = 222;
    public static readonly RULE_withOptionKeys = 223;
    public static readonly RULE_connectedComponentConstants = 224;
    public static readonly RULE_pageRankConstants = 225;
    public static readonly RULE_peerPressureConstants = 226;
    public static readonly RULE_shortestPathConstants = 227;
    public static readonly RULE_withOptionsValues = 228;
    public static readonly RULE_ioOptionsKeys = 229;
    public static readonly RULE_ioOptionsValues = 230;
    public static readonly RULE_connectedComponentConstants_component = 231;
    public static readonly RULE_connectedComponentConstants_edges = 232;
    public static readonly RULE_connectedComponentConstants_propertyName = 233;
    public static readonly RULE_pageRankConstants_edges = 234;
    public static readonly RULE_pageRankConstants_times = 235;
    public static readonly RULE_pageRankConstants_propertyName = 236;
    public static readonly RULE_peerPressureConstants_edges = 237;
    public static readonly RULE_peerPressureConstants_times = 238;
    public static readonly RULE_peerPressureConstants_propertyName = 239;
    public static readonly RULE_shortestPathConstants_target = 240;
    public static readonly RULE_shortestPathConstants_edges = 241;
    public static readonly RULE_shortestPathConstants_distance = 242;
    public static readonly RULE_shortestPathConstants_maxDistance = 243;
    public static readonly RULE_shortestPathConstants_includeEdges = 244;
    public static readonly RULE_withOptionsConstants_tokens = 245;
    public static readonly RULE_withOptionsConstants_none = 246;
    public static readonly RULE_withOptionsConstants_ids = 247;
    public static readonly RULE_withOptionsConstants_labels = 248;
    public static readonly RULE_withOptionsConstants_keys = 249;
    public static readonly RULE_withOptionsConstants_values = 250;
    public static readonly RULE_withOptionsConstants_all = 251;
    public static readonly RULE_withOptionsConstants_indexer = 252;
    public static readonly RULE_withOptionsConstants_list = 253;
    public static readonly RULE_withOptionsConstants_map = 254;
    public static readonly RULE_ioOptionsConstants_reader = 255;
    public static readonly RULE_ioOptionsConstants_writer = 256;
    public static readonly RULE_ioOptionsConstants_gryo = 257;
    public static readonly RULE_ioOptionsConstants_graphson = 258;
    public static readonly RULE_ioOptionsConstants_graphml = 259;
    public static readonly RULE_connectedComponentStringConstant = 260;
    public static readonly RULE_pageRankStringConstant = 261;
    public static readonly RULE_peerPressureStringConstant = 262;
    public static readonly RULE_shortestPathStringConstant = 263;
    public static readonly RULE_withOptionsStringConstant = 264;
    public static readonly RULE_ioOptionsStringConstant = 265;
    public static readonly RULE_booleanArgument = 266;
    public static readonly RULE_integerArgument = 267;
    public static readonly RULE_stringArgument = 268;
    public static readonly RULE_stringArgumentVarargs = 269;
    public static readonly RULE_stringNullableArgument = 270;
    public static readonly RULE_stringNullableArgumentVarargs = 271;
    public static readonly RULE_dateArgument = 272;
    public static readonly RULE_genericArgument = 273;
    public static readonly RULE_genericArgumentVarargs = 274;
    public static readonly RULE_genericMapArgument = 275;
    public static readonly RULE_genericMapNullableArgument = 276;
    public static readonly RULE_nullableGenericLiteralMap = 277;
    public static readonly RULE_traversalStrategyVarargs = 278;
    public static readonly RULE_traversalStrategyExpr = 279;
    public static readonly RULE_classTypeList = 280;
    public static readonly RULE_classTypeExpr = 281;
    public static readonly RULE_nestedTraversalList = 282;
    public static readonly RULE_nestedTraversalExpr = 283;
    public static readonly RULE_genericCollectionLiteral = 284;
    public static readonly RULE_genericLiteralVarargs = 285;
    public static readonly RULE_genericLiteralExpr = 286;
    public static readonly RULE_genericMapNullableLiteral = 287;
    public static readonly RULE_genericRangeLiteral = 288;
    public static readonly RULE_genericSetLiteral = 289;
    public static readonly RULE_stringNullableLiteralVarargs = 290;
    public static readonly RULE_stringLiteralVarargs = 291;
    public static readonly RULE_genericLiteral = 292;
    public static readonly RULE_genericMapLiteral = 293;
    public static readonly RULE_mapKey = 294;
    public static readonly RULE_mapEntry = 295;
    public static readonly RULE_stringLiteral = 296;
    public static readonly RULE_stringNullableLiteral = 297;
    public static readonly RULE_integerLiteral = 298;
    public static readonly RULE_floatLiteral = 299;
    public static readonly RULE_numericLiteral = 300;
    public static readonly RULE_booleanLiteral = 301;
    public static readonly RULE_dateLiteral = 302;
    public static readonly RULE_nullLiteral = 303;
    public static readonly RULE_nanLiteral = 304;
    public static readonly RULE_infLiteral = 305;
    public static readonly RULE_uuidLiteral = 306;
    public static readonly RULE_characterLiteral = 307;
    public static readonly RULE_durationLiteral = 308;
    public static readonly RULE_binaryLiteral = 309;
    public static readonly RULE_pdtLiteral = 310;
    public static readonly RULE_nakedKey = 311;
    public static readonly RULE_classType = 312;
    public static readonly RULE_variable = 313;
    public static readonly RULE_keyword = 314;

    public static readonly literalNames = [
        null, "'addAll'", "'addE'", "'addLabel'", "'addV'", "'aggregate'", 
        "'all'", "'and'", "'any'", "'as'", "'asBool'", "'asc'", "'asDate'", 
        "'asNumber'", "'asString'", "'assign'", "'barrier'", "'Barrier'", 
        "'begin'", "'between'", "'bigDecimal'", "'BIGDECIMAL'", "'bigInt'", 
        "'BIGINT'", "'binary'", "'Binary'", "'BINARY'", "'boolean'", "'BOOLEAN'", 
        "'both'", "'BOTH'", "'bothE'", "'bothV'", "'branch'", "'by'", "'byte'", 
        "'BYTE'", "'call'", "'cap'", "'Cardinality'", "'char'", "'CHAR'", 
        "'choose'", "'coalesce'", "'coin'", "'Column'", "'combine'", "'commit'", 
        "'component'", "'concat'", "'conjoin'", "'connectedComponent'", 
        "'ConnectedComponent'", "'constant'", "'containing'", "'count'", 
        "'cyclicPath'", "'day'", "'dateAdd'", "'dateDiff'", "'datetime'", 
        "'DateTime'", "'DATETIME'", "'decr'", "'dedup'", "'desc'", "'difference'", 
        "'discard'", "'Direction'", "'disjunct'", "'distance'", "'div'", 
        "'double'", "'DOUBLE'", "'drop'", "'dropLabel'", "'dropLabels'", 
        "'DT'", "'duration'", "'Duration'", "'DURATION'", "'E'", "'edge'", 
        "'EDGE'", "'edges'", "'elementMap'", "'element'", "'emit'", "'endingWith'", 
        "'eq'", "'explain'", "'fail'", "'false'", "'filter'", "'first'", 
        "'flatMap'", "'float'", "'FLOAT'", "'fold'", "'format'", "'from'", 
        "'global'", "'gt'", "'gte'", "'GType'", "'graphml'", "'graphson'", 
        "'groupCount'", "'group'", "'gryo'", "'graph'", "'GRAPH'", "'has'", 
        "'hasId'", "'hasKey'", "'hasLabel'", "'hasNext'", "'hasNot'", "'hasValue'", 
        "'hour'", "'id'", "'identity'", "'ids'", "'in'", "'IN'", "'inE'", 
        "'includeEdges'", "'incr'", "'indexer'", "'index'", "'Infinity'", 
        "'inject'", "'inside'", "'int'", "'INT'", "'intersect'", "'inV'", 
        "'IO'", "'io'", "'is'", "'iterate'", "'key'", "'keys'", "'labels'", 
        "'label'", "'last'", "'length'", "'limit'", "'list'", "'LIST'", 
        "'local'", "'long'", "'LONG'", "'loops'", "'lt'", "'lte'", "'lTrim'", 
        "'map'", "'MAP'", "'match'", "'math'", "'max'", "'maxDistance'", 
        "'mean'", "'Merge'", "'merge'", "'mergeE'", "'mergeV'", "'min'", 
        "'minute'", "'minus'", "'mixed'", "'mult'", "'N'", "'NaN'", "'negate'", 
        "'next'", "'none'", "'notRegex'", "'notContaining'", "'notEndingWith'", 
        "'notStartingWith'", "'not'", "'neq'", "'new'", "'normSack'", "'null'", 
        "'NULL'", "'number'", "'NUMBER'", "'onCreate'", "'onMatch'", "'Operator'", 
        "'option'", "'optional'", "'Order'", "'order'", "'or'", "'otherV'", 
        "'OUT'", "'out'", "'outE'", "'outside'", "'outV'", "'P'", "'PageRank'", 
        "'pageRank'", "'path'", "'PATH'", "'PDT'", "'PeerPressure'", "'peerPressure'", 
        "'Pick'", "'Pop'", "'profile'", "'project'", "'properties'", "'propertyMap'", 
        "'propertyName'", "'property'", "'PROPERTY'", "'product'", "'range'", 
        "'read'", "'reader'", "'regex'", "'replace'", "'repeat'", "'reverse'", 
        "'rollback'", "'rTrim'", "'sack'", "'sample'", "'Scope'", "'second'", 
        "'select'", "'set'", "'SET'", "'ShortestPath'", "'shortestPath'", 
        "'shuffle'", "'short'", "'SHORT'", "'sideEffect'", "'simplePath'", 
        "'single'", "'skip'", "'split'", "'startingWith'", "'string'", "'STRING'", 
        "'subgraph'", "'substring'", "'sum'", "'sumLong'", "'T'", "'tail'", 
        "'target'", "'TextP'", "'timeLimit'", "'times'", "'to'", "'toBulkSet'", 
        "'tokens'", "'toList'", "'toLower'", "'toSet'", "'toString'", "'toUpper'", 
        "'toE'", "'toV'", "'tree'", "'TREE'", "'trim'", "'true'", "'tryNext'", 
        "'typeOf'", "'tx'", "'unfold'", "'union'", "'unproductive'", "'until'", 
        "'UUID'", "'uuid'", "'V'", "'valueMap'", "'values'", "'value'", 
        "'vertex'", "'VERTEX'", "'vproperty'", "'VPROPERTY'", "'where'", 
        "'with'", "'withBulk'", "'within'", "'WithOptions'", "'without'", 
        "'withoutStrategies'", "'withPath'", "'withSack'", "'withSideEffect'", 
        "'withStrategies'", "'write'", "'writer'", null, null, null, null, 
        null, null, null, null, "'('", "')'", "'{'", "'}'", "'['", "']'", 
        "';'", "','", "'.'", "':'", "'g'", "'__'"
    ];

    public static readonly symbolicNames = [
        null, "K_ADDALL", "K_ADDE", "K_ADDLABEL", "K_ADDV", "K_AGGREGATE", 
        "K_ALL", "K_AND", "K_ANY", "K_AS", "K_ASBOOL", "K_ASC", "K_ASDATE", 
        "K_ASNUMBER", "K_ASSTRING", "K_ASSIGN", "K_BARRIER", "K_BARRIERU", 
        "K_BEGIN", "K_BETWEEN", "K_BIGDECIMAL", "K_BIGDECIMALU", "K_BIGINT", 
        "K_BIGINTU", "K_BINARY", "K_BINARYC", "K_BINARYU", "K_BOOLEAN", 
        "K_BOOLEANU", "K_BOTH", "K_BOTHU", "K_BOTHE", "K_BOTHV", "K_BRANCH", 
        "K_BY", "K_BYTE", "K_BYTEU", "K_CALL", "K_CAP", "K_CARDINALITY", 
        "K_CHAR", "K_CHARU", "K_CHOOSE", "K_COALESCE", "K_COIN", "K_COLUMN", 
        "K_COMBINE", "K_COMMIT", "K_COMPONENT", "K_CONCAT", "K_CONJOIN", 
        "K_CONNECTEDCOMPONENT", "K_CONNECTEDCOMPONENTU", "K_CONSTANT", "K_CONTAINING", 
        "K_COUNT", "K_CYCLICPATH", "K_DAY", "K_DATEADD", "K_DATEDIFF", "K_DATETIME", 
        "K_DATETIMEC", "K_DATETIMEU", "K_DECR", "K_DEDUP", "K_DESC", "K_DIFFERENCE", 
        "K_DISCARD", "K_DIRECTION", "K_DISJUNCT", "K_DISTANCE", "K_DIV", 
        "K_DOUBLE", "K_DOUBLEU", "K_DROP", "K_DROPLABEL", "K_DROPLABELS", 
        "K_DT", "K_DURATION", "K_DURATIONC", "K_DURATIONU", "K_E", "K_EDGE", 
        "K_EDGEU", "K_EDGES", "K_ELEMENTMAP", "K_ELEMENT", "K_EMIT", "K_ENDINGWITH", 
        "K_EQ", "K_EXPLAIN", "K_FAIL", "K_FALSE", "K_FILTER", "K_FIRST", 
        "K_FLATMAP", "K_FLOAT", "K_FLOATU", "K_FOLD", "K_FORMAT", "K_FROM", 
        "K_GLOBAL", "K_GT", "K_GTE", "K_GTYPE", "K_GRAPHML", "K_GRAPHSON", 
        "K_GROUPCOUNT", "K_GROUP", "K_GRYO", "K_GRAPH", "K_GRAPHU", "K_HAS", 
        "K_HASID", "K_HASKEY", "K_HASLABEL", "K_HASNEXT", "K_HASNOT", "K_HASVALUE", 
        "K_HOUR", "K_ID", "K_IDENTITY", "K_IDS", "K_IN", "K_INU", "K_INE", 
        "K_INCLUDEEDGES", "K_INCR", "K_INDEXER", "K_INDEX", "K_INFINITY", 
        "K_INJECT", "K_INSIDE", "K_INT", "K_INTU", "K_INTERSECT", "K_INV", 
        "K_IOU", "K_IO", "K_IS", "K_ITERATE", "K_KEY", "K_KEYS", "K_LABELS", 
        "K_LABEL", "K_LAST", "K_LENGTH", "K_LIMIT", "K_LIST", "K_LISTU", 
        "K_LOCAL", "K_LONG", "K_LONGU", "K_LOOPS", "K_LT", "K_LTE", "K_LTRIM", 
        "K_MAP", "K_MAPU", "K_MATCH", "K_MATH", "K_MAX", "K_MAXDISTANCE", 
        "K_MEAN", "K_MERGEU", "K_MERGE", "K_MERGEE", "K_MERGEV", "K_MIN", 
        "K_MINUTE", "K_MINUS", "K_MIXED", "K_MULT", "K_N", "K_NAN", "K_NEGATE", 
        "K_NEXT", "K_NONE", "K_NOTREGEX", "K_NOTCONTAINING", "K_NOTENDINGWITH", 
        "K_NOTSTARTINGWITH", "K_NOT", "K_NEQ", "K_NEW", "K_NORMSACK", "K_NULL", 
        "K_NULLU", "K_NUMBER", "K_NUMBERU", "K_ONCREATE", "K_ONMATCH", "K_OPERATOR", 
        "K_OPTION", "K_OPTIONAL", "K_ORDERU", "K_ORDER", "K_OR", "K_OTHERV", 
        "K_OUTU", "K_OUT", "K_OUTE", "K_OUTSIDE", "K_OUTV", "K_P", "K_PAGERANKU", 
        "K_PAGERANK", "K_PATH", "K_PATHU", "K_PDT", "K_PEERPRESSUREU", "K_PEERPRESSURE", 
        "K_PICK", "K_POP", "K_PROFILE", "K_PROJECT", "K_PROPERTIES", "K_PROPERTYMAP", 
        "K_PROPERTYNAME", "K_PROPERTY", "K_PROPERTYU", "K_PRODUCT", "K_RANGE", 
        "K_READ", "K_READER", "K_REGEX", "K_REPLACE", "K_REPEAT", "K_REVERSE", 
        "K_ROLLBACK", "K_RTRIM", "K_SACK", "K_SAMPLE", "K_SCOPE", "K_SECOND", 
        "K_SELECT", "K_SET", "K_SETU", "K_SHORTESTPATHU", "K_SHORTESTPATH", 
        "K_SHUFFLE", "K_SHORT", "K_SHORTU", "K_SIDEEFFECT", "K_SIMPLEPATH", 
        "K_SINGLE", "K_SKIP", "K_SPLIT", "K_STARTINGWITH", "K_STRING", "K_STRINGU", 
        "K_SUBGRAPH", "K_SUBSTRING", "K_SUM", "K_SUMLONG", "K_T", "K_TAIL", 
        "K_TARGET", "K_TEXTP", "K_TIMELIMIT", "K_TIMES", "K_TO", "K_TOBULKSET", 
        "K_TOKENS", "K_TOLIST", "K_TOLOWER", "K_TOSET", "K_TOSTRING", "K_TOUPPER", 
        "K_TOE", "K_TOV", "K_TREE", "K_TREEU", "K_TRIM", "K_TRUE", "K_TRYNEXT", 
        "K_TYPEOF", "K_TX", "K_UNFOLD", "K_UNION", "K_UNPRODUCTIVE", "K_UNTIL", 
        "K_UUID", "K_UUIDL", "K_V", "K_VALUEMAP", "K_VALUES", "K_VALUE", 
        "K_VERTEX", "K_VERTEXU", "K_VPROPERTY", "K_VPROPERTYU", "K_WHERE", 
        "K_WITH", "K_WITHBULK", "K_WITHIN", "K_WITHOPTOPTIONS", "K_WITHOUT", 
        "K_WITHOUTSTRATEGIES", "K_WITHPATH", "K_WITHSACK", "K_WITHSIDEEFFECT", 
        "K_WITHSTRATEGIES", "K_WRITE", "K_WRITER", "IntegerLiteral", "FloatingPointLiteral", 
        "SignedInfLiteral", "CharacterLiteral", "StringSuffixLiteral", "EmptyStringSuffixLiteral", 
        "NonEmptyStringLiteral", "EmptyStringLiteral", "LPAREN", "RPAREN", 
        "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", "DOT", 
        "COLON", "TRAVERSAL_ROOT", "ANON_TRAVERSAL_ROOT", "WS", "LINE_COMMENT", 
        "Identifier"
    ];
    public static readonly ruleNames = [
        "queryList", "query", "emptyQuery", "traversalSource", "transactionPart", 
        "rootTraversal", "traversalSourceSelfMethod", "traversalSourceSelfMethod_withBulk", 
        "traversalSourceSelfMethod_withPath", "traversalSourceSelfMethod_withSack", 
        "traversalSourceSelfMethod_withSideEffect", "traversalSourceSelfMethod_withStrategies", 
        "traversalSourceSelfMethod_withoutStrategies", "traversalSourceSelfMethod_with", 
        "traversalSourceSpawnMethod", "traversalSourceSpawnMethod_addE", 
        "traversalSourceSpawnMethod_addV", "traversalSourceSpawnMethod_E", 
        "traversalSourceSpawnMethod_V", "traversalSourceSpawnMethod_inject", 
        "traversalSourceSpawnMethod_io", "traversalSourceSpawnMethod_mergeV", 
        "traversalSourceSpawnMethod_mergeE", "traversalSourceSpawnMethod_call", 
        "traversalSourceSpawnMethod_union", "traversalSourceSpawnMethod_match", 
        "chainedTraversal", "nestedTraversal", "terminatedTraversal", "traversalMethod", 
        "traversalMethod_V", "traversalMethod_E", "traversalMethod_addE", 
        "traversalMethod_addV", "traversalMethod_aggregate", "traversalMethod_all", 
        "traversalMethod_and", "traversalMethod_any", "traversalMethod_as", 
        "traversalMethod_asBool", "traversalMethod_asDate", "traversalMethod_asNumber", 
        "traversalMethod_asString", "traversalMethod_barrier", "traversalMethod_both", 
        "traversalMethod_bothE", "traversalMethod_bothV", "traversalMethod_branch", 
        "traversalMethod_by", "traversalMethod_call", "traversalMethod_cap", 
        "traversalMethod_choose", "traversalMethod_coalesce", "traversalMethod_coin", 
        "traversalMethod_combine", "traversalMethod_concat", "traversalMethod_conjoin", 
        "traversalMethod_connectedComponent", "traversalMethod_constant", 
        "traversalMethod_count", "traversalMethod_cyclicPath", "traversalMethod_dateAdd", 
        "traversalMethod_dateDiff", "traversalMethod_dedup", "traversalMethod_difference", 
        "traversalMethod_discard", "traversalMethod_disjunct", "traversalMethod_drop", 
        "traversalMethod_element", "traversalMethod_elementMap", "traversalMethod_emit", 
        "traversalMethod_fail", "traversalMethod_filter", "traversalMethod_flatMap", 
        "traversalMethod_fold", "traversalMethod_format", "traversalMethod_from", 
        "traversalMethod_group", "traversalMethod_groupCount", "traversalMethod_has", 
        "traversalMethod_hasId", "traversalMethod_hasKey", "traversalMethod_hasLabel", 
        "traversalMethod_hasNot", "traversalMethod_hasValue", "traversalMethod_id", 
        "traversalMethod_identity", "traversalMethod_in", "traversalMethod_inE", 
        "traversalMethod_intersect", "traversalMethod_inV", "traversalMethod_index", 
        "traversalMethod_inject", "traversalMethod_is", "traversalMethod_key", 
        "traversalMethod_label", "traversalMethod_labels", "traversalMethod_addLabel", 
        "traversalMethod_dropLabels", "traversalMethod_dropLabel", "traversalMethod_length", 
        "traversalMethod_limit", "traversalMethod_local", "traversalMethod_loops", 
        "traversalMethod_lTrim", "traversalMethod_map", "traversalMethod_match", 
        "traversalMethod_math", "traversalMethod_max", "traversalMethod_mean", 
        "traversalMethod_merge", "traversalMethod_mergeV", "traversalMethod_mergeE", 
        "traversalMethod_min", "traversalMethod_none", "traversalMethod_not", 
        "traversalMethod_option", "traversalMethod_optional", "traversalMethod_or", 
        "traversalMethod_order", "traversalMethod_otherV", "traversalMethod_out", 
        "traversalMethod_outE", "traversalMethod_outV", "traversalMethod_pageRank", 
        "traversalMethod_path", "traversalMethod_peerPressure", "traversalMethod_product", 
        "traversalMethod_profile", "traversalMethod_project", "traversalMethod_properties", 
        "traversalMethod_property", "traversalMethod_propertyMap", "traversalMethod_range", 
        "traversalMethod_read", "traversalMethod_repeat", "traversalMethod_replace", 
        "traversalMethod_reverse", "traversalMethod_rTrim", "traversalMethod_sack", 
        "traversalMethod_sample", "traversalMethod_select", "traversalMethod_shortestPath", 
        "traversalMethod_sideEffect", "traversalMethod_simplePath", "traversalMethod_skip", 
        "traversalMethod_split", "traversalMethod_subgraph", "traversalMethod_substring", 
        "traversalMethod_sum", "traversalMethod_tail", "traversalMethod_timeLimit", 
        "traversalMethod_times", "traversalMethod_to", "traversalMethod_toE", 
        "traversalMethod_toLower", "traversalMethod_toUpper", "traversalMethod_toV", 
        "traversalMethod_tree", "traversalMethod_trim", "traversalMethod_unfold", 
        "traversalMethod_union", "traversalMethod_until", "traversalMethod_value", 
        "traversalMethod_valueMap", "traversalMethod_values", "traversalMethod_where", 
        "traversalMethod_with", "traversalMethod_write", "traversalStrategy", 
        "configuration", "traversalScope", "traversalBarrier", "traversalT", 
        "traversalTShort", "traversalTLong", "traversalMerge", "traversalOrder", 
        "traversalDirection", "traversalDirectionShort", "traversalDirectionLong", 
        "traversalCardinality", "traversalColumn", "traversalPop", "traversalOperator", 
        "traversalPick", "traversalDT", "traversalGType", "traversalPredicate", 
        "traversalTerminalMethod", "traversalSackMethod", "traversalComparator", 
        "traversalFunction", "traversalBiFunction", "traversalPredicate_eq", 
        "traversalPredicate_neq", "traversalPredicate_typeOf", "traversalPredicate_lt", 
        "traversalPredicate_lte", "traversalPredicate_gt", "traversalPredicate_gte", 
        "traversalPredicate_inside", "traversalPredicate_outside", "traversalPredicate_between", 
        "traversalPredicate_within", "traversalPredicate_without", "traversalPredicate_not", 
        "traversalPredicate_containing", "traversalPredicate_notContaining", 
        "traversalPredicate_startingWith", "traversalPredicate_notStartingWith", 
        "traversalPredicate_endingWith", "traversalPredicate_notEndingWith", 
        "traversalPredicate_regex", "traversalPredicate_notRegex", "traversalTerminalMethod_explain", 
        "traversalTerminalMethod_hasNext", "traversalTerminalMethod_iterate", 
        "traversalTerminalMethod_tryNext", "traversalTerminalMethod_next", 
        "traversalTerminalMethod_toList", "traversalTerminalMethod_toSet", 
        "traversalTerminalMethod_toBulkSet", "withOptionKeys", "connectedComponentConstants", 
        "pageRankConstants", "peerPressureConstants", "shortestPathConstants", 
        "withOptionsValues", "ioOptionsKeys", "ioOptionsValues", "connectedComponentConstants_component", 
        "connectedComponentConstants_edges", "connectedComponentConstants_propertyName", 
        "pageRankConstants_edges", "pageRankConstants_times", "pageRankConstants_propertyName", 
        "peerPressureConstants_edges", "peerPressureConstants_times", "peerPressureConstants_propertyName", 
        "shortestPathConstants_target", "shortestPathConstants_edges", "shortestPathConstants_distance", 
        "shortestPathConstants_maxDistance", "shortestPathConstants_includeEdges", 
        "withOptionsConstants_tokens", "withOptionsConstants_none", "withOptionsConstants_ids", 
        "withOptionsConstants_labels", "withOptionsConstants_keys", "withOptionsConstants_values", 
        "withOptionsConstants_all", "withOptionsConstants_indexer", "withOptionsConstants_list", 
        "withOptionsConstants_map", "ioOptionsConstants_reader", "ioOptionsConstants_writer", 
        "ioOptionsConstants_gryo", "ioOptionsConstants_graphson", "ioOptionsConstants_graphml", 
        "connectedComponentStringConstant", "pageRankStringConstant", "peerPressureStringConstant", 
        "shortestPathStringConstant", "withOptionsStringConstant", "ioOptionsStringConstant", 
        "booleanArgument", "integerArgument", "stringArgument", "stringArgumentVarargs", 
        "stringNullableArgument", "stringNullableArgumentVarargs", "dateArgument", 
        "genericArgument", "genericArgumentVarargs", "genericMapArgument", 
        "genericMapNullableArgument", "nullableGenericLiteralMap", "traversalStrategyVarargs", 
        "traversalStrategyExpr", "classTypeList", "classTypeExpr", "nestedTraversalList", 
        "nestedTraversalExpr", "genericCollectionLiteral", "genericLiteralVarargs", 
        "genericLiteralExpr", "genericMapNullableLiteral", "genericRangeLiteral", 
        "genericSetLiteral", "stringNullableLiteralVarargs", "stringLiteralVarargs", 
        "genericLiteral", "genericMapLiteral", "mapKey", "mapEntry", "stringLiteral", 
        "stringNullableLiteral", "integerLiteral", "floatLiteral", "numericLiteral", 
        "booleanLiteral", "dateLiteral", "nullLiteral", "nanLiteral", "infLiteral", 
        "uuidLiteral", "characterLiteral", "durationLiteral", "binaryLiteral", 
        "pdtLiteral", "nakedKey", "classType", "variable", "keyword",
    ];

    public get grammarFileName(): string { return "Gremlin.g4"; }
    public get literalNames(): (string | null)[] { return GremlinParser.literalNames; }
    public get symbolicNames(): (string | null)[] { return GremlinParser.symbolicNames; }
    public get ruleNames(): string[] { return GremlinParser.ruleNames; }
    public get serializedATN(): number[] { return GremlinParser._serializedATN; }

    protected createFailedPredicateException(predicate?: string, message?: string): antlr.FailedPredicateException {
        return new antlr.FailedPredicateException(this, predicate, message);
    }

    public constructor(input: antlr.TokenStream) {
        super(input);
        this.interpreter = new antlr.ParserATNSimulator(this, GremlinParser._ATN, GremlinParser.decisionsToDFA, new antlr.PredictionContextCache());
    }
    public queryList(): QueryListContext {
        let localContext = new QueryListContext(this.context, this.state);
        this.enterRule(localContext, 0, GremlinParser.RULE_queryList);
        let _la: number;
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 630;
            this.query(0);
            this.state = 637;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    {
                    {
                    this.state = 632;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if (_la === 319) {
                        {
                        this.state = 631;
                        this.match(GremlinParser.SEMI);
                        }
                    }

                    this.state = 634;
                    this.query(0);
                    }
                    }
                }
                this.state = 639;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1, this.context);
            }
            this.state = 641;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 319) {
                {
                this.state = 640;
                this.match(GremlinParser.SEMI);
                }
            }

            this.state = 643;
            this.match(GremlinParser.EOF);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }

    public query(): QueryContext;
    public query(_p: number): QueryContext;
    public query(_p?: number): QueryContext {
        if (_p === undefined) {
            _p = 0;
        }

        let parentContext = this.context;
        let parentState = this.state;
        let localContext = new QueryContext(this.context, parentState);
        let previousContext = localContext;
        let _startState = 2;
        this.enterRecursionRule(localContext, 2, GremlinParser.RULE_query, _p);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 657;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 3, this.context) ) {
            case 1:
                {
                this.state = 646;
                this.traversalSource(0);
                }
                break;
            case 2:
                {
                this.state = 647;
                this.traversalSource(0);
                this.state = 648;
                this.match(GremlinParser.DOT);
                this.state = 649;
                this.transactionPart();
                }
                break;
            case 3:
                {
                this.state = 651;
                this.rootTraversal();
                }
                break;
            case 4:
                {
                this.state = 652;
                this.rootTraversal();
                this.state = 653;
                this.match(GremlinParser.DOT);
                this.state = 654;
                this.traversalTerminalMethod();
                }
                break;
            case 5:
                {
                this.state = 656;
                this.emptyQuery();
                }
                break;
            }
            this.context!.stop = this.tokenStream.LT(-1);
            this.state = 666;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 4, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    if (this.parseListeners != null) {
                        this.triggerExitRuleEvent();
                    }
                    previousContext = localContext;
                    {
                    {
                    localContext = new QueryContext(parentContext, parentState);
                    this.pushNewRecursionContext(localContext, _startState, GremlinParser.RULE_query);
                    this.state = 659;
                    if (!(this.precpred(this.context, 2))) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 2)");
                    }
                    this.state = 660;
                    this.match(GremlinParser.DOT);
                    this.state = 661;
                    this.match(GremlinParser.K_TOSTRING);
                    this.state = 662;
                    this.match(GremlinParser.LPAREN);
                    this.state = 663;
                    this.match(GremlinParser.RPAREN);
                    }
                    }
                }
                this.state = 668;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 4, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.unrollRecursionContexts(parentContext);
        }
        return localContext;
    }
    public emptyQuery(): EmptyQueryContext {
        let localContext = new EmptyQueryContext(this.context, this.state);
        this.enterRule(localContext, 4, GremlinParser.RULE_emptyQuery);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 669;
            this.match(GremlinParser.EmptyStringLiteral);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }

    public traversalSource(): TraversalSourceContext;
    public traversalSource(_p: number): TraversalSourceContext;
    public traversalSource(_p?: number): TraversalSourceContext {
        if (_p === undefined) {
            _p = 0;
        }

        let parentContext = this.context;
        let parentState = this.state;
        let localContext = new TraversalSourceContext(this.context, parentState);
        let previousContext = localContext;
        let _startState = 6;
        this.enterRecursionRule(localContext, 6, GremlinParser.RULE_traversalSource, _p);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 676;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 5, this.context) ) {
            case 1:
                {
                this.state = 672;
                this.match(GremlinParser.TRAVERSAL_ROOT);
                }
                break;
            case 2:
                {
                this.state = 673;
                this.match(GremlinParser.TRAVERSAL_ROOT);
                this.state = 674;
                this.match(GremlinParser.DOT);
                this.state = 675;
                this.traversalSourceSelfMethod();
                }
                break;
            }
            this.context!.stop = this.tokenStream.LT(-1);
            this.state = 683;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 6, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    if (this.parseListeners != null) {
                        this.triggerExitRuleEvent();
                    }
                    previousContext = localContext;
                    {
                    {
                    localContext = new TraversalSourceContext(parentContext, parentState);
                    this.pushNewRecursionContext(localContext, _startState, GremlinParser.RULE_traversalSource);
                    this.state = 678;
                    if (!(this.precpred(this.context, 1))) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 1)");
                    }
                    this.state = 679;
                    this.match(GremlinParser.DOT);
                    this.state = 680;
                    this.traversalSourceSelfMethod();
                    }
                    }
                }
                this.state = 685;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 6, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.unrollRecursionContexts(parentContext);
        }
        return localContext;
    }
    public transactionPart(): TransactionPartContext {
        let localContext = new TransactionPartContext(this.context, this.state);
        this.enterRule(localContext, 8, GremlinParser.RULE_transactionPart);
        try {
            this.state = 707;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 7, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 686;
                this.match(GremlinParser.K_TX);
                this.state = 687;
                this.match(GremlinParser.LPAREN);
                this.state = 688;
                this.match(GremlinParser.RPAREN);
                this.state = 689;
                this.match(GremlinParser.DOT);
                this.state = 690;
                this.match(GremlinParser.K_BEGIN);
                this.state = 691;
                this.match(GremlinParser.LPAREN);
                this.state = 692;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 693;
                this.match(GremlinParser.K_TX);
                this.state = 694;
                this.match(GremlinParser.LPAREN);
                this.state = 695;
                this.match(GremlinParser.RPAREN);
                this.state = 696;
                this.match(GremlinParser.DOT);
                this.state = 697;
                this.match(GremlinParser.K_COMMIT);
                this.state = 698;
                this.match(GremlinParser.LPAREN);
                this.state = 699;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 700;
                this.match(GremlinParser.K_TX);
                this.state = 701;
                this.match(GremlinParser.LPAREN);
                this.state = 702;
                this.match(GremlinParser.RPAREN);
                this.state = 703;
                this.match(GremlinParser.DOT);
                this.state = 704;
                this.match(GremlinParser.K_ROLLBACK);
                this.state = 705;
                this.match(GremlinParser.LPAREN);
                this.state = 706;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public rootTraversal(): RootTraversalContext {
        let localContext = new RootTraversalContext(this.context, this.state);
        this.enterRule(localContext, 10, GremlinParser.RULE_rootTraversal);
        try {
            this.state = 719;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 8, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 709;
                this.traversalSource(0);
                this.state = 710;
                this.match(GremlinParser.DOT);
                this.state = 711;
                this.traversalSourceSpawnMethod();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 713;
                this.traversalSource(0);
                this.state = 714;
                this.match(GremlinParser.DOT);
                this.state = 715;
                this.traversalSourceSpawnMethod();
                this.state = 716;
                this.match(GremlinParser.DOT);
                this.state = 717;
                this.chainedTraversal(0);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSelfMethod(): TraversalSourceSelfMethodContext {
        let localContext = new TraversalSourceSelfMethodContext(this.context, this.state);
        this.enterRule(localContext, 12, GremlinParser.RULE_traversalSourceSelfMethod);
        try {
            this.state = 728;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_WITHBULK:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 721;
                this.traversalSourceSelfMethod_withBulk();
                }
                break;
            case GremlinParser.K_WITHPATH:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 722;
                this.traversalSourceSelfMethod_withPath();
                }
                break;
            case GremlinParser.K_WITHSACK:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 723;
                this.traversalSourceSelfMethod_withSack();
                }
                break;
            case GremlinParser.K_WITHSIDEEFFECT:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 724;
                this.traversalSourceSelfMethod_withSideEffect();
                }
                break;
            case GremlinParser.K_WITHSTRATEGIES:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 725;
                this.traversalSourceSelfMethod_withStrategies();
                }
                break;
            case GremlinParser.K_WITHOUTSTRATEGIES:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 726;
                this.traversalSourceSelfMethod_withoutStrategies();
                }
                break;
            case GremlinParser.K_WITH:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 727;
                this.traversalSourceSelfMethod_with();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSelfMethod_withBulk(): TraversalSourceSelfMethod_withBulkContext {
        let localContext = new TraversalSourceSelfMethod_withBulkContext(this.context, this.state);
        this.enterRule(localContext, 14, GremlinParser.RULE_traversalSourceSelfMethod_withBulk);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 730;
            this.match(GremlinParser.K_WITHBULK);
            this.state = 731;
            this.match(GremlinParser.LPAREN);
            this.state = 732;
            this.booleanLiteral();
            this.state = 733;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSelfMethod_withPath(): TraversalSourceSelfMethod_withPathContext {
        let localContext = new TraversalSourceSelfMethod_withPathContext(this.context, this.state);
        this.enterRule(localContext, 16, GremlinParser.RULE_traversalSourceSelfMethod_withPath);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 735;
            this.match(GremlinParser.K_WITHPATH);
            this.state = 736;
            this.match(GremlinParser.LPAREN);
            this.state = 737;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSelfMethod_withSack(): TraversalSourceSelfMethod_withSackContext {
        let localContext = new TraversalSourceSelfMethod_withSackContext(this.context, this.state);
        this.enterRule(localContext, 18, GremlinParser.RULE_traversalSourceSelfMethod_withSack);
        try {
            this.state = 751;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 10, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 739;
                this.match(GremlinParser.K_WITHSACK);
                this.state = 740;
                this.match(GremlinParser.LPAREN);
                this.state = 741;
                this.genericLiteral();
                this.state = 742;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 744;
                this.match(GremlinParser.K_WITHSACK);
                this.state = 745;
                this.match(GremlinParser.LPAREN);
                this.state = 746;
                this.genericLiteral();
                this.state = 747;
                this.match(GremlinParser.COMMA);
                this.state = 748;
                this.traversalBiFunction();
                this.state = 749;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSelfMethod_withSideEffect(): TraversalSourceSelfMethod_withSideEffectContext {
        let localContext = new TraversalSourceSelfMethod_withSideEffectContext(this.context, this.state);
        this.enterRule(localContext, 20, GremlinParser.RULE_traversalSourceSelfMethod_withSideEffect);
        try {
            this.state = 769;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 11, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 753;
                this.match(GremlinParser.K_WITHSIDEEFFECT);
                this.state = 754;
                this.match(GremlinParser.LPAREN);
                this.state = 755;
                this.stringLiteral();
                this.state = 756;
                this.match(GremlinParser.COMMA);
                this.state = 757;
                this.genericLiteral();
                this.state = 758;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 760;
                this.match(GremlinParser.K_WITHSIDEEFFECT);
                this.state = 761;
                this.match(GremlinParser.LPAREN);
                this.state = 762;
                this.stringLiteral();
                this.state = 763;
                this.match(GremlinParser.COMMA);
                this.state = 764;
                this.genericLiteral();
                this.state = 765;
                this.match(GremlinParser.COMMA);
                this.state = 766;
                this.traversalBiFunction();
                this.state = 767;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSelfMethod_withStrategies(): TraversalSourceSelfMethod_withStrategiesContext {
        let localContext = new TraversalSourceSelfMethod_withStrategiesContext(this.context, this.state);
        this.enterRule(localContext, 22, GremlinParser.RULE_traversalSourceSelfMethod_withStrategies);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 771;
            this.match(GremlinParser.K_WITHSTRATEGIES);
            this.state = 772;
            this.match(GremlinParser.LPAREN);
            this.state = 773;
            this.traversalStrategy();
            this.state = 776;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 320) {
                {
                this.state = 774;
                this.match(GremlinParser.COMMA);
                this.state = 775;
                this.traversalStrategyVarargs();
                }
            }

            this.state = 778;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSelfMethod_withoutStrategies(): TraversalSourceSelfMethod_withoutStrategiesContext {
        let localContext = new TraversalSourceSelfMethod_withoutStrategiesContext(this.context, this.state);
        this.enterRule(localContext, 24, GremlinParser.RULE_traversalSourceSelfMethod_withoutStrategies);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 780;
            this.match(GremlinParser.K_WITHOUTSTRATEGIES);
            this.state = 781;
            this.match(GremlinParser.LPAREN);
            this.state = 782;
            this.classType();
            this.state = 785;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 320) {
                {
                this.state = 783;
                this.match(GremlinParser.COMMA);
                this.state = 784;
                this.classTypeList();
                }
            }

            this.state = 787;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSelfMethod_with(): TraversalSourceSelfMethod_withContext {
        let localContext = new TraversalSourceSelfMethod_withContext(this.context, this.state);
        this.enterRule(localContext, 26, GremlinParser.RULE_traversalSourceSelfMethod_with);
        try {
            this.state = 801;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 14, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 789;
                this.match(GremlinParser.K_WITH);
                this.state = 790;
                this.match(GremlinParser.LPAREN);
                this.state = 791;
                this.stringLiteral();
                this.state = 792;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 794;
                this.match(GremlinParser.K_WITH);
                this.state = 795;
                this.match(GremlinParser.LPAREN);
                this.state = 796;
                this.stringLiteral();
                this.state = 797;
                this.match(GremlinParser.COMMA);
                this.state = 798;
                this.genericLiteral();
                this.state = 799;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSpawnMethod(): TraversalSourceSpawnMethodContext {
        let localContext = new TraversalSourceSpawnMethodContext(this.context, this.state);
        this.enterRule(localContext, 28, GremlinParser.RULE_traversalSourceSpawnMethod);
        try {
            this.state = 814;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_ADDE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 803;
                this.traversalSourceSpawnMethod_addE();
                }
                break;
            case GremlinParser.K_ADDV:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 804;
                this.traversalSourceSpawnMethod_addV();
                }
                break;
            case GremlinParser.K_E:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 805;
                this.traversalSourceSpawnMethod_E();
                }
                break;
            case GremlinParser.K_V:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 806;
                this.traversalSourceSpawnMethod_V();
                }
                break;
            case GremlinParser.K_MERGEE:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 807;
                this.traversalSourceSpawnMethod_mergeE();
                }
                break;
            case GremlinParser.K_MERGEV:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 808;
                this.traversalSourceSpawnMethod_mergeV();
                }
                break;
            case GremlinParser.K_INJECT:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 809;
                this.traversalSourceSpawnMethod_inject();
                }
                break;
            case GremlinParser.K_IO:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 810;
                this.traversalSourceSpawnMethod_io();
                }
                break;
            case GremlinParser.K_CALL:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 811;
                this.traversalSourceSpawnMethod_call();
                }
                break;
            case GremlinParser.K_UNION:
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 812;
                this.traversalSourceSpawnMethod_union();
                }
                break;
            case GremlinParser.K_MATCH:
                this.enterOuterAlt(localContext, 11);
                {
                this.state = 813;
                this.traversalSourceSpawnMethod_match();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSpawnMethod_addE(): TraversalSourceSpawnMethod_addEContext {
        let localContext = new TraversalSourceSpawnMethod_addEContext(this.context, this.state);
        this.enterRule(localContext, 30, GremlinParser.RULE_traversalSourceSpawnMethod_addE);
        try {
            this.state = 826;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 16, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 816;
                this.match(GremlinParser.K_ADDE);
                this.state = 817;
                this.match(GremlinParser.LPAREN);
                this.state = 818;
                this.stringArgument();
                this.state = 819;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 821;
                this.match(GremlinParser.K_ADDE);
                this.state = 822;
                this.match(GremlinParser.LPAREN);
                this.state = 823;
                this.nestedTraversal();
                this.state = 824;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSpawnMethod_addV(): TraversalSourceSpawnMethod_addVContext {
        let localContext = new TraversalSourceSpawnMethod_addVContext(this.context, this.state);
        this.enterRule(localContext, 32, GremlinParser.RULE_traversalSourceSpawnMethod_addV);
        let _la: number;
        try {
            this.state = 848;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 18, this.context) ) {
            case 1:
                localContext = new TraversalSourceSpawnMethod_addV_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 828;
                this.match(GremlinParser.K_ADDV);
                this.state = 829;
                this.match(GremlinParser.LPAREN);
                this.state = 830;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalSourceSpawnMethod_addV_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 831;
                this.match(GremlinParser.K_ADDV);
                this.state = 832;
                this.match(GremlinParser.LPAREN);
                this.state = 833;
                this.stringArgumentVarargs();
                this.state = 834;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalSourceSpawnMethod_addV_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 836;
                this.match(GremlinParser.K_ADDV);
                this.state = 837;
                this.match(GremlinParser.LPAREN);
                this.state = 838;
                this.nestedTraversal();
                this.state = 843;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 320) {
                    {
                    {
                    this.state = 839;
                    this.match(GremlinParser.COMMA);
                    this.state = 840;
                    this.nestedTraversal();
                    }
                    }
                    this.state = 845;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 846;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSpawnMethod_E(): TraversalSourceSpawnMethod_EContext {
        let localContext = new TraversalSourceSpawnMethod_EContext(this.context, this.state);
        this.enterRule(localContext, 34, GremlinParser.RULE_traversalSourceSpawnMethod_E);
        try {
            this.state = 860;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 19, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 850;
                this.match(GremlinParser.K_E);
                this.state = 851;
                this.match(GremlinParser.LPAREN);
                this.state = 852;
                this.genericArgumentVarargs();
                this.state = 853;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 855;
                this.match(GremlinParser.K_E);
                this.state = 856;
                this.match(GremlinParser.LPAREN);
                this.state = 857;
                this.nestedTraversal();
                this.state = 858;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSpawnMethod_V(): TraversalSourceSpawnMethod_VContext {
        let localContext = new TraversalSourceSpawnMethod_VContext(this.context, this.state);
        this.enterRule(localContext, 36, GremlinParser.RULE_traversalSourceSpawnMethod_V);
        try {
            this.state = 872;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 20, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 862;
                this.match(GremlinParser.K_V);
                this.state = 863;
                this.match(GremlinParser.LPAREN);
                this.state = 864;
                this.genericArgumentVarargs();
                this.state = 865;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 867;
                this.match(GremlinParser.K_V);
                this.state = 868;
                this.match(GremlinParser.LPAREN);
                this.state = 869;
                this.nestedTraversal();
                this.state = 870;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSpawnMethod_inject(): TraversalSourceSpawnMethod_injectContext {
        let localContext = new TraversalSourceSpawnMethod_injectContext(this.context, this.state);
        this.enterRule(localContext, 38, GremlinParser.RULE_traversalSourceSpawnMethod_inject);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 874;
            this.match(GremlinParser.K_INJECT);
            this.state = 875;
            this.match(GremlinParser.LPAREN);
            this.state = 876;
            this.genericLiteralVarargs();
            this.state = 877;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSpawnMethod_io(): TraversalSourceSpawnMethod_ioContext {
        let localContext = new TraversalSourceSpawnMethod_ioContext(this.context, this.state);
        this.enterRule(localContext, 40, GremlinParser.RULE_traversalSourceSpawnMethod_io);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 879;
            this.match(GremlinParser.K_IO);
            this.state = 880;
            this.match(GremlinParser.LPAREN);
            this.state = 881;
            this.stringLiteral();
            this.state = 882;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSpawnMethod_mergeV(): TraversalSourceSpawnMethod_mergeVContext {
        let localContext = new TraversalSourceSpawnMethod_mergeVContext(this.context, this.state);
        this.enterRule(localContext, 42, GremlinParser.RULE_traversalSourceSpawnMethod_mergeV);
        try {
            this.state = 894;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 21, this.context) ) {
            case 1:
                localContext = new TraversalSourceSpawnMethod_mergeV_MapContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 884;
                this.match(GremlinParser.K_MERGEV);
                this.state = 885;
                this.match(GremlinParser.LPAREN);
                this.state = 886;
                this.genericMapNullableArgument();
                this.state = 887;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalSourceSpawnMethod_mergeV_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 889;
                this.match(GremlinParser.K_MERGEV);
                this.state = 890;
                this.match(GremlinParser.LPAREN);
                this.state = 891;
                this.nestedTraversal();
                this.state = 892;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSpawnMethod_mergeE(): TraversalSourceSpawnMethod_mergeEContext {
        let localContext = new TraversalSourceSpawnMethod_mergeEContext(this.context, this.state);
        this.enterRule(localContext, 44, GremlinParser.RULE_traversalSourceSpawnMethod_mergeE);
        try {
            this.state = 906;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 22, this.context) ) {
            case 1:
                localContext = new TraversalSourceSpawnMethod_mergeE_MapContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 896;
                this.match(GremlinParser.K_MERGEE);
                this.state = 897;
                this.match(GremlinParser.LPAREN);
                this.state = 898;
                this.genericMapNullableArgument();
                this.state = 899;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalSourceSpawnMethod_mergeE_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 901;
                this.match(GremlinParser.K_MERGEE);
                this.state = 902;
                this.match(GremlinParser.LPAREN);
                this.state = 903;
                this.nestedTraversal();
                this.state = 904;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSpawnMethod_call(): TraversalSourceSpawnMethod_callContext {
        let localContext = new TraversalSourceSpawnMethod_callContext(this.context, this.state);
        this.enterRule(localContext, 46, GremlinParser.RULE_traversalSourceSpawnMethod_call);
        try {
            this.state = 939;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 23, this.context) ) {
            case 1:
                localContext = new TraversalSourceSpawnMethod_call_emptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 908;
                this.match(GremlinParser.K_CALL);
                this.state = 909;
                this.match(GremlinParser.LPAREN);
                this.state = 910;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalSourceSpawnMethod_call_stringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 911;
                this.match(GremlinParser.K_CALL);
                this.state = 912;
                this.match(GremlinParser.LPAREN);
                this.state = 913;
                this.stringLiteral();
                this.state = 914;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalSourceSpawnMethod_call_string_mapContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 916;
                this.match(GremlinParser.K_CALL);
                this.state = 917;
                this.match(GremlinParser.LPAREN);
                this.state = 918;
                this.stringLiteral();
                this.state = 919;
                this.match(GremlinParser.COMMA);
                this.state = 920;
                this.genericMapArgument();
                this.state = 921;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 4:
                localContext = new TraversalSourceSpawnMethod_call_string_traversalContext(localContext);
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 923;
                this.match(GremlinParser.K_CALL);
                this.state = 924;
                this.match(GremlinParser.LPAREN);
                this.state = 925;
                this.stringLiteral();
                this.state = 926;
                this.match(GremlinParser.COMMA);
                this.state = 927;
                this.nestedTraversal();
                this.state = 928;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 5:
                localContext = new TraversalSourceSpawnMethod_call_string_map_traversalContext(localContext);
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 930;
                this.match(GremlinParser.K_CALL);
                this.state = 931;
                this.match(GremlinParser.LPAREN);
                this.state = 932;
                this.stringLiteral();
                this.state = 933;
                this.match(GremlinParser.COMMA);
                this.state = 934;
                this.genericMapArgument();
                this.state = 935;
                this.match(GremlinParser.COMMA);
                this.state = 936;
                this.nestedTraversal();
                this.state = 937;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSpawnMethod_union(): TraversalSourceSpawnMethod_unionContext {
        let localContext = new TraversalSourceSpawnMethod_unionContext(this.context, this.state);
        this.enterRule(localContext, 48, GremlinParser.RULE_traversalSourceSpawnMethod_union);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 941;
            this.match(GremlinParser.K_UNION);
            this.state = 942;
            this.match(GremlinParser.LPAREN);
            this.state = 943;
            this.nestedTraversalList();
            this.state = 944;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSourceSpawnMethod_match(): TraversalSourceSpawnMethod_matchContext {
        let localContext = new TraversalSourceSpawnMethod_matchContext(this.context, this.state);
        this.enterRule(localContext, 50, GremlinParser.RULE_traversalSourceSpawnMethod_match);
        try {
            this.state = 958;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 24, this.context) ) {
            case 1:
                localContext = new TraversalSourceSpawnMethod_match_stringContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 946;
                this.match(GremlinParser.K_MATCH);
                this.state = 947;
                this.match(GremlinParser.LPAREN);
                this.state = 948;
                this.stringLiteral();
                this.state = 949;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalSourceSpawnMethod_match_string_mapContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 951;
                this.match(GremlinParser.K_MATCH);
                this.state = 952;
                this.match(GremlinParser.LPAREN);
                this.state = 953;
                this.stringLiteral();
                this.state = 954;
                this.match(GremlinParser.COMMA);
                this.state = 955;
                this.genericMapLiteral();
                this.state = 956;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }

    public chainedTraversal(): ChainedTraversalContext;
    public chainedTraversal(_p: number): ChainedTraversalContext;
    public chainedTraversal(_p?: number): ChainedTraversalContext {
        if (_p === undefined) {
            _p = 0;
        }

        let parentContext = this.context;
        let parentState = this.state;
        let localContext = new ChainedTraversalContext(this.context, parentState);
        let previousContext = localContext;
        let _startState = 52;
        this.enterRecursionRule(localContext, 52, GremlinParser.RULE_chainedTraversal, _p);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            {
            this.state = 961;
            this.traversalMethod();
            }
            this.context!.stop = this.tokenStream.LT(-1);
            this.state = 968;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 25, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    if (this.parseListeners != null) {
                        this.triggerExitRuleEvent();
                    }
                    previousContext = localContext;
                    {
                    {
                    localContext = new ChainedTraversalContext(parentContext, parentState);
                    this.pushNewRecursionContext(localContext, _startState, GremlinParser.RULE_chainedTraversal);
                    this.state = 963;
                    if (!(this.precpred(this.context, 1))) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 1)");
                    }
                    this.state = 964;
                    this.match(GremlinParser.DOT);
                    this.state = 965;
                    this.traversalMethod();
                    }
                    }
                }
                this.state = 970;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 25, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.unrollRecursionContexts(parentContext);
        }
        return localContext;
    }
    public nestedTraversal(): NestedTraversalContext {
        let localContext = new NestedTraversalContext(this.context, this.state);
        this.enterRule(localContext, 54, GremlinParser.RULE_nestedTraversal);
        try {
            this.state = 975;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_ADDE:
            case GremlinParser.K_ADDLABEL:
            case GremlinParser.K_ADDV:
            case GremlinParser.K_AGGREGATE:
            case GremlinParser.K_ALL:
            case GremlinParser.K_AND:
            case GremlinParser.K_ANY:
            case GremlinParser.K_AS:
            case GremlinParser.K_ASBOOL:
            case GremlinParser.K_ASDATE:
            case GremlinParser.K_ASNUMBER:
            case GremlinParser.K_ASSTRING:
            case GremlinParser.K_BARRIER:
            case GremlinParser.K_BOTH:
            case GremlinParser.K_BOTHE:
            case GremlinParser.K_BOTHV:
            case GremlinParser.K_BRANCH:
            case GremlinParser.K_BY:
            case GremlinParser.K_CALL:
            case GremlinParser.K_CAP:
            case GremlinParser.K_CHOOSE:
            case GremlinParser.K_COALESCE:
            case GremlinParser.K_COIN:
            case GremlinParser.K_COMBINE:
            case GremlinParser.K_CONCAT:
            case GremlinParser.K_CONJOIN:
            case GremlinParser.K_CONNECTEDCOMPONENT:
            case GremlinParser.K_CONSTANT:
            case GremlinParser.K_COUNT:
            case GremlinParser.K_CYCLICPATH:
            case GremlinParser.K_DATEADD:
            case GremlinParser.K_DATEDIFF:
            case GremlinParser.K_DEDUP:
            case GremlinParser.K_DIFFERENCE:
            case GremlinParser.K_DISCARD:
            case GremlinParser.K_DISJUNCT:
            case GremlinParser.K_DROP:
            case GremlinParser.K_DROPLABEL:
            case GremlinParser.K_DROPLABELS:
            case GremlinParser.K_E:
            case GremlinParser.K_ELEMENTMAP:
            case GremlinParser.K_ELEMENT:
            case GremlinParser.K_EMIT:
            case GremlinParser.K_FAIL:
            case GremlinParser.K_FILTER:
            case GremlinParser.K_FLATMAP:
            case GremlinParser.K_FOLD:
            case GremlinParser.K_FORMAT:
            case GremlinParser.K_FROM:
            case GremlinParser.K_GROUPCOUNT:
            case GremlinParser.K_GROUP:
            case GremlinParser.K_HAS:
            case GremlinParser.K_HASID:
            case GremlinParser.K_HASKEY:
            case GremlinParser.K_HASLABEL:
            case GremlinParser.K_HASNOT:
            case GremlinParser.K_HASVALUE:
            case GremlinParser.K_ID:
            case GremlinParser.K_IDENTITY:
            case GremlinParser.K_IN:
            case GremlinParser.K_INE:
            case GremlinParser.K_INDEX:
            case GremlinParser.K_INJECT:
            case GremlinParser.K_INTERSECT:
            case GremlinParser.K_INV:
            case GremlinParser.K_IS:
            case GremlinParser.K_KEY:
            case GremlinParser.K_LABELS:
            case GremlinParser.K_LABEL:
            case GremlinParser.K_LENGTH:
            case GremlinParser.K_LIMIT:
            case GremlinParser.K_LOCAL:
            case GremlinParser.K_LOOPS:
            case GremlinParser.K_LTRIM:
            case GremlinParser.K_MAP:
            case GremlinParser.K_MATCH:
            case GremlinParser.K_MATH:
            case GremlinParser.K_MAX:
            case GremlinParser.K_MEAN:
            case GremlinParser.K_MERGE:
            case GremlinParser.K_MERGEE:
            case GremlinParser.K_MERGEV:
            case GremlinParser.K_MIN:
            case GremlinParser.K_NONE:
            case GremlinParser.K_NOT:
            case GremlinParser.K_OPTION:
            case GremlinParser.K_OPTIONAL:
            case GremlinParser.K_ORDER:
            case GremlinParser.K_OR:
            case GremlinParser.K_OTHERV:
            case GremlinParser.K_OUT:
            case GremlinParser.K_OUTE:
            case GremlinParser.K_OUTV:
            case GremlinParser.K_PAGERANK:
            case GremlinParser.K_PATH:
            case GremlinParser.K_PEERPRESSURE:
            case GremlinParser.K_PROFILE:
            case GremlinParser.K_PROJECT:
            case GremlinParser.K_PROPERTIES:
            case GremlinParser.K_PROPERTYMAP:
            case GremlinParser.K_PROPERTY:
            case GremlinParser.K_PRODUCT:
            case GremlinParser.K_RANGE:
            case GremlinParser.K_READ:
            case GremlinParser.K_REPLACE:
            case GremlinParser.K_REPEAT:
            case GremlinParser.K_REVERSE:
            case GremlinParser.K_RTRIM:
            case GremlinParser.K_SACK:
            case GremlinParser.K_SAMPLE:
            case GremlinParser.K_SELECT:
            case GremlinParser.K_SHORTESTPATH:
            case GremlinParser.K_SIDEEFFECT:
            case GremlinParser.K_SIMPLEPATH:
            case GremlinParser.K_SKIP:
            case GremlinParser.K_SPLIT:
            case GremlinParser.K_SUBGRAPH:
            case GremlinParser.K_SUBSTRING:
            case GremlinParser.K_SUM:
            case GremlinParser.K_TAIL:
            case GremlinParser.K_TIMELIMIT:
            case GremlinParser.K_TIMES:
            case GremlinParser.K_TO:
            case GremlinParser.K_TOLOWER:
            case GremlinParser.K_TOUPPER:
            case GremlinParser.K_TOE:
            case GremlinParser.K_TOV:
            case GremlinParser.K_TREE:
            case GremlinParser.K_TRIM:
            case GremlinParser.K_UNFOLD:
            case GremlinParser.K_UNION:
            case GremlinParser.K_UNTIL:
            case GremlinParser.K_V:
            case GremlinParser.K_VALUEMAP:
            case GremlinParser.K_VALUES:
            case GremlinParser.K_VALUE:
            case GremlinParser.K_WHERE:
            case GremlinParser.K_WITH:
            case GremlinParser.K_WRITE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 971;
                this.chainedTraversal(0);
                }
                break;
            case GremlinParser.ANON_TRAVERSAL_ROOT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 972;
                this.match(GremlinParser.ANON_TRAVERSAL_ROOT);
                this.state = 973;
                this.match(GremlinParser.DOT);
                this.state = 974;
                this.chainedTraversal(0);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public terminatedTraversal(): TerminatedTraversalContext {
        let localContext = new TerminatedTraversalContext(this.context, this.state);
        this.enterRule(localContext, 56, GremlinParser.RULE_terminatedTraversal);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 977;
            this.rootTraversal();
            this.state = 978;
            this.match(GremlinParser.DOT);
            this.state = 979;
            this.traversalTerminalMethod();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod(): TraversalMethodContext {
        let localContext = new TraversalMethodContext(this.context, this.state);
        this.enterRule(localContext, 58, GremlinParser.RULE_traversalMethod);
        try {
            this.state = 1120;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_V:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 981;
                this.traversalMethod_V();
                }
                break;
            case GremlinParser.K_E:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 982;
                this.traversalMethod_E();
                }
                break;
            case GremlinParser.K_ADDE:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 983;
                this.traversalMethod_addE();
                }
                break;
            case GremlinParser.K_ADDV:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 984;
                this.traversalMethod_addV();
                }
                break;
            case GremlinParser.K_MERGEE:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 985;
                this.traversalMethod_mergeE();
                }
                break;
            case GremlinParser.K_MERGEV:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 986;
                this.traversalMethod_mergeV();
                }
                break;
            case GremlinParser.K_AGGREGATE:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 987;
                this.traversalMethod_aggregate();
                }
                break;
            case GremlinParser.K_ALL:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 988;
                this.traversalMethod_all();
                }
                break;
            case GremlinParser.K_AND:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 989;
                this.traversalMethod_and();
                }
                break;
            case GremlinParser.K_ANY:
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 990;
                this.traversalMethod_any();
                }
                break;
            case GremlinParser.K_AS:
                this.enterOuterAlt(localContext, 11);
                {
                this.state = 991;
                this.traversalMethod_as();
                }
                break;
            case GremlinParser.K_BARRIER:
                this.enterOuterAlt(localContext, 12);
                {
                this.state = 992;
                this.traversalMethod_barrier();
                }
                break;
            case GremlinParser.K_BOTH:
                this.enterOuterAlt(localContext, 13);
                {
                this.state = 993;
                this.traversalMethod_both();
                }
                break;
            case GremlinParser.K_BOTHE:
                this.enterOuterAlt(localContext, 14);
                {
                this.state = 994;
                this.traversalMethod_bothE();
                }
                break;
            case GremlinParser.K_BOTHV:
                this.enterOuterAlt(localContext, 15);
                {
                this.state = 995;
                this.traversalMethod_bothV();
                }
                break;
            case GremlinParser.K_BRANCH:
                this.enterOuterAlt(localContext, 16);
                {
                this.state = 996;
                this.traversalMethod_branch();
                }
                break;
            case GremlinParser.K_BY:
                this.enterOuterAlt(localContext, 17);
                {
                this.state = 997;
                this.traversalMethod_by();
                }
                break;
            case GremlinParser.K_CAP:
                this.enterOuterAlt(localContext, 18);
                {
                this.state = 998;
                this.traversalMethod_cap();
                }
                break;
            case GremlinParser.K_CHOOSE:
                this.enterOuterAlt(localContext, 19);
                {
                this.state = 999;
                this.traversalMethod_choose();
                }
                break;
            case GremlinParser.K_COALESCE:
                this.enterOuterAlt(localContext, 20);
                {
                this.state = 1000;
                this.traversalMethod_coalesce();
                }
                break;
            case GremlinParser.K_COIN:
                this.enterOuterAlt(localContext, 21);
                {
                this.state = 1001;
                this.traversalMethod_coin();
                }
                break;
            case GremlinParser.K_CONJOIN:
                this.enterOuterAlt(localContext, 22);
                {
                this.state = 1002;
                this.traversalMethod_conjoin();
                }
                break;
            case GremlinParser.K_CONNECTEDCOMPONENT:
                this.enterOuterAlt(localContext, 23);
                {
                this.state = 1003;
                this.traversalMethod_connectedComponent();
                }
                break;
            case GremlinParser.K_CONSTANT:
                this.enterOuterAlt(localContext, 24);
                {
                this.state = 1004;
                this.traversalMethod_constant();
                }
                break;
            case GremlinParser.K_COUNT:
                this.enterOuterAlt(localContext, 25);
                {
                this.state = 1005;
                this.traversalMethod_count();
                }
                break;
            case GremlinParser.K_CYCLICPATH:
                this.enterOuterAlt(localContext, 26);
                {
                this.state = 1006;
                this.traversalMethod_cyclicPath();
                }
                break;
            case GremlinParser.K_DEDUP:
                this.enterOuterAlt(localContext, 27);
                {
                this.state = 1007;
                this.traversalMethod_dedup();
                }
                break;
            case GremlinParser.K_DIFFERENCE:
                this.enterOuterAlt(localContext, 28);
                {
                this.state = 1008;
                this.traversalMethod_difference();
                }
                break;
            case GremlinParser.K_DISCARD:
                this.enterOuterAlt(localContext, 29);
                {
                this.state = 1009;
                this.traversalMethod_discard();
                }
                break;
            case GremlinParser.K_DISJUNCT:
                this.enterOuterAlt(localContext, 30);
                {
                this.state = 1010;
                this.traversalMethod_disjunct();
                }
                break;
            case GremlinParser.K_DROP:
                this.enterOuterAlt(localContext, 31);
                {
                this.state = 1011;
                this.traversalMethod_drop();
                }
                break;
            case GremlinParser.K_ELEMENTMAP:
                this.enterOuterAlt(localContext, 32);
                {
                this.state = 1012;
                this.traversalMethod_elementMap();
                }
                break;
            case GremlinParser.K_EMIT:
                this.enterOuterAlt(localContext, 33);
                {
                this.state = 1013;
                this.traversalMethod_emit();
                }
                break;
            case GremlinParser.K_FILTER:
                this.enterOuterAlt(localContext, 34);
                {
                this.state = 1014;
                this.traversalMethod_filter();
                }
                break;
            case GremlinParser.K_FLATMAP:
                this.enterOuterAlt(localContext, 35);
                {
                this.state = 1015;
                this.traversalMethod_flatMap();
                }
                break;
            case GremlinParser.K_FOLD:
                this.enterOuterAlt(localContext, 36);
                {
                this.state = 1016;
                this.traversalMethod_fold();
                }
                break;
            case GremlinParser.K_FROM:
                this.enterOuterAlt(localContext, 37);
                {
                this.state = 1017;
                this.traversalMethod_from();
                }
                break;
            case GremlinParser.K_GROUP:
                this.enterOuterAlt(localContext, 38);
                {
                this.state = 1018;
                this.traversalMethod_group();
                }
                break;
            case GremlinParser.K_GROUPCOUNT:
                this.enterOuterAlt(localContext, 39);
                {
                this.state = 1019;
                this.traversalMethod_groupCount();
                }
                break;
            case GremlinParser.K_HAS:
                this.enterOuterAlt(localContext, 40);
                {
                this.state = 1020;
                this.traversalMethod_has();
                }
                break;
            case GremlinParser.K_HASID:
                this.enterOuterAlt(localContext, 41);
                {
                this.state = 1021;
                this.traversalMethod_hasId();
                }
                break;
            case GremlinParser.K_HASKEY:
                this.enterOuterAlt(localContext, 42);
                {
                this.state = 1022;
                this.traversalMethod_hasKey();
                }
                break;
            case GremlinParser.K_HASLABEL:
                this.enterOuterAlt(localContext, 43);
                {
                this.state = 1023;
                this.traversalMethod_hasLabel();
                }
                break;
            case GremlinParser.K_HASNOT:
                this.enterOuterAlt(localContext, 44);
                {
                this.state = 1024;
                this.traversalMethod_hasNot();
                }
                break;
            case GremlinParser.K_HASVALUE:
                this.enterOuterAlt(localContext, 45);
                {
                this.state = 1025;
                this.traversalMethod_hasValue();
                }
                break;
            case GremlinParser.K_ID:
                this.enterOuterAlt(localContext, 46);
                {
                this.state = 1026;
                this.traversalMethod_id();
                }
                break;
            case GremlinParser.K_IDENTITY:
                this.enterOuterAlt(localContext, 47);
                {
                this.state = 1027;
                this.traversalMethod_identity();
                }
                break;
            case GremlinParser.K_IN:
                this.enterOuterAlt(localContext, 48);
                {
                this.state = 1028;
                this.traversalMethod_in();
                }
                break;
            case GremlinParser.K_INE:
                this.enterOuterAlt(localContext, 49);
                {
                this.state = 1029;
                this.traversalMethod_inE();
                }
                break;
            case GremlinParser.K_INTERSECT:
                this.enterOuterAlt(localContext, 50);
                {
                this.state = 1030;
                this.traversalMethod_intersect();
                }
                break;
            case GremlinParser.K_INV:
                this.enterOuterAlt(localContext, 51);
                {
                this.state = 1031;
                this.traversalMethod_inV();
                }
                break;
            case GremlinParser.K_INDEX:
                this.enterOuterAlt(localContext, 52);
                {
                this.state = 1032;
                this.traversalMethod_index();
                }
                break;
            case GremlinParser.K_INJECT:
                this.enterOuterAlt(localContext, 53);
                {
                this.state = 1033;
                this.traversalMethod_inject();
                }
                break;
            case GremlinParser.K_IS:
                this.enterOuterAlt(localContext, 54);
                {
                this.state = 1034;
                this.traversalMethod_is();
                }
                break;
            case GremlinParser.K_KEY:
                this.enterOuterAlt(localContext, 55);
                {
                this.state = 1035;
                this.traversalMethod_key();
                }
                break;
            case GremlinParser.K_LABEL:
                this.enterOuterAlt(localContext, 56);
                {
                this.state = 1036;
                this.traversalMethod_label();
                }
                break;
            case GremlinParser.K_LIMIT:
                this.enterOuterAlt(localContext, 57);
                {
                this.state = 1037;
                this.traversalMethod_limit();
                }
                break;
            case GremlinParser.K_LOCAL:
                this.enterOuterAlt(localContext, 58);
                {
                this.state = 1038;
                this.traversalMethod_local();
                }
                break;
            case GremlinParser.K_LOOPS:
                this.enterOuterAlt(localContext, 59);
                {
                this.state = 1039;
                this.traversalMethod_loops();
                }
                break;
            case GremlinParser.K_MAP:
                this.enterOuterAlt(localContext, 60);
                {
                this.state = 1040;
                this.traversalMethod_map();
                }
                break;
            case GremlinParser.K_MATCH:
                this.enterOuterAlt(localContext, 61);
                {
                this.state = 1041;
                this.traversalMethod_match();
                }
                break;
            case GremlinParser.K_MATH:
                this.enterOuterAlt(localContext, 62);
                {
                this.state = 1042;
                this.traversalMethod_math();
                }
                break;
            case GremlinParser.K_MAX:
                this.enterOuterAlt(localContext, 63);
                {
                this.state = 1043;
                this.traversalMethod_max();
                }
                break;
            case GremlinParser.K_MEAN:
                this.enterOuterAlt(localContext, 64);
                {
                this.state = 1044;
                this.traversalMethod_mean();
                }
                break;
            case GremlinParser.K_MIN:
                this.enterOuterAlt(localContext, 65);
                {
                this.state = 1045;
                this.traversalMethod_min();
                }
                break;
            case GremlinParser.K_NONE:
                this.enterOuterAlt(localContext, 66);
                {
                this.state = 1046;
                this.traversalMethod_none();
                }
                break;
            case GremlinParser.K_NOT:
                this.enterOuterAlt(localContext, 67);
                {
                this.state = 1047;
                this.traversalMethod_not();
                }
                break;
            case GremlinParser.K_OPTION:
                this.enterOuterAlt(localContext, 68);
                {
                this.state = 1048;
                this.traversalMethod_option();
                }
                break;
            case GremlinParser.K_OPTIONAL:
                this.enterOuterAlt(localContext, 69);
                {
                this.state = 1049;
                this.traversalMethod_optional();
                }
                break;
            case GremlinParser.K_OR:
                this.enterOuterAlt(localContext, 70);
                {
                this.state = 1050;
                this.traversalMethod_or();
                }
                break;
            case GremlinParser.K_ORDER:
                this.enterOuterAlt(localContext, 71);
                {
                this.state = 1051;
                this.traversalMethod_order();
                }
                break;
            case GremlinParser.K_OTHERV:
                this.enterOuterAlt(localContext, 72);
                {
                this.state = 1052;
                this.traversalMethod_otherV();
                }
                break;
            case GremlinParser.K_OUT:
                this.enterOuterAlt(localContext, 73);
                {
                this.state = 1053;
                this.traversalMethod_out();
                }
                break;
            case GremlinParser.K_OUTE:
                this.enterOuterAlt(localContext, 74);
                {
                this.state = 1054;
                this.traversalMethod_outE();
                }
                break;
            case GremlinParser.K_OUTV:
                this.enterOuterAlt(localContext, 75);
                {
                this.state = 1055;
                this.traversalMethod_outV();
                }
                break;
            case GremlinParser.K_PAGERANK:
                this.enterOuterAlt(localContext, 76);
                {
                this.state = 1056;
                this.traversalMethod_pageRank();
                }
                break;
            case GremlinParser.K_PATH:
                this.enterOuterAlt(localContext, 77);
                {
                this.state = 1057;
                this.traversalMethod_path();
                }
                break;
            case GremlinParser.K_PEERPRESSURE:
                this.enterOuterAlt(localContext, 78);
                {
                this.state = 1058;
                this.traversalMethod_peerPressure();
                }
                break;
            case GremlinParser.K_PROFILE:
                this.enterOuterAlt(localContext, 79);
                {
                this.state = 1059;
                this.traversalMethod_profile();
                }
                break;
            case GremlinParser.K_PROJECT:
                this.enterOuterAlt(localContext, 80);
                {
                this.state = 1060;
                this.traversalMethod_project();
                }
                break;
            case GremlinParser.K_PROPERTIES:
                this.enterOuterAlt(localContext, 81);
                {
                this.state = 1061;
                this.traversalMethod_properties();
                }
                break;
            case GremlinParser.K_PROPERTY:
                this.enterOuterAlt(localContext, 82);
                {
                this.state = 1062;
                this.traversalMethod_property();
                }
                break;
            case GremlinParser.K_PROPERTYMAP:
                this.enterOuterAlt(localContext, 83);
                {
                this.state = 1063;
                this.traversalMethod_propertyMap();
                }
                break;
            case GremlinParser.K_RANGE:
                this.enterOuterAlt(localContext, 84);
                {
                this.state = 1064;
                this.traversalMethod_range();
                }
                break;
            case GremlinParser.K_READ:
                this.enterOuterAlt(localContext, 85);
                {
                this.state = 1065;
                this.traversalMethod_read();
                }
                break;
            case GremlinParser.K_REPEAT:
                this.enterOuterAlt(localContext, 86);
                {
                this.state = 1066;
                this.traversalMethod_repeat();
                }
                break;
            case GremlinParser.K_SACK:
                this.enterOuterAlt(localContext, 87);
                {
                this.state = 1067;
                this.traversalMethod_sack();
                }
                break;
            case GremlinParser.K_SAMPLE:
                this.enterOuterAlt(localContext, 88);
                {
                this.state = 1068;
                this.traversalMethod_sample();
                }
                break;
            case GremlinParser.K_SELECT:
                this.enterOuterAlt(localContext, 89);
                {
                this.state = 1069;
                this.traversalMethod_select();
                }
                break;
            case GremlinParser.K_COMBINE:
                this.enterOuterAlt(localContext, 90);
                {
                this.state = 1070;
                this.traversalMethod_combine();
                }
                break;
            case GremlinParser.K_PRODUCT:
                this.enterOuterAlt(localContext, 91);
                {
                this.state = 1071;
                this.traversalMethod_product();
                }
                break;
            case GremlinParser.K_MERGE:
                this.enterOuterAlt(localContext, 92);
                {
                this.state = 1072;
                this.traversalMethod_merge();
                }
                break;
            case GremlinParser.K_SHORTESTPATH:
                this.enterOuterAlt(localContext, 93);
                {
                this.state = 1073;
                this.traversalMethod_shortestPath();
                }
                break;
            case GremlinParser.K_SIDEEFFECT:
                this.enterOuterAlt(localContext, 94);
                {
                this.state = 1074;
                this.traversalMethod_sideEffect();
                }
                break;
            case GremlinParser.K_SIMPLEPATH:
                this.enterOuterAlt(localContext, 95);
                {
                this.state = 1075;
                this.traversalMethod_simplePath();
                }
                break;
            case GremlinParser.K_SKIP:
                this.enterOuterAlt(localContext, 96);
                {
                this.state = 1076;
                this.traversalMethod_skip();
                }
                break;
            case GremlinParser.K_SUBGRAPH:
                this.enterOuterAlt(localContext, 97);
                {
                this.state = 1077;
                this.traversalMethod_subgraph();
                }
                break;
            case GremlinParser.K_SUM:
                this.enterOuterAlt(localContext, 98);
                {
                this.state = 1078;
                this.traversalMethod_sum();
                }
                break;
            case GremlinParser.K_TAIL:
                this.enterOuterAlt(localContext, 99);
                {
                this.state = 1079;
                this.traversalMethod_tail();
                }
                break;
            case GremlinParser.K_FAIL:
                this.enterOuterAlt(localContext, 100);
                {
                this.state = 1080;
                this.traversalMethod_fail();
                }
                break;
            case GremlinParser.K_TIMELIMIT:
                this.enterOuterAlt(localContext, 101);
                {
                this.state = 1081;
                this.traversalMethod_timeLimit();
                }
                break;
            case GremlinParser.K_TIMES:
                this.enterOuterAlt(localContext, 102);
                {
                this.state = 1082;
                this.traversalMethod_times();
                }
                break;
            case GremlinParser.K_TO:
                this.enterOuterAlt(localContext, 103);
                {
                this.state = 1083;
                this.traversalMethod_to();
                }
                break;
            case GremlinParser.K_TOE:
                this.enterOuterAlt(localContext, 104);
                {
                this.state = 1084;
                this.traversalMethod_toE();
                }
                break;
            case GremlinParser.K_TOV:
                this.enterOuterAlt(localContext, 105);
                {
                this.state = 1085;
                this.traversalMethod_toV();
                }
                break;
            case GremlinParser.K_TREE:
                this.enterOuterAlt(localContext, 106);
                {
                this.state = 1086;
                this.traversalMethod_tree();
                }
                break;
            case GremlinParser.K_UNFOLD:
                this.enterOuterAlt(localContext, 107);
                {
                this.state = 1087;
                this.traversalMethod_unfold();
                }
                break;
            case GremlinParser.K_UNION:
                this.enterOuterAlt(localContext, 108);
                {
                this.state = 1088;
                this.traversalMethod_union();
                }
                break;
            case GremlinParser.K_UNTIL:
                this.enterOuterAlt(localContext, 109);
                {
                this.state = 1089;
                this.traversalMethod_until();
                }
                break;
            case GremlinParser.K_VALUE:
                this.enterOuterAlt(localContext, 110);
                {
                this.state = 1090;
                this.traversalMethod_value();
                }
                break;
            case GremlinParser.K_VALUEMAP:
                this.enterOuterAlt(localContext, 111);
                {
                this.state = 1091;
                this.traversalMethod_valueMap();
                }
                break;
            case GremlinParser.K_VALUES:
                this.enterOuterAlt(localContext, 112);
                {
                this.state = 1092;
                this.traversalMethod_values();
                }
                break;
            case GremlinParser.K_WHERE:
                this.enterOuterAlt(localContext, 113);
                {
                this.state = 1093;
                this.traversalMethod_where();
                }
                break;
            case GremlinParser.K_WITH:
                this.enterOuterAlt(localContext, 114);
                {
                this.state = 1094;
                this.traversalMethod_with();
                }
                break;
            case GremlinParser.K_WRITE:
                this.enterOuterAlt(localContext, 115);
                {
                this.state = 1095;
                this.traversalMethod_write();
                }
                break;
            case GremlinParser.K_ELEMENT:
                this.enterOuterAlt(localContext, 116);
                {
                this.state = 1096;
                this.traversalMethod_element();
                }
                break;
            case GremlinParser.K_CALL:
                this.enterOuterAlt(localContext, 117);
                {
                this.state = 1097;
                this.traversalMethod_call();
                }
                break;
            case GremlinParser.K_CONCAT:
                this.enterOuterAlt(localContext, 118);
                {
                this.state = 1098;
                this.traversalMethod_concat();
                }
                break;
            case GremlinParser.K_ASSTRING:
                this.enterOuterAlt(localContext, 119);
                {
                this.state = 1099;
                this.traversalMethod_asString();
                }
                break;
            case GremlinParser.K_FORMAT:
                this.enterOuterAlt(localContext, 120);
                {
                this.state = 1100;
                this.traversalMethod_format();
                }
                break;
            case GremlinParser.K_TOUPPER:
                this.enterOuterAlt(localContext, 121);
                {
                this.state = 1101;
                this.traversalMethod_toUpper();
                }
                break;
            case GremlinParser.K_TOLOWER:
                this.enterOuterAlt(localContext, 122);
                {
                this.state = 1102;
                this.traversalMethod_toLower();
                }
                break;
            case GremlinParser.K_LENGTH:
                this.enterOuterAlt(localContext, 123);
                {
                this.state = 1103;
                this.traversalMethod_length();
                }
                break;
            case GremlinParser.K_TRIM:
                this.enterOuterAlt(localContext, 124);
                {
                this.state = 1104;
                this.traversalMethod_trim();
                }
                break;
            case GremlinParser.K_LTRIM:
                this.enterOuterAlt(localContext, 125);
                {
                this.state = 1105;
                this.traversalMethod_lTrim();
                }
                break;
            case GremlinParser.K_RTRIM:
                this.enterOuterAlt(localContext, 126);
                {
                this.state = 1106;
                this.traversalMethod_rTrim();
                }
                break;
            case GremlinParser.K_REVERSE:
                this.enterOuterAlt(localContext, 127);
                {
                this.state = 1107;
                this.traversalMethod_reverse();
                }
                break;
            case GremlinParser.K_REPLACE:
                this.enterOuterAlt(localContext, 128);
                {
                this.state = 1108;
                this.traversalMethod_replace();
                }
                break;
            case GremlinParser.K_SPLIT:
                this.enterOuterAlt(localContext, 129);
                {
                this.state = 1109;
                this.traversalMethod_split();
                }
                break;
            case GremlinParser.K_SUBSTRING:
                this.enterOuterAlt(localContext, 130);
                {
                this.state = 1110;
                this.traversalMethod_substring();
                }
                break;
            case GremlinParser.K_ASBOOL:
                this.enterOuterAlt(localContext, 131);
                {
                this.state = 1111;
                this.traversalMethod_asBool();
                }
                break;
            case GremlinParser.K_ASDATE:
                this.enterOuterAlt(localContext, 132);
                {
                this.state = 1112;
                this.traversalMethod_asDate();
                }
                break;
            case GremlinParser.K_DATEADD:
                this.enterOuterAlt(localContext, 133);
                {
                this.state = 1113;
                this.traversalMethod_dateAdd();
                }
                break;
            case GremlinParser.K_DATEDIFF:
                this.enterOuterAlt(localContext, 134);
                {
                this.state = 1114;
                this.traversalMethod_dateDiff();
                }
                break;
            case GremlinParser.K_ASNUMBER:
                this.enterOuterAlt(localContext, 135);
                {
                this.state = 1115;
                this.traversalMethod_asNumber();
                }
                break;
            case GremlinParser.K_LABELS:
                this.enterOuterAlt(localContext, 136);
                {
                this.state = 1116;
                this.traversalMethod_labels();
                }
                break;
            case GremlinParser.K_ADDLABEL:
                this.enterOuterAlt(localContext, 137);
                {
                this.state = 1117;
                this.traversalMethod_addLabel();
                }
                break;
            case GremlinParser.K_DROPLABELS:
                this.enterOuterAlt(localContext, 138);
                {
                this.state = 1118;
                this.traversalMethod_dropLabels();
                }
                break;
            case GremlinParser.K_DROPLABEL:
                this.enterOuterAlt(localContext, 139);
                {
                this.state = 1119;
                this.traversalMethod_dropLabel();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_V(): TraversalMethod_VContext {
        let localContext = new TraversalMethod_VContext(this.context, this.state);
        this.enterRule(localContext, 60, GremlinParser.RULE_traversalMethod_V);
        try {
            this.state = 1132;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 28, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1122;
                this.match(GremlinParser.K_V);
                this.state = 1123;
                this.match(GremlinParser.LPAREN);
                this.state = 1124;
                this.genericArgumentVarargs();
                this.state = 1125;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1127;
                this.match(GremlinParser.K_V);
                this.state = 1128;
                this.match(GremlinParser.LPAREN);
                this.state = 1129;
                this.nestedTraversal();
                this.state = 1130;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_E(): TraversalMethod_EContext {
        let localContext = new TraversalMethod_EContext(this.context, this.state);
        this.enterRule(localContext, 62, GremlinParser.RULE_traversalMethod_E);
        try {
            this.state = 1144;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 29, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1134;
                this.match(GremlinParser.K_E);
                this.state = 1135;
                this.match(GremlinParser.LPAREN);
                this.state = 1136;
                this.genericArgumentVarargs();
                this.state = 1137;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1139;
                this.match(GremlinParser.K_E);
                this.state = 1140;
                this.match(GremlinParser.LPAREN);
                this.state = 1141;
                this.nestedTraversal();
                this.state = 1142;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_addE(): TraversalMethod_addEContext {
        let localContext = new TraversalMethod_addEContext(this.context, this.state);
        this.enterRule(localContext, 64, GremlinParser.RULE_traversalMethod_addE);
        try {
            this.state = 1156;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 30, this.context) ) {
            case 1:
                localContext = new TraversalMethod_addE_StringContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1146;
                this.match(GremlinParser.K_ADDE);
                this.state = 1147;
                this.match(GremlinParser.LPAREN);
                this.state = 1148;
                this.stringArgument();
                this.state = 1149;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_addE_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1151;
                this.match(GremlinParser.K_ADDE);
                this.state = 1152;
                this.match(GremlinParser.LPAREN);
                this.state = 1153;
                this.nestedTraversal();
                this.state = 1154;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_addV(): TraversalMethod_addVContext {
        let localContext = new TraversalMethod_addVContext(this.context, this.state);
        this.enterRule(localContext, 66, GremlinParser.RULE_traversalMethod_addV);
        let _la: number;
        try {
            this.state = 1178;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 32, this.context) ) {
            case 1:
                localContext = new TraversalMethod_addV_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1158;
                this.match(GremlinParser.K_ADDV);
                this.state = 1159;
                this.match(GremlinParser.LPAREN);
                this.state = 1160;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_addV_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1161;
                this.match(GremlinParser.K_ADDV);
                this.state = 1162;
                this.match(GremlinParser.LPAREN);
                this.state = 1163;
                this.stringArgumentVarargs();
                this.state = 1164;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_addV_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1166;
                this.match(GremlinParser.K_ADDV);
                this.state = 1167;
                this.match(GremlinParser.LPAREN);
                this.state = 1168;
                this.nestedTraversal();
                this.state = 1173;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 320) {
                    {
                    {
                    this.state = 1169;
                    this.match(GremlinParser.COMMA);
                    this.state = 1170;
                    this.nestedTraversal();
                    }
                    }
                    this.state = 1175;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 1176;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_aggregate(): TraversalMethod_aggregateContext {
        let localContext = new TraversalMethod_aggregateContext(this.context, this.state);
        this.enterRule(localContext, 68, GremlinParser.RULE_traversalMethod_aggregate);
        try {
            localContext = new TraversalMethod_aggregate_StringContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1180;
            this.match(GremlinParser.K_AGGREGATE);
            this.state = 1181;
            this.match(GremlinParser.LPAREN);
            this.state = 1182;
            this.stringLiteral();
            this.state = 1183;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_all(): TraversalMethod_allContext {
        let localContext = new TraversalMethod_allContext(this.context, this.state);
        this.enterRule(localContext, 70, GremlinParser.RULE_traversalMethod_all);
        try {
            localContext = new TraversalMethod_all_PContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1185;
            this.match(GremlinParser.K_ALL);
            this.state = 1186;
            this.match(GremlinParser.LPAREN);
            this.state = 1187;
            this.traversalPredicate(0);
            this.state = 1188;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_and(): TraversalMethod_andContext {
        let localContext = new TraversalMethod_andContext(this.context, this.state);
        this.enterRule(localContext, 72, GremlinParser.RULE_traversalMethod_and);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1190;
            this.match(GremlinParser.K_AND);
            this.state = 1191;
            this.match(GremlinParser.LPAREN);
            this.state = 1192;
            this.nestedTraversalList();
            this.state = 1193;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_any(): TraversalMethod_anyContext {
        let localContext = new TraversalMethod_anyContext(this.context, this.state);
        this.enterRule(localContext, 74, GremlinParser.RULE_traversalMethod_any);
        try {
            localContext = new TraversalMethod_any_PContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1195;
            this.match(GremlinParser.K_ANY);
            this.state = 1196;
            this.match(GremlinParser.LPAREN);
            this.state = 1197;
            this.traversalPredicate(0);
            this.state = 1198;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_as(): TraversalMethod_asContext {
        let localContext = new TraversalMethod_asContext(this.context, this.state);
        this.enterRule(localContext, 76, GremlinParser.RULE_traversalMethod_as);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1200;
            this.match(GremlinParser.K_AS);
            this.state = 1201;
            this.match(GremlinParser.LPAREN);
            this.state = 1202;
            this.stringLiteral();
            this.state = 1205;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 320) {
                {
                this.state = 1203;
                this.match(GremlinParser.COMMA);
                this.state = 1204;
                this.stringNullableLiteralVarargs();
                }
            }

            this.state = 1207;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_asBool(): TraversalMethod_asBoolContext {
        let localContext = new TraversalMethod_asBoolContext(this.context, this.state);
        this.enterRule(localContext, 78, GremlinParser.RULE_traversalMethod_asBool);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1209;
            this.match(GremlinParser.K_ASBOOL);
            this.state = 1210;
            this.match(GremlinParser.LPAREN);
            this.state = 1211;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_asDate(): TraversalMethod_asDateContext {
        let localContext = new TraversalMethod_asDateContext(this.context, this.state);
        this.enterRule(localContext, 80, GremlinParser.RULE_traversalMethod_asDate);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1213;
            this.match(GremlinParser.K_ASDATE);
            this.state = 1214;
            this.match(GremlinParser.LPAREN);
            this.state = 1215;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_asNumber(): TraversalMethod_asNumberContext {
        let localContext = new TraversalMethod_asNumberContext(this.context, this.state);
        this.enterRule(localContext, 82, GremlinParser.RULE_traversalMethod_asNumber);
        try {
            this.state = 1225;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 34, this.context) ) {
            case 1:
                localContext = new TraversalMethod_asNumber_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1217;
                this.match(GremlinParser.K_ASNUMBER);
                this.state = 1218;
                this.match(GremlinParser.LPAREN);
                this.state = 1219;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_asNumber_traversalGTypeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1220;
                this.match(GremlinParser.K_ASNUMBER);
                this.state = 1221;
                this.match(GremlinParser.LPAREN);
                this.state = 1222;
                this.traversalGType();
                this.state = 1223;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_asString(): TraversalMethod_asStringContext {
        let localContext = new TraversalMethod_asStringContext(this.context, this.state);
        this.enterRule(localContext, 84, GremlinParser.RULE_traversalMethod_asString);
        try {
            this.state = 1235;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 35, this.context) ) {
            case 1:
                localContext = new TraversalMethod_asString_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1227;
                this.match(GremlinParser.K_ASSTRING);
                this.state = 1228;
                this.match(GremlinParser.LPAREN);
                this.state = 1229;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_asString_ScopeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1230;
                this.match(GremlinParser.K_ASSTRING);
                this.state = 1231;
                this.match(GremlinParser.LPAREN);
                this.state = 1232;
                this.traversalScope();
                this.state = 1233;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_barrier(): TraversalMethod_barrierContext {
        let localContext = new TraversalMethod_barrierContext(this.context, this.state);
        this.enterRule(localContext, 86, GremlinParser.RULE_traversalMethod_barrier);
        try {
            this.state = 1250;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 36, this.context) ) {
            case 1:
                localContext = new TraversalMethod_barrier_ConsumerContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1237;
                this.match(GremlinParser.K_BARRIER);
                this.state = 1238;
                this.match(GremlinParser.LPAREN);
                this.state = 1239;
                this.traversalSackMethod();
                this.state = 1240;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_barrier_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1242;
                this.match(GremlinParser.K_BARRIER);
                this.state = 1243;
                this.match(GremlinParser.LPAREN);
                this.state = 1244;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_barrier_intContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1245;
                this.match(GremlinParser.K_BARRIER);
                this.state = 1246;
                this.match(GremlinParser.LPAREN);
                this.state = 1247;
                this.integerLiteral();
                this.state = 1248;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_both(): TraversalMethod_bothContext {
        let localContext = new TraversalMethod_bothContext(this.context, this.state);
        this.enterRule(localContext, 88, GremlinParser.RULE_traversalMethod_both);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1252;
            this.match(GremlinParser.K_BOTH);
            this.state = 1253;
            this.match(GremlinParser.LPAREN);
            this.state = 1254;
            this.stringNullableArgumentVarargs();
            this.state = 1255;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_bothE(): TraversalMethod_bothEContext {
        let localContext = new TraversalMethod_bothEContext(this.context, this.state);
        this.enterRule(localContext, 90, GremlinParser.RULE_traversalMethod_bothE);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1257;
            this.match(GremlinParser.K_BOTHE);
            this.state = 1258;
            this.match(GremlinParser.LPAREN);
            this.state = 1259;
            this.stringNullableArgumentVarargs();
            this.state = 1260;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_bothV(): TraversalMethod_bothVContext {
        let localContext = new TraversalMethod_bothVContext(this.context, this.state);
        this.enterRule(localContext, 92, GremlinParser.RULE_traversalMethod_bothV);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1262;
            this.match(GremlinParser.K_BOTHV);
            this.state = 1263;
            this.match(GremlinParser.LPAREN);
            this.state = 1264;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_branch(): TraversalMethod_branchContext {
        let localContext = new TraversalMethod_branchContext(this.context, this.state);
        this.enterRule(localContext, 94, GremlinParser.RULE_traversalMethod_branch);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1266;
            this.match(GremlinParser.K_BRANCH);
            this.state = 1267;
            this.match(GremlinParser.LPAREN);
            this.state = 1268;
            this.nestedTraversal();
            this.state = 1269;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_by(): TraversalMethod_byContext {
        let localContext = new TraversalMethod_byContext(this.context, this.state);
        this.enterRule(localContext, 96, GremlinParser.RULE_traversalMethod_by);
        try {
            this.state = 1325;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 37, this.context) ) {
            case 1:
                localContext = new TraversalMethod_by_ComparatorContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1271;
                this.match(GremlinParser.K_BY);
                this.state = 1272;
                this.match(GremlinParser.LPAREN);
                this.state = 1273;
                this.traversalComparator();
                this.state = 1274;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_by_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1276;
                this.match(GremlinParser.K_BY);
                this.state = 1277;
                this.match(GremlinParser.LPAREN);
                this.state = 1278;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_by_FunctionContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1279;
                this.match(GremlinParser.K_BY);
                this.state = 1280;
                this.match(GremlinParser.LPAREN);
                this.state = 1281;
                this.traversalFunction();
                this.state = 1282;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 4:
                localContext = new TraversalMethod_by_Function_ComparatorContext(localContext);
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1284;
                this.match(GremlinParser.K_BY);
                this.state = 1285;
                this.match(GremlinParser.LPAREN);
                this.state = 1286;
                this.traversalFunction();
                this.state = 1287;
                this.match(GremlinParser.COMMA);
                this.state = 1288;
                this.traversalComparator();
                this.state = 1289;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 5:
                localContext = new TraversalMethod_by_OrderContext(localContext);
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 1291;
                this.match(GremlinParser.K_BY);
                this.state = 1292;
                this.match(GremlinParser.LPAREN);
                this.state = 1293;
                this.traversalOrder();
                this.state = 1294;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 6:
                localContext = new TraversalMethod_by_StringContext(localContext);
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 1296;
                this.match(GremlinParser.K_BY);
                this.state = 1297;
                this.match(GremlinParser.LPAREN);
                this.state = 1298;
                this.stringLiteral();
                this.state = 1299;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 7:
                localContext = new TraversalMethod_by_String_ComparatorContext(localContext);
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 1301;
                this.match(GremlinParser.K_BY);
                this.state = 1302;
                this.match(GremlinParser.LPAREN);
                this.state = 1303;
                this.stringLiteral();
                this.state = 1304;
                this.match(GremlinParser.COMMA);
                this.state = 1305;
                this.traversalComparator();
                this.state = 1306;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 8:
                localContext = new TraversalMethod_by_TContext(localContext);
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 1308;
                this.match(GremlinParser.K_BY);
                this.state = 1309;
                this.match(GremlinParser.LPAREN);
                this.state = 1310;
                this.traversalT();
                this.state = 1311;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 9:
                localContext = new TraversalMethod_by_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 1313;
                this.match(GremlinParser.K_BY);
                this.state = 1314;
                this.match(GremlinParser.LPAREN);
                this.state = 1315;
                this.nestedTraversal();
                this.state = 1316;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 10:
                localContext = new TraversalMethod_by_Traversal_ComparatorContext(localContext);
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 1318;
                this.match(GremlinParser.K_BY);
                this.state = 1319;
                this.match(GremlinParser.LPAREN);
                this.state = 1320;
                this.nestedTraversal();
                this.state = 1321;
                this.match(GremlinParser.COMMA);
                this.state = 1322;
                this.traversalComparator();
                this.state = 1323;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_call(): TraversalMethod_callContext {
        let localContext = new TraversalMethod_callContext(this.context, this.state);
        this.enterRule(localContext, 98, GremlinParser.RULE_traversalMethod_call);
        try {
            this.state = 1355;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 38, this.context) ) {
            case 1:
                localContext = new TraversalMethod_call_stringContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1327;
                this.match(GremlinParser.K_CALL);
                this.state = 1328;
                this.match(GremlinParser.LPAREN);
                this.state = 1329;
                this.stringLiteral();
                this.state = 1330;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_call_string_mapContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1332;
                this.match(GremlinParser.K_CALL);
                this.state = 1333;
                this.match(GremlinParser.LPAREN);
                this.state = 1334;
                this.stringLiteral();
                this.state = 1335;
                this.match(GremlinParser.COMMA);
                this.state = 1336;
                this.genericMapArgument();
                this.state = 1337;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_call_string_traversalContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1339;
                this.match(GremlinParser.K_CALL);
                this.state = 1340;
                this.match(GremlinParser.LPAREN);
                this.state = 1341;
                this.stringLiteral();
                this.state = 1342;
                this.match(GremlinParser.COMMA);
                this.state = 1343;
                this.nestedTraversal();
                this.state = 1344;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 4:
                localContext = new TraversalMethod_call_string_map_traversalContext(localContext);
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1346;
                this.match(GremlinParser.K_CALL);
                this.state = 1347;
                this.match(GremlinParser.LPAREN);
                this.state = 1348;
                this.stringLiteral();
                this.state = 1349;
                this.match(GremlinParser.COMMA);
                this.state = 1350;
                this.genericMapArgument();
                this.state = 1351;
                this.match(GremlinParser.COMMA);
                this.state = 1352;
                this.nestedTraversal();
                this.state = 1353;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_cap(): TraversalMethod_capContext {
        let localContext = new TraversalMethod_capContext(this.context, this.state);
        this.enterRule(localContext, 100, GremlinParser.RULE_traversalMethod_cap);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1357;
            this.match(GremlinParser.K_CAP);
            this.state = 1358;
            this.match(GremlinParser.LPAREN);
            this.state = 1359;
            this.stringLiteral();
            this.state = 1362;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 320) {
                {
                this.state = 1360;
                this.match(GremlinParser.COMMA);
                this.state = 1361;
                this.stringNullableLiteralVarargs();
                }
            }

            this.state = 1364;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_choose(): TraversalMethod_chooseContext {
        let localContext = new TraversalMethod_chooseContext(this.context, this.state);
        this.enterRule(localContext, 102, GremlinParser.RULE_traversalMethod_choose);
        try {
            this.state = 1408;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 40, this.context) ) {
            case 1:
                localContext = new TraversalMethod_choose_FunctionContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1366;
                this.match(GremlinParser.K_CHOOSE);
                this.state = 1367;
                this.match(GremlinParser.LPAREN);
                this.state = 1368;
                this.traversalFunction();
                this.state = 1369;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_choose_Predicate_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1371;
                this.match(GremlinParser.K_CHOOSE);
                this.state = 1372;
                this.match(GremlinParser.LPAREN);
                this.state = 1373;
                this.traversalPredicate(0);
                this.state = 1374;
                this.match(GremlinParser.COMMA);
                this.state = 1375;
                this.nestedTraversal();
                this.state = 1376;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_choose_Predicate_Traversal_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1378;
                this.match(GremlinParser.K_CHOOSE);
                this.state = 1379;
                this.match(GremlinParser.LPAREN);
                this.state = 1380;
                this.traversalPredicate(0);
                this.state = 1381;
                this.match(GremlinParser.COMMA);
                this.state = 1382;
                this.nestedTraversal();
                this.state = 1383;
                this.match(GremlinParser.COMMA);
                this.state = 1384;
                this.nestedTraversal();
                this.state = 1385;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 4:
                localContext = new TraversalMethod_choose_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1387;
                this.match(GremlinParser.K_CHOOSE);
                this.state = 1388;
                this.match(GremlinParser.LPAREN);
                this.state = 1389;
                this.nestedTraversal();
                this.state = 1390;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 5:
                localContext = new TraversalMethod_choose_Traversal_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 1392;
                this.match(GremlinParser.K_CHOOSE);
                this.state = 1393;
                this.match(GremlinParser.LPAREN);
                this.state = 1394;
                this.nestedTraversal();
                this.state = 1395;
                this.match(GremlinParser.COMMA);
                this.state = 1396;
                this.nestedTraversal();
                this.state = 1397;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 6:
                localContext = new TraversalMethod_choose_Traversal_Traversal_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 1399;
                this.match(GremlinParser.K_CHOOSE);
                this.state = 1400;
                this.match(GremlinParser.LPAREN);
                this.state = 1401;
                this.nestedTraversal();
                this.state = 1402;
                this.match(GremlinParser.COMMA);
                this.state = 1403;
                this.nestedTraversal();
                this.state = 1404;
                this.match(GremlinParser.COMMA);
                this.state = 1405;
                this.nestedTraversal();
                this.state = 1406;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_coalesce(): TraversalMethod_coalesceContext {
        let localContext = new TraversalMethod_coalesceContext(this.context, this.state);
        this.enterRule(localContext, 104, GremlinParser.RULE_traversalMethod_coalesce);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1410;
            this.match(GremlinParser.K_COALESCE);
            this.state = 1411;
            this.match(GremlinParser.LPAREN);
            this.state = 1412;
            this.nestedTraversalList();
            this.state = 1413;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_coin(): TraversalMethod_coinContext {
        let localContext = new TraversalMethod_coinContext(this.context, this.state);
        this.enterRule(localContext, 106, GremlinParser.RULE_traversalMethod_coin);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1415;
            this.match(GremlinParser.K_COIN);
            this.state = 1416;
            this.match(GremlinParser.LPAREN);
            this.state = 1417;
            this.numericLiteral();
            this.state = 1418;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_combine(): TraversalMethod_combineContext {
        let localContext = new TraversalMethod_combineContext(this.context, this.state);
        this.enterRule(localContext, 108, GremlinParser.RULE_traversalMethod_combine);
        try {
            localContext = new TraversalMethod_combine_ObjectContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1420;
            this.match(GremlinParser.K_COMBINE);
            this.state = 1421;
            this.match(GremlinParser.LPAREN);
            this.state = 1422;
            this.genericLiteral();
            this.state = 1423;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_concat(): TraversalMethod_concatContext {
        let localContext = new TraversalMethod_concatContext(this.context, this.state);
        this.enterRule(localContext, 110, GremlinParser.RULE_traversalMethod_concat);
        let _la: number;
        try {
            this.state = 1439;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 42, this.context) ) {
            case 1:
                localContext = new TraversalMethod_concat_Traversal_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1425;
                this.match(GremlinParser.K_CONCAT);
                this.state = 1426;
                this.match(GremlinParser.LPAREN);
                this.state = 1427;
                this.nestedTraversal();
                this.state = 1430;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 320) {
                    {
                    this.state = 1428;
                    this.match(GremlinParser.COMMA);
                    this.state = 1429;
                    this.nestedTraversalList();
                    }
                }

                this.state = 1432;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_concat_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1434;
                this.match(GremlinParser.K_CONCAT);
                this.state = 1435;
                this.match(GremlinParser.LPAREN);
                this.state = 1436;
                this.stringNullableLiteralVarargs();
                this.state = 1437;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_conjoin(): TraversalMethod_conjoinContext {
        let localContext = new TraversalMethod_conjoinContext(this.context, this.state);
        this.enterRule(localContext, 112, GremlinParser.RULE_traversalMethod_conjoin);
        try {
            localContext = new TraversalMethod_conjoin_StringContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1441;
            this.match(GremlinParser.K_CONJOIN);
            this.state = 1442;
            this.match(GremlinParser.LPAREN);
            this.state = 1443;
            this.stringLiteral();
            this.state = 1444;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_connectedComponent(): TraversalMethod_connectedComponentContext {
        let localContext = new TraversalMethod_connectedComponentContext(this.context, this.state);
        this.enterRule(localContext, 114, GremlinParser.RULE_traversalMethod_connectedComponent);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1446;
            this.match(GremlinParser.K_CONNECTEDCOMPONENT);
            this.state = 1447;
            this.match(GremlinParser.LPAREN);
            this.state = 1448;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_constant(): TraversalMethod_constantContext {
        let localContext = new TraversalMethod_constantContext(this.context, this.state);
        this.enterRule(localContext, 116, GremlinParser.RULE_traversalMethod_constant);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1450;
            this.match(GremlinParser.K_CONSTANT);
            this.state = 1451;
            this.match(GremlinParser.LPAREN);
            this.state = 1452;
            this.genericLiteral();
            this.state = 1453;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_count(): TraversalMethod_countContext {
        let localContext = new TraversalMethod_countContext(this.context, this.state);
        this.enterRule(localContext, 118, GremlinParser.RULE_traversalMethod_count);
        try {
            this.state = 1463;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 43, this.context) ) {
            case 1:
                localContext = new TraversalMethod_count_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1455;
                this.match(GremlinParser.K_COUNT);
                this.state = 1456;
                this.match(GremlinParser.LPAREN);
                this.state = 1457;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_count_ScopeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1458;
                this.match(GremlinParser.K_COUNT);
                this.state = 1459;
                this.match(GremlinParser.LPAREN);
                this.state = 1460;
                this.traversalScope();
                this.state = 1461;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_cyclicPath(): TraversalMethod_cyclicPathContext {
        let localContext = new TraversalMethod_cyclicPathContext(this.context, this.state);
        this.enterRule(localContext, 120, GremlinParser.RULE_traversalMethod_cyclicPath);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1465;
            this.match(GremlinParser.K_CYCLICPATH);
            this.state = 1466;
            this.match(GremlinParser.LPAREN);
            this.state = 1467;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_dateAdd(): TraversalMethod_dateAddContext {
        let localContext = new TraversalMethod_dateAddContext(this.context, this.state);
        this.enterRule(localContext, 122, GremlinParser.RULE_traversalMethod_dateAdd);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1469;
            this.match(GremlinParser.K_DATEADD);
            this.state = 1470;
            this.match(GremlinParser.LPAREN);
            this.state = 1471;
            this.traversalDT();
            this.state = 1472;
            this.match(GremlinParser.COMMA);
            this.state = 1473;
            this.integerLiteral();
            this.state = 1474;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_dateDiff(): TraversalMethod_dateDiffContext {
        let localContext = new TraversalMethod_dateDiffContext(this.context, this.state);
        this.enterRule(localContext, 124, GremlinParser.RULE_traversalMethod_dateDiff);
        try {
            this.state = 1486;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 44, this.context) ) {
            case 1:
                localContext = new TraversalMethod_dateDiff_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1476;
                this.match(GremlinParser.K_DATEDIFF);
                this.state = 1477;
                this.match(GremlinParser.LPAREN);
                this.state = 1478;
                this.nestedTraversal();
                this.state = 1479;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_dateDiff_DateContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1481;
                this.match(GremlinParser.K_DATEDIFF);
                this.state = 1482;
                this.match(GremlinParser.LPAREN);
                this.state = 1483;
                this.dateLiteral();
                this.state = 1484;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_dedup(): TraversalMethod_dedupContext {
        let localContext = new TraversalMethod_dedupContext(this.context, this.state);
        this.enterRule(localContext, 126, GremlinParser.RULE_traversalMethod_dedup);
        let _la: number;
        try {
            this.state = 1502;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 46, this.context) ) {
            case 1:
                localContext = new TraversalMethod_dedup_Scope_StringContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1488;
                this.match(GremlinParser.K_DEDUP);
                this.state = 1489;
                this.match(GremlinParser.LPAREN);
                this.state = 1490;
                this.traversalScope();
                this.state = 1493;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 320) {
                    {
                    this.state = 1491;
                    this.match(GremlinParser.COMMA);
                    this.state = 1492;
                    this.stringNullableLiteralVarargs();
                    }
                }

                this.state = 1495;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_dedup_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1497;
                this.match(GremlinParser.K_DEDUP);
                this.state = 1498;
                this.match(GremlinParser.LPAREN);
                this.state = 1499;
                this.stringNullableLiteralVarargs();
                this.state = 1500;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_difference(): TraversalMethod_differenceContext {
        let localContext = new TraversalMethod_differenceContext(this.context, this.state);
        this.enterRule(localContext, 128, GremlinParser.RULE_traversalMethod_difference);
        try {
            localContext = new TraversalMethod_difference_ObjectContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1504;
            this.match(GremlinParser.K_DIFFERENCE);
            this.state = 1505;
            this.match(GremlinParser.LPAREN);
            this.state = 1506;
            this.genericLiteral();
            this.state = 1507;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_discard(): TraversalMethod_discardContext {
        let localContext = new TraversalMethod_discardContext(this.context, this.state);
        this.enterRule(localContext, 130, GremlinParser.RULE_traversalMethod_discard);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1509;
            this.match(GremlinParser.K_DISCARD);
            this.state = 1510;
            this.match(GremlinParser.LPAREN);
            this.state = 1511;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_disjunct(): TraversalMethod_disjunctContext {
        let localContext = new TraversalMethod_disjunctContext(this.context, this.state);
        this.enterRule(localContext, 132, GremlinParser.RULE_traversalMethod_disjunct);
        try {
            localContext = new TraversalMethod_disjunct_ObjectContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1513;
            this.match(GremlinParser.K_DISJUNCT);
            this.state = 1514;
            this.match(GremlinParser.LPAREN);
            this.state = 1515;
            this.genericLiteral();
            this.state = 1516;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_drop(): TraversalMethod_dropContext {
        let localContext = new TraversalMethod_dropContext(this.context, this.state);
        this.enterRule(localContext, 134, GremlinParser.RULE_traversalMethod_drop);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1518;
            this.match(GremlinParser.K_DROP);
            this.state = 1519;
            this.match(GremlinParser.LPAREN);
            this.state = 1520;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_element(): TraversalMethod_elementContext {
        let localContext = new TraversalMethod_elementContext(this.context, this.state);
        this.enterRule(localContext, 136, GremlinParser.RULE_traversalMethod_element);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1522;
            this.match(GremlinParser.K_ELEMENT);
            this.state = 1523;
            this.match(GremlinParser.LPAREN);
            this.state = 1524;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_elementMap(): TraversalMethod_elementMapContext {
        let localContext = new TraversalMethod_elementMapContext(this.context, this.state);
        this.enterRule(localContext, 138, GremlinParser.RULE_traversalMethod_elementMap);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1526;
            this.match(GremlinParser.K_ELEMENTMAP);
            this.state = 1527;
            this.match(GremlinParser.LPAREN);
            this.state = 1528;
            this.stringNullableLiteralVarargs();
            this.state = 1529;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_emit(): TraversalMethod_emitContext {
        let localContext = new TraversalMethod_emitContext(this.context, this.state);
        this.enterRule(localContext, 140, GremlinParser.RULE_traversalMethod_emit);
        try {
            this.state = 1544;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 47, this.context) ) {
            case 1:
                localContext = new TraversalMethod_emit_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1531;
                this.match(GremlinParser.K_EMIT);
                this.state = 1532;
                this.match(GremlinParser.LPAREN);
                this.state = 1533;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_emit_PredicateContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1534;
                this.match(GremlinParser.K_EMIT);
                this.state = 1535;
                this.match(GremlinParser.LPAREN);
                this.state = 1536;
                this.traversalPredicate(0);
                this.state = 1537;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_emit_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1539;
                this.match(GremlinParser.K_EMIT);
                this.state = 1540;
                this.match(GremlinParser.LPAREN);
                this.state = 1541;
                this.nestedTraversal();
                this.state = 1542;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_fail(): TraversalMethod_failContext {
        let localContext = new TraversalMethod_failContext(this.context, this.state);
        this.enterRule(localContext, 142, GremlinParser.RULE_traversalMethod_fail);
        try {
            this.state = 1554;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 48, this.context) ) {
            case 1:
                localContext = new TraversalMethod_fail_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1546;
                this.match(GremlinParser.K_FAIL);
                this.state = 1547;
                this.match(GremlinParser.LPAREN);
                this.state = 1548;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_fail_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1549;
                this.match(GremlinParser.K_FAIL);
                this.state = 1550;
                this.match(GremlinParser.LPAREN);
                this.state = 1551;
                this.stringLiteral();
                this.state = 1552;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_filter(): TraversalMethod_filterContext {
        let localContext = new TraversalMethod_filterContext(this.context, this.state);
        this.enterRule(localContext, 144, GremlinParser.RULE_traversalMethod_filter);
        try {
            this.state = 1566;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 49, this.context) ) {
            case 1:
                localContext = new TraversalMethod_filter_PredicateContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1556;
                this.match(GremlinParser.K_FILTER);
                this.state = 1557;
                this.match(GremlinParser.LPAREN);
                this.state = 1558;
                this.traversalPredicate(0);
                this.state = 1559;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_filter_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1561;
                this.match(GremlinParser.K_FILTER);
                this.state = 1562;
                this.match(GremlinParser.LPAREN);
                this.state = 1563;
                this.nestedTraversal();
                this.state = 1564;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_flatMap(): TraversalMethod_flatMapContext {
        let localContext = new TraversalMethod_flatMapContext(this.context, this.state);
        this.enterRule(localContext, 146, GremlinParser.RULE_traversalMethod_flatMap);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1568;
            this.match(GremlinParser.K_FLATMAP);
            this.state = 1569;
            this.match(GremlinParser.LPAREN);
            this.state = 1570;
            this.nestedTraversal();
            this.state = 1571;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_fold(): TraversalMethod_foldContext {
        let localContext = new TraversalMethod_foldContext(this.context, this.state);
        this.enterRule(localContext, 148, GremlinParser.RULE_traversalMethod_fold);
        try {
            this.state = 1583;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 50, this.context) ) {
            case 1:
                localContext = new TraversalMethod_fold_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1573;
                this.match(GremlinParser.K_FOLD);
                this.state = 1574;
                this.match(GremlinParser.LPAREN);
                this.state = 1575;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_fold_Object_BiFunctionContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1576;
                this.match(GremlinParser.K_FOLD);
                this.state = 1577;
                this.match(GremlinParser.LPAREN);
                this.state = 1578;
                this.genericLiteral();
                this.state = 1579;
                this.match(GremlinParser.COMMA);
                this.state = 1580;
                this.traversalBiFunction();
                this.state = 1581;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_format(): TraversalMethod_formatContext {
        let localContext = new TraversalMethod_formatContext(this.context, this.state);
        this.enterRule(localContext, 150, GremlinParser.RULE_traversalMethod_format);
        try {
            localContext = new TraversalMethod_format_StringContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1585;
            this.match(GremlinParser.K_FORMAT);
            this.state = 1586;
            this.match(GremlinParser.LPAREN);
            this.state = 1587;
            this.stringLiteral();
            this.state = 1588;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_from(): TraversalMethod_fromContext {
        let localContext = new TraversalMethod_fromContext(this.context, this.state);
        this.enterRule(localContext, 152, GremlinParser.RULE_traversalMethod_from);
        try {
            this.state = 1600;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 51, this.context) ) {
            case 1:
                localContext = new TraversalMethod_from_StringContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1590;
                this.match(GremlinParser.K_FROM);
                this.state = 1591;
                this.match(GremlinParser.LPAREN);
                this.state = 1592;
                this.stringLiteral();
                this.state = 1593;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_from_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1595;
                this.match(GremlinParser.K_FROM);
                this.state = 1596;
                this.match(GremlinParser.LPAREN);
                this.state = 1597;
                this.nestedTraversal();
                this.state = 1598;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_group(): TraversalMethod_groupContext {
        let localContext = new TraversalMethod_groupContext(this.context, this.state);
        this.enterRule(localContext, 154, GremlinParser.RULE_traversalMethod_group);
        try {
            this.state = 1610;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 52, this.context) ) {
            case 1:
                localContext = new TraversalMethod_group_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1602;
                this.match(GremlinParser.K_GROUP);
                this.state = 1603;
                this.match(GremlinParser.LPAREN);
                this.state = 1604;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_group_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1605;
                this.match(GremlinParser.K_GROUP);
                this.state = 1606;
                this.match(GremlinParser.LPAREN);
                this.state = 1607;
                this.stringLiteral();
                this.state = 1608;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_groupCount(): TraversalMethod_groupCountContext {
        let localContext = new TraversalMethod_groupCountContext(this.context, this.state);
        this.enterRule(localContext, 156, GremlinParser.RULE_traversalMethod_groupCount);
        try {
            this.state = 1620;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 53, this.context) ) {
            case 1:
                localContext = new TraversalMethod_groupCount_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1612;
                this.match(GremlinParser.K_GROUPCOUNT);
                this.state = 1613;
                this.match(GremlinParser.LPAREN);
                this.state = 1614;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_groupCount_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1615;
                this.match(GremlinParser.K_GROUPCOUNT);
                this.state = 1616;
                this.match(GremlinParser.LPAREN);
                this.state = 1617;
                this.stringLiteral();
                this.state = 1618;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_has(): TraversalMethod_hasContext {
        let localContext = new TraversalMethod_hasContext(this.context, this.state);
        this.enterRule(localContext, 158, GremlinParser.RULE_traversalMethod_has);
        try {
            this.state = 1696;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 54, this.context) ) {
            case 1:
                localContext = new TraversalMethod_has_StringContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1622;
                this.match(GremlinParser.K_HAS);
                this.state = 1623;
                this.match(GremlinParser.LPAREN);
                this.state = 1624;
                this.stringNullableLiteral();
                this.state = 1625;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_has_String_ObjectContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1627;
                this.match(GremlinParser.K_HAS);
                this.state = 1628;
                this.match(GremlinParser.LPAREN);
                this.state = 1629;
                this.stringNullableLiteral();
                this.state = 1630;
                this.match(GremlinParser.COMMA);
                this.state = 1631;
                this.genericArgument();
                this.state = 1632;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_has_String_PContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1634;
                this.match(GremlinParser.K_HAS);
                this.state = 1635;
                this.match(GremlinParser.LPAREN);
                this.state = 1636;
                this.stringNullableLiteral();
                this.state = 1637;
                this.match(GremlinParser.COMMA);
                this.state = 1638;
                this.traversalPredicate(0);
                this.state = 1639;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 4:
                localContext = new TraversalMethod_has_String_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1641;
                this.match(GremlinParser.K_HAS);
                this.state = 1642;
                this.match(GremlinParser.LPAREN);
                this.state = 1643;
                this.stringNullableLiteral();
                this.state = 1644;
                this.match(GremlinParser.COMMA);
                this.state = 1645;
                this.nestedTraversal();
                this.state = 1646;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 5:
                localContext = new TraversalMethod_has_String_String_ObjectContext(localContext);
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 1648;
                this.match(GremlinParser.K_HAS);
                this.state = 1649;
                this.match(GremlinParser.LPAREN);
                this.state = 1650;
                this.stringNullableArgument();
                this.state = 1651;
                this.match(GremlinParser.COMMA);
                this.state = 1652;
                this.stringNullableLiteral();
                this.state = 1653;
                this.match(GremlinParser.COMMA);
                this.state = 1654;
                this.genericArgument();
                this.state = 1655;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 6:
                localContext = new TraversalMethod_has_String_String_PContext(localContext);
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 1657;
                this.match(GremlinParser.K_HAS);
                this.state = 1658;
                this.match(GremlinParser.LPAREN);
                this.state = 1659;
                this.stringNullableArgument();
                this.state = 1660;
                this.match(GremlinParser.COMMA);
                this.state = 1661;
                this.stringNullableLiteral();
                this.state = 1662;
                this.match(GremlinParser.COMMA);
                this.state = 1663;
                this.traversalPredicate(0);
                this.state = 1664;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 7:
                localContext = new TraversalMethod_has_String_String_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 1666;
                this.match(GremlinParser.K_HAS);
                this.state = 1667;
                this.match(GremlinParser.LPAREN);
                this.state = 1668;
                this.stringNullableArgument();
                this.state = 1669;
                this.match(GremlinParser.COMMA);
                this.state = 1670;
                this.stringNullableLiteral();
                this.state = 1671;
                this.match(GremlinParser.COMMA);
                this.state = 1672;
                this.nestedTraversal();
                this.state = 1673;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 8:
                localContext = new TraversalMethod_has_T_ObjectContext(localContext);
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 1675;
                this.match(GremlinParser.K_HAS);
                this.state = 1676;
                this.match(GremlinParser.LPAREN);
                this.state = 1677;
                this.traversalT();
                this.state = 1678;
                this.match(GremlinParser.COMMA);
                this.state = 1679;
                this.genericArgument();
                this.state = 1680;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 9:
                localContext = new TraversalMethod_has_T_PContext(localContext);
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 1682;
                this.match(GremlinParser.K_HAS);
                this.state = 1683;
                this.match(GremlinParser.LPAREN);
                this.state = 1684;
                this.traversalT();
                this.state = 1685;
                this.match(GremlinParser.COMMA);
                this.state = 1686;
                this.traversalPredicate(0);
                this.state = 1687;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 10:
                localContext = new TraversalMethod_has_T_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 1689;
                this.match(GremlinParser.K_HAS);
                this.state = 1690;
                this.match(GremlinParser.LPAREN);
                this.state = 1691;
                this.traversalT();
                this.state = 1692;
                this.match(GremlinParser.COMMA);
                this.state = 1693;
                this.nestedTraversal();
                this.state = 1694;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_hasId(): TraversalMethod_hasIdContext {
        let localContext = new TraversalMethod_hasIdContext(this.context, this.state);
        this.enterRule(localContext, 160, GremlinParser.RULE_traversalMethod_hasId);
        let _la: number;
        try {
            this.state = 1712;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 56, this.context) ) {
            case 1:
                localContext = new TraversalMethod_hasId_Object_ObjectContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1698;
                this.match(GremlinParser.K_HASID);
                this.state = 1699;
                this.match(GremlinParser.LPAREN);
                this.state = 1700;
                this.genericArgument();
                this.state = 1703;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 320) {
                    {
                    this.state = 1701;
                    this.match(GremlinParser.COMMA);
                    this.state = 1702;
                    this.genericArgumentVarargs();
                    }
                }

                this.state = 1705;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_hasId_PContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1707;
                this.match(GremlinParser.K_HASID);
                this.state = 1708;
                this.match(GremlinParser.LPAREN);
                this.state = 1709;
                this.traversalPredicate(0);
                this.state = 1710;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_hasKey(): TraversalMethod_hasKeyContext {
        let localContext = new TraversalMethod_hasKeyContext(this.context, this.state);
        this.enterRule(localContext, 162, GremlinParser.RULE_traversalMethod_hasKey);
        let _la: number;
        try {
            this.state = 1733;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 58, this.context) ) {
            case 1:
                localContext = new TraversalMethod_hasKey_PContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1714;
                this.match(GremlinParser.K_HASKEY);
                this.state = 1715;
                this.match(GremlinParser.LPAREN);
                this.state = 1716;
                this.traversalPredicate(0);
                this.state = 1717;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_hasKey_String_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1719;
                this.match(GremlinParser.K_HASKEY);
                this.state = 1720;
                this.match(GremlinParser.LPAREN);
                this.state = 1721;
                this.stringNullableLiteral();
                this.state = 1724;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 320) {
                    {
                    this.state = 1722;
                    this.match(GremlinParser.COMMA);
                    this.state = 1723;
                    this.stringNullableLiteralVarargs();
                    }
                }

                this.state = 1726;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_hasKey_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1728;
                this.match(GremlinParser.K_HASKEY);
                this.state = 1729;
                this.match(GremlinParser.LPAREN);
                this.state = 1730;
                this.nestedTraversal();
                this.state = 1731;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_hasLabel(): TraversalMethod_hasLabelContext {
        let localContext = new TraversalMethod_hasLabelContext(this.context, this.state);
        this.enterRule(localContext, 164, GremlinParser.RULE_traversalMethod_hasLabel);
        let _la: number;
        try {
            this.state = 1754;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 60, this.context) ) {
            case 1:
                localContext = new TraversalMethod_hasLabel_PContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1735;
                this.match(GremlinParser.K_HASLABEL);
                this.state = 1736;
                this.match(GremlinParser.LPAREN);
                this.state = 1737;
                this.traversalPredicate(0);
                this.state = 1738;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_hasLabel_String_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1740;
                this.match(GremlinParser.K_HASLABEL);
                this.state = 1741;
                this.match(GremlinParser.LPAREN);
                this.state = 1742;
                this.stringNullableArgument();
                this.state = 1745;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 320) {
                    {
                    this.state = 1743;
                    this.match(GremlinParser.COMMA);
                    this.state = 1744;
                    this.stringNullableArgumentVarargs();
                    }
                }

                this.state = 1747;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_hasLabel_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1749;
                this.match(GremlinParser.K_HASLABEL);
                this.state = 1750;
                this.match(GremlinParser.LPAREN);
                this.state = 1751;
                this.nestedTraversal();
                this.state = 1752;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_hasNot(): TraversalMethod_hasNotContext {
        let localContext = new TraversalMethod_hasNotContext(this.context, this.state);
        this.enterRule(localContext, 166, GremlinParser.RULE_traversalMethod_hasNot);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1756;
            this.match(GremlinParser.K_HASNOT);
            this.state = 1757;
            this.match(GremlinParser.LPAREN);
            this.state = 1758;
            this.stringNullableLiteral();
            this.state = 1759;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_hasValue(): TraversalMethod_hasValueContext {
        let localContext = new TraversalMethod_hasValueContext(this.context, this.state);
        this.enterRule(localContext, 168, GremlinParser.RULE_traversalMethod_hasValue);
        let _la: number;
        try {
            this.state = 1780;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 62, this.context) ) {
            case 1:
                localContext = new TraversalMethod_hasValue_Object_ObjectContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1761;
                this.match(GremlinParser.K_HASVALUE);
                this.state = 1762;
                this.match(GremlinParser.LPAREN);
                this.state = 1763;
                this.genericArgument();
                this.state = 1766;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 320) {
                    {
                    this.state = 1764;
                    this.match(GremlinParser.COMMA);
                    this.state = 1765;
                    this.genericArgumentVarargs();
                    }
                }

                this.state = 1768;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_hasValue_PContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1770;
                this.match(GremlinParser.K_HASVALUE);
                this.state = 1771;
                this.match(GremlinParser.LPAREN);
                this.state = 1772;
                this.traversalPredicate(0);
                this.state = 1773;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_hasValue_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1775;
                this.match(GremlinParser.K_HASVALUE);
                this.state = 1776;
                this.match(GremlinParser.LPAREN);
                this.state = 1777;
                this.nestedTraversal();
                this.state = 1778;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_id(): TraversalMethod_idContext {
        let localContext = new TraversalMethod_idContext(this.context, this.state);
        this.enterRule(localContext, 170, GremlinParser.RULE_traversalMethod_id);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1782;
            this.match(GremlinParser.K_ID);
            this.state = 1783;
            this.match(GremlinParser.LPAREN);
            this.state = 1784;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_identity(): TraversalMethod_identityContext {
        let localContext = new TraversalMethod_identityContext(this.context, this.state);
        this.enterRule(localContext, 172, GremlinParser.RULE_traversalMethod_identity);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1786;
            this.match(GremlinParser.K_IDENTITY);
            this.state = 1787;
            this.match(GremlinParser.LPAREN);
            this.state = 1788;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_in(): TraversalMethod_inContext {
        let localContext = new TraversalMethod_inContext(this.context, this.state);
        this.enterRule(localContext, 174, GremlinParser.RULE_traversalMethod_in);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1790;
            this.match(GremlinParser.K_IN);
            this.state = 1791;
            this.match(GremlinParser.LPAREN);
            this.state = 1792;
            this.stringNullableArgumentVarargs();
            this.state = 1793;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_inE(): TraversalMethod_inEContext {
        let localContext = new TraversalMethod_inEContext(this.context, this.state);
        this.enterRule(localContext, 176, GremlinParser.RULE_traversalMethod_inE);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1795;
            this.match(GremlinParser.K_INE);
            this.state = 1796;
            this.match(GremlinParser.LPAREN);
            this.state = 1797;
            this.stringNullableArgumentVarargs();
            this.state = 1798;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_intersect(): TraversalMethod_intersectContext {
        let localContext = new TraversalMethod_intersectContext(this.context, this.state);
        this.enterRule(localContext, 178, GremlinParser.RULE_traversalMethod_intersect);
        try {
            localContext = new TraversalMethod_intersect_ObjectContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1800;
            this.match(GremlinParser.K_INTERSECT);
            this.state = 1801;
            this.match(GremlinParser.LPAREN);
            this.state = 1802;
            this.genericLiteral();
            this.state = 1803;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_inV(): TraversalMethod_inVContext {
        let localContext = new TraversalMethod_inVContext(this.context, this.state);
        this.enterRule(localContext, 180, GremlinParser.RULE_traversalMethod_inV);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1805;
            this.match(GremlinParser.K_INV);
            this.state = 1806;
            this.match(GremlinParser.LPAREN);
            this.state = 1807;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_index(): TraversalMethod_indexContext {
        let localContext = new TraversalMethod_indexContext(this.context, this.state);
        this.enterRule(localContext, 182, GremlinParser.RULE_traversalMethod_index);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1809;
            this.match(GremlinParser.K_INDEX);
            this.state = 1810;
            this.match(GremlinParser.LPAREN);
            this.state = 1811;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_inject(): TraversalMethod_injectContext {
        let localContext = new TraversalMethod_injectContext(this.context, this.state);
        this.enterRule(localContext, 184, GremlinParser.RULE_traversalMethod_inject);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1813;
            this.match(GremlinParser.K_INJECT);
            this.state = 1814;
            this.match(GremlinParser.LPAREN);
            this.state = 1815;
            this.genericLiteralVarargs();
            this.state = 1816;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_is(): TraversalMethod_isContext {
        let localContext = new TraversalMethod_isContext(this.context, this.state);
        this.enterRule(localContext, 186, GremlinParser.RULE_traversalMethod_is);
        try {
            this.state = 1828;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 63, this.context) ) {
            case 1:
                localContext = new TraversalMethod_is_ObjectContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1818;
                this.match(GremlinParser.K_IS);
                this.state = 1819;
                this.match(GremlinParser.LPAREN);
                this.state = 1820;
                this.genericArgument();
                this.state = 1821;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_is_PContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1823;
                this.match(GremlinParser.K_IS);
                this.state = 1824;
                this.match(GremlinParser.LPAREN);
                this.state = 1825;
                this.traversalPredicate(0);
                this.state = 1826;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_key(): TraversalMethod_keyContext {
        let localContext = new TraversalMethod_keyContext(this.context, this.state);
        this.enterRule(localContext, 188, GremlinParser.RULE_traversalMethod_key);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1830;
            this.match(GremlinParser.K_KEY);
            this.state = 1831;
            this.match(GremlinParser.LPAREN);
            this.state = 1832;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_label(): TraversalMethod_labelContext {
        let localContext = new TraversalMethod_labelContext(this.context, this.state);
        this.enterRule(localContext, 190, GremlinParser.RULE_traversalMethod_label);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1834;
            this.match(GremlinParser.K_LABEL);
            this.state = 1835;
            this.match(GremlinParser.LPAREN);
            this.state = 1836;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_labels(): TraversalMethod_labelsContext {
        let localContext = new TraversalMethod_labelsContext(this.context, this.state);
        this.enterRule(localContext, 192, GremlinParser.RULE_traversalMethod_labels);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1838;
            this.match(GremlinParser.K_LABELS);
            this.state = 1839;
            this.match(GremlinParser.LPAREN);
            this.state = 1840;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_addLabel(): TraversalMethod_addLabelContext {
        let localContext = new TraversalMethod_addLabelContext(this.context, this.state);
        this.enterRule(localContext, 194, GremlinParser.RULE_traversalMethod_addLabel);
        let _la: number;
        try {
            this.state = 1859;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 65, this.context) ) {
            case 1:
                localContext = new TraversalMethod_addLabel_StringContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1842;
                this.match(GremlinParser.K_ADDLABEL);
                this.state = 1843;
                this.match(GremlinParser.LPAREN);
                this.state = 1844;
                this.stringLiteralVarargs();
                this.state = 1845;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_addLabel_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1847;
                this.match(GremlinParser.K_ADDLABEL);
                this.state = 1848;
                this.match(GremlinParser.LPAREN);
                this.state = 1849;
                this.nestedTraversal();
                this.state = 1854;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 320) {
                    {
                    {
                    this.state = 1850;
                    this.match(GremlinParser.COMMA);
                    this.state = 1851;
                    this.nestedTraversal();
                    }
                    }
                    this.state = 1856;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 1857;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_dropLabels(): TraversalMethod_dropLabelsContext {
        let localContext = new TraversalMethod_dropLabelsContext(this.context, this.state);
        this.enterRule(localContext, 196, GremlinParser.RULE_traversalMethod_dropLabels);
        try {
            localContext = new TraversalMethod_dropLabels_EmptyContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1861;
            this.match(GremlinParser.K_DROPLABELS);
            this.state = 1862;
            this.match(GremlinParser.LPAREN);
            this.state = 1863;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_dropLabel(): TraversalMethod_dropLabelContext {
        let localContext = new TraversalMethod_dropLabelContext(this.context, this.state);
        this.enterRule(localContext, 198, GremlinParser.RULE_traversalMethod_dropLabel);
        let _la: number;
        try {
            this.state = 1882;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 67, this.context) ) {
            case 1:
                localContext = new TraversalMethod_dropLabel_StringContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1865;
                this.match(GremlinParser.K_DROPLABEL);
                this.state = 1866;
                this.match(GremlinParser.LPAREN);
                this.state = 1867;
                this.stringLiteralVarargs();
                this.state = 1868;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_dropLabel_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1870;
                this.match(GremlinParser.K_DROPLABEL);
                this.state = 1871;
                this.match(GremlinParser.LPAREN);
                this.state = 1872;
                this.nestedTraversal();
                this.state = 1877;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 320) {
                    {
                    {
                    this.state = 1873;
                    this.match(GremlinParser.COMMA);
                    this.state = 1874;
                    this.nestedTraversal();
                    }
                    }
                    this.state = 1879;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 1880;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_length(): TraversalMethod_lengthContext {
        let localContext = new TraversalMethod_lengthContext(this.context, this.state);
        this.enterRule(localContext, 200, GremlinParser.RULE_traversalMethod_length);
        try {
            this.state = 1892;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 68, this.context) ) {
            case 1:
                localContext = new TraversalMethod_length_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1884;
                this.match(GremlinParser.K_LENGTH);
                this.state = 1885;
                this.match(GremlinParser.LPAREN);
                this.state = 1886;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_length_ScopeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1887;
                this.match(GremlinParser.K_LENGTH);
                this.state = 1888;
                this.match(GremlinParser.LPAREN);
                this.state = 1889;
                this.traversalScope();
                this.state = 1890;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_limit(): TraversalMethod_limitContext {
        let localContext = new TraversalMethod_limitContext(this.context, this.state);
        this.enterRule(localContext, 202, GremlinParser.RULE_traversalMethod_limit);
        try {
            this.state = 1906;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 69, this.context) ) {
            case 1:
                localContext = new TraversalMethod_limit_Scope_longContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1894;
                this.match(GremlinParser.K_LIMIT);
                this.state = 1895;
                this.match(GremlinParser.LPAREN);
                this.state = 1896;
                this.traversalScope();
                this.state = 1897;
                this.match(GremlinParser.COMMA);
                this.state = 1898;
                this.integerArgument();
                this.state = 1899;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_limit_longContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1901;
                this.match(GremlinParser.K_LIMIT);
                this.state = 1902;
                this.match(GremlinParser.LPAREN);
                this.state = 1903;
                this.integerArgument();
                this.state = 1904;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_local(): TraversalMethod_localContext {
        let localContext = new TraversalMethod_localContext(this.context, this.state);
        this.enterRule(localContext, 204, GremlinParser.RULE_traversalMethod_local);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1908;
            this.match(GremlinParser.K_LOCAL);
            this.state = 1909;
            this.match(GremlinParser.LPAREN);
            this.state = 1910;
            this.nestedTraversal();
            this.state = 1911;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_loops(): TraversalMethod_loopsContext {
        let localContext = new TraversalMethod_loopsContext(this.context, this.state);
        this.enterRule(localContext, 206, GremlinParser.RULE_traversalMethod_loops);
        try {
            this.state = 1921;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 70, this.context) ) {
            case 1:
                localContext = new TraversalMethod_loops_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1913;
                this.match(GremlinParser.K_LOOPS);
                this.state = 1914;
                this.match(GremlinParser.LPAREN);
                this.state = 1915;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_loops_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1916;
                this.match(GremlinParser.K_LOOPS);
                this.state = 1917;
                this.match(GremlinParser.LPAREN);
                this.state = 1918;
                this.stringLiteral();
                this.state = 1919;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_lTrim(): TraversalMethod_lTrimContext {
        let localContext = new TraversalMethod_lTrimContext(this.context, this.state);
        this.enterRule(localContext, 208, GremlinParser.RULE_traversalMethod_lTrim);
        try {
            this.state = 1931;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 71, this.context) ) {
            case 1:
                localContext = new TraversalMethod_lTrim_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1923;
                this.match(GremlinParser.K_LTRIM);
                this.state = 1924;
                this.match(GremlinParser.LPAREN);
                this.state = 1925;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_lTrim_ScopeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1926;
                this.match(GremlinParser.K_LTRIM);
                this.state = 1927;
                this.match(GremlinParser.LPAREN);
                this.state = 1928;
                this.traversalScope();
                this.state = 1929;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_map(): TraversalMethod_mapContext {
        let localContext = new TraversalMethod_mapContext(this.context, this.state);
        this.enterRule(localContext, 210, GremlinParser.RULE_traversalMethod_map);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1933;
            this.match(GremlinParser.K_MAP);
            this.state = 1934;
            this.match(GremlinParser.LPAREN);
            this.state = 1935;
            this.nestedTraversal();
            this.state = 1936;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_match(): TraversalMethod_matchContext {
        let localContext = new TraversalMethod_matchContext(this.context, this.state);
        this.enterRule(localContext, 212, GremlinParser.RULE_traversalMethod_match);
        try {
            this.state = 1955;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 72, this.context) ) {
            case 1:
                localContext = new TraversalMethod_match_traversalContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1938;
                this.match(GremlinParser.K_MATCH);
                this.state = 1939;
                this.match(GremlinParser.LPAREN);
                this.state = 1940;
                this.nestedTraversalList();
                this.state = 1941;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_match_stringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1943;
                this.match(GremlinParser.K_MATCH);
                this.state = 1944;
                this.match(GremlinParser.LPAREN);
                this.state = 1945;
                this.stringLiteral();
                this.state = 1946;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_match_string_mapContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1948;
                this.match(GremlinParser.K_MATCH);
                this.state = 1949;
                this.match(GremlinParser.LPAREN);
                this.state = 1950;
                this.stringLiteral();
                this.state = 1951;
                this.match(GremlinParser.COMMA);
                this.state = 1952;
                this.genericMapLiteral();
                this.state = 1953;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_math(): TraversalMethod_mathContext {
        let localContext = new TraversalMethod_mathContext(this.context, this.state);
        this.enterRule(localContext, 214, GremlinParser.RULE_traversalMethod_math);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1957;
            this.match(GremlinParser.K_MATH);
            this.state = 1958;
            this.match(GremlinParser.LPAREN);
            this.state = 1959;
            this.stringLiteral();
            this.state = 1960;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_max(): TraversalMethod_maxContext {
        let localContext = new TraversalMethod_maxContext(this.context, this.state);
        this.enterRule(localContext, 216, GremlinParser.RULE_traversalMethod_max);
        try {
            this.state = 1970;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 73, this.context) ) {
            case 1:
                localContext = new TraversalMethod_max_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1962;
                this.match(GremlinParser.K_MAX);
                this.state = 1963;
                this.match(GremlinParser.LPAREN);
                this.state = 1964;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_max_ScopeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1965;
                this.match(GremlinParser.K_MAX);
                this.state = 1966;
                this.match(GremlinParser.LPAREN);
                this.state = 1967;
                this.traversalScope();
                this.state = 1968;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_mean(): TraversalMethod_meanContext {
        let localContext = new TraversalMethod_meanContext(this.context, this.state);
        this.enterRule(localContext, 218, GremlinParser.RULE_traversalMethod_mean);
        try {
            this.state = 1980;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 74, this.context) ) {
            case 1:
                localContext = new TraversalMethod_mean_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1972;
                this.match(GremlinParser.K_MEAN);
                this.state = 1973;
                this.match(GremlinParser.LPAREN);
                this.state = 1974;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_mean_ScopeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1975;
                this.match(GremlinParser.K_MEAN);
                this.state = 1976;
                this.match(GremlinParser.LPAREN);
                this.state = 1977;
                this.traversalScope();
                this.state = 1978;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_merge(): TraversalMethod_mergeContext {
        let localContext = new TraversalMethod_mergeContext(this.context, this.state);
        this.enterRule(localContext, 220, GremlinParser.RULE_traversalMethod_merge);
        try {
            localContext = new TraversalMethod_merge_ObjectContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1982;
            this.match(GremlinParser.K_MERGE);
            this.state = 1983;
            this.match(GremlinParser.LPAREN);
            this.state = 1984;
            this.genericLiteral();
            this.state = 1985;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_mergeV(): TraversalMethod_mergeVContext {
        let localContext = new TraversalMethod_mergeVContext(this.context, this.state);
        this.enterRule(localContext, 222, GremlinParser.RULE_traversalMethod_mergeV);
        try {
            this.state = 2000;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 75, this.context) ) {
            case 1:
                localContext = new TraversalMethod_mergeV_emptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1987;
                this.match(GremlinParser.K_MERGEV);
                this.state = 1988;
                this.match(GremlinParser.LPAREN);
                this.state = 1989;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_mergeV_MapContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1990;
                this.match(GremlinParser.K_MERGEV);
                this.state = 1991;
                this.match(GremlinParser.LPAREN);
                this.state = 1992;
                this.genericMapNullableArgument();
                this.state = 1993;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_mergeV_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1995;
                this.match(GremlinParser.K_MERGEV);
                this.state = 1996;
                this.match(GremlinParser.LPAREN);
                this.state = 1997;
                this.nestedTraversal();
                this.state = 1998;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_mergeE(): TraversalMethod_mergeEContext {
        let localContext = new TraversalMethod_mergeEContext(this.context, this.state);
        this.enterRule(localContext, 224, GremlinParser.RULE_traversalMethod_mergeE);
        try {
            this.state = 2015;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 76, this.context) ) {
            case 1:
                localContext = new TraversalMethod_mergeE_emptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2002;
                this.match(GremlinParser.K_MERGEE);
                this.state = 2003;
                this.match(GremlinParser.LPAREN);
                this.state = 2004;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_mergeE_MapContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2005;
                this.match(GremlinParser.K_MERGEE);
                this.state = 2006;
                this.match(GremlinParser.LPAREN);
                this.state = 2007;
                this.genericMapNullableArgument();
                this.state = 2008;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_mergeE_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2010;
                this.match(GremlinParser.K_MERGEE);
                this.state = 2011;
                this.match(GremlinParser.LPAREN);
                this.state = 2012;
                this.nestedTraversal();
                this.state = 2013;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_min(): TraversalMethod_minContext {
        let localContext = new TraversalMethod_minContext(this.context, this.state);
        this.enterRule(localContext, 226, GremlinParser.RULE_traversalMethod_min);
        try {
            this.state = 2025;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 77, this.context) ) {
            case 1:
                localContext = new TraversalMethod_min_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2017;
                this.match(GremlinParser.K_MIN);
                this.state = 2018;
                this.match(GremlinParser.LPAREN);
                this.state = 2019;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_min_ScopeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2020;
                this.match(GremlinParser.K_MIN);
                this.state = 2021;
                this.match(GremlinParser.LPAREN);
                this.state = 2022;
                this.traversalScope();
                this.state = 2023;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_none(): TraversalMethod_noneContext {
        let localContext = new TraversalMethod_noneContext(this.context, this.state);
        this.enterRule(localContext, 228, GremlinParser.RULE_traversalMethod_none);
        try {
            localContext = new TraversalMethod_none_PContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2027;
            this.match(GremlinParser.K_NONE);
            this.state = 2028;
            this.match(GremlinParser.LPAREN);
            this.state = 2029;
            this.traversalPredicate(0);
            this.state = 2030;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_not(): TraversalMethod_notContext {
        let localContext = new TraversalMethod_notContext(this.context, this.state);
        this.enterRule(localContext, 230, GremlinParser.RULE_traversalMethod_not);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2032;
            this.match(GremlinParser.K_NOT);
            this.state = 2033;
            this.match(GremlinParser.LPAREN);
            this.state = 2034;
            this.nestedTraversal();
            this.state = 2035;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_option(): TraversalMethod_optionContext {
        let localContext = new TraversalMethod_optionContext(this.context, this.state);
        this.enterRule(localContext, 232, GremlinParser.RULE_traversalMethod_option);
        try {
            this.state = 2079;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 78, this.context) ) {
            case 1:
                localContext = new TraversalMethod_option_Predicate_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2037;
                this.match(GremlinParser.K_OPTION);
                this.state = 2038;
                this.match(GremlinParser.LPAREN);
                this.state = 2039;
                this.traversalPredicate(0);
                this.state = 2040;
                this.match(GremlinParser.COMMA);
                this.state = 2041;
                this.nestedTraversal();
                this.state = 2042;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_option_Merge_MapContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2044;
                this.match(GremlinParser.K_OPTION);
                this.state = 2045;
                this.match(GremlinParser.LPAREN);
                this.state = 2046;
                this.traversalMerge();
                this.state = 2047;
                this.match(GremlinParser.COMMA);
                this.state = 2048;
                this.genericMapNullableArgument();
                this.state = 2049;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_option_Merge_Map_CardinalityContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2051;
                this.match(GremlinParser.K_OPTION);
                this.state = 2052;
                this.match(GremlinParser.LPAREN);
                this.state = 2053;
                this.traversalMerge();
                this.state = 2054;
                this.match(GremlinParser.COMMA);
                this.state = 2055;
                this.genericMapNullableArgument();
                this.state = 2056;
                this.match(GremlinParser.COMMA);
                this.state = 2057;
                this.traversalCardinality();
                this.state = 2058;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 4:
                localContext = new TraversalMethod_option_Merge_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2060;
                this.match(GremlinParser.K_OPTION);
                this.state = 2061;
                this.match(GremlinParser.LPAREN);
                this.state = 2062;
                this.traversalMerge();
                this.state = 2063;
                this.match(GremlinParser.COMMA);
                this.state = 2064;
                this.nestedTraversal();
                this.state = 2065;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 5:
                localContext = new TraversalMethod_option_Object_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2067;
                this.match(GremlinParser.K_OPTION);
                this.state = 2068;
                this.match(GremlinParser.LPAREN);
                this.state = 2069;
                this.genericArgument();
                this.state = 2070;
                this.match(GremlinParser.COMMA);
                this.state = 2071;
                this.nestedTraversal();
                this.state = 2072;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 6:
                localContext = new TraversalMethod_option_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 2074;
                this.match(GremlinParser.K_OPTION);
                this.state = 2075;
                this.match(GremlinParser.LPAREN);
                this.state = 2076;
                this.nestedTraversal();
                this.state = 2077;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_optional(): TraversalMethod_optionalContext {
        let localContext = new TraversalMethod_optionalContext(this.context, this.state);
        this.enterRule(localContext, 234, GremlinParser.RULE_traversalMethod_optional);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2081;
            this.match(GremlinParser.K_OPTIONAL);
            this.state = 2082;
            this.match(GremlinParser.LPAREN);
            this.state = 2083;
            this.nestedTraversal();
            this.state = 2084;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_or(): TraversalMethod_orContext {
        let localContext = new TraversalMethod_orContext(this.context, this.state);
        this.enterRule(localContext, 236, GremlinParser.RULE_traversalMethod_or);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2086;
            this.match(GremlinParser.K_OR);
            this.state = 2087;
            this.match(GremlinParser.LPAREN);
            this.state = 2088;
            this.nestedTraversalList();
            this.state = 2089;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_order(): TraversalMethod_orderContext {
        let localContext = new TraversalMethod_orderContext(this.context, this.state);
        this.enterRule(localContext, 238, GremlinParser.RULE_traversalMethod_order);
        try {
            this.state = 2099;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 79, this.context) ) {
            case 1:
                localContext = new TraversalMethod_order_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2091;
                this.match(GremlinParser.K_ORDER);
                this.state = 2092;
                this.match(GremlinParser.LPAREN);
                this.state = 2093;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_order_ScopeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2094;
                this.match(GremlinParser.K_ORDER);
                this.state = 2095;
                this.match(GremlinParser.LPAREN);
                this.state = 2096;
                this.traversalScope();
                this.state = 2097;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_otherV(): TraversalMethod_otherVContext {
        let localContext = new TraversalMethod_otherVContext(this.context, this.state);
        this.enterRule(localContext, 240, GremlinParser.RULE_traversalMethod_otherV);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2101;
            this.match(GremlinParser.K_OTHERV);
            this.state = 2102;
            this.match(GremlinParser.LPAREN);
            this.state = 2103;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_out(): TraversalMethod_outContext {
        let localContext = new TraversalMethod_outContext(this.context, this.state);
        this.enterRule(localContext, 242, GremlinParser.RULE_traversalMethod_out);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2105;
            this.match(GremlinParser.K_OUT);
            this.state = 2106;
            this.match(GremlinParser.LPAREN);
            this.state = 2107;
            this.stringNullableArgumentVarargs();
            this.state = 2108;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_outE(): TraversalMethod_outEContext {
        let localContext = new TraversalMethod_outEContext(this.context, this.state);
        this.enterRule(localContext, 244, GremlinParser.RULE_traversalMethod_outE);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2110;
            this.match(GremlinParser.K_OUTE);
            this.state = 2111;
            this.match(GremlinParser.LPAREN);
            this.state = 2112;
            this.stringNullableArgumentVarargs();
            this.state = 2113;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_outV(): TraversalMethod_outVContext {
        let localContext = new TraversalMethod_outVContext(this.context, this.state);
        this.enterRule(localContext, 246, GremlinParser.RULE_traversalMethod_outV);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2115;
            this.match(GremlinParser.K_OUTV);
            this.state = 2116;
            this.match(GremlinParser.LPAREN);
            this.state = 2117;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_pageRank(): TraversalMethod_pageRankContext {
        let localContext = new TraversalMethod_pageRankContext(this.context, this.state);
        this.enterRule(localContext, 248, GremlinParser.RULE_traversalMethod_pageRank);
        try {
            this.state = 2127;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 80, this.context) ) {
            case 1:
                localContext = new TraversalMethod_pageRank_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2119;
                this.match(GremlinParser.K_PAGERANK);
                this.state = 2120;
                this.match(GremlinParser.LPAREN);
                this.state = 2121;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_pageRank_doubleContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2122;
                this.match(GremlinParser.K_PAGERANK);
                this.state = 2123;
                this.match(GremlinParser.LPAREN);
                this.state = 2124;
                this.numericLiteral();
                this.state = 2125;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_path(): TraversalMethod_pathContext {
        let localContext = new TraversalMethod_pathContext(this.context, this.state);
        this.enterRule(localContext, 250, GremlinParser.RULE_traversalMethod_path);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2129;
            this.match(GremlinParser.K_PATH);
            this.state = 2130;
            this.match(GremlinParser.LPAREN);
            this.state = 2131;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_peerPressure(): TraversalMethod_peerPressureContext {
        let localContext = new TraversalMethod_peerPressureContext(this.context, this.state);
        this.enterRule(localContext, 252, GremlinParser.RULE_traversalMethod_peerPressure);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2133;
            this.match(GremlinParser.K_PEERPRESSURE);
            this.state = 2134;
            this.match(GremlinParser.LPAREN);
            this.state = 2135;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_product(): TraversalMethod_productContext {
        let localContext = new TraversalMethod_productContext(this.context, this.state);
        this.enterRule(localContext, 254, GremlinParser.RULE_traversalMethod_product);
        try {
            localContext = new TraversalMethod_product_ObjectContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2137;
            this.match(GremlinParser.K_PRODUCT);
            this.state = 2138;
            this.match(GremlinParser.LPAREN);
            this.state = 2139;
            this.genericLiteral();
            this.state = 2140;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_profile(): TraversalMethod_profileContext {
        let localContext = new TraversalMethod_profileContext(this.context, this.state);
        this.enterRule(localContext, 256, GremlinParser.RULE_traversalMethod_profile);
        try {
            this.state = 2150;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 81, this.context) ) {
            case 1:
                localContext = new TraversalMethod_profile_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2142;
                this.match(GremlinParser.K_PROFILE);
                this.state = 2143;
                this.match(GremlinParser.LPAREN);
                this.state = 2144;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_profile_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2145;
                this.match(GremlinParser.K_PROFILE);
                this.state = 2146;
                this.match(GremlinParser.LPAREN);
                this.state = 2147;
                this.stringLiteral();
                this.state = 2148;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_project(): TraversalMethod_projectContext {
        let localContext = new TraversalMethod_projectContext(this.context, this.state);
        this.enterRule(localContext, 258, GremlinParser.RULE_traversalMethod_project);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2152;
            this.match(GremlinParser.K_PROJECT);
            this.state = 2153;
            this.match(GremlinParser.LPAREN);
            this.state = 2154;
            this.stringLiteral();
            this.state = 2157;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 320) {
                {
                this.state = 2155;
                this.match(GremlinParser.COMMA);
                this.state = 2156;
                this.stringNullableLiteralVarargs();
                }
            }

            this.state = 2159;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_properties(): TraversalMethod_propertiesContext {
        let localContext = new TraversalMethod_propertiesContext(this.context, this.state);
        this.enterRule(localContext, 260, GremlinParser.RULE_traversalMethod_properties);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2161;
            this.match(GremlinParser.K_PROPERTIES);
            this.state = 2162;
            this.match(GremlinParser.LPAREN);
            this.state = 2163;
            this.stringNullableLiteralVarargs();
            this.state = 2164;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_property(): TraversalMethod_propertyContext {
        let localContext = new TraversalMethod_propertyContext(this.context, this.state);
        this.enterRule(localContext, 262, GremlinParser.RULE_traversalMethod_property);
        let _la: number;
        try {
            this.state = 2223;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 85, this.context) ) {
            case 1:
                localContext = new TraversalMethod_property_Cardinality_Object_Object_ObjectContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2166;
                this.match(GremlinParser.K_PROPERTY);
                this.state = 2167;
                this.match(GremlinParser.LPAREN);
                this.state = 2168;
                this.traversalCardinality();
                this.state = 2169;
                this.match(GremlinParser.COMMA);
                this.state = 2170;
                this.genericLiteral();
                this.state = 2171;
                this.match(GremlinParser.COMMA);
                this.state = 2172;
                this.genericArgument();
                this.state = 2175;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 320) {
                    {
                    this.state = 2173;
                    this.match(GremlinParser.COMMA);
                    this.state = 2174;
                    this.genericArgumentVarargs();
                    }
                }

                this.state = 2177;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_property_Cardinality_Object_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2179;
                this.match(GremlinParser.K_PROPERTY);
                this.state = 2180;
                this.match(GremlinParser.LPAREN);
                this.state = 2181;
                this.traversalCardinality();
                this.state = 2182;
                this.match(GremlinParser.COMMA);
                this.state = 2183;
                this.genericLiteral();
                this.state = 2184;
                this.match(GremlinParser.COMMA);
                this.state = 2185;
                this.nestedTraversal();
                this.state = 2186;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_property_Cardinality_ObjectContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2188;
                this.match(GremlinParser.K_PROPERTY);
                this.state = 2189;
                this.match(GremlinParser.LPAREN);
                this.state = 2190;
                this.traversalCardinality();
                this.state = 2191;
                this.match(GremlinParser.COMMA);
                this.state = 2192;
                this.genericMapNullableArgument();
                this.state = 2193;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 4:
                localContext = new TraversalMethod_property_Object_Object_ObjectContext(localContext);
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2195;
                this.match(GremlinParser.K_PROPERTY);
                this.state = 2196;
                this.match(GremlinParser.LPAREN);
                this.state = 2197;
                this.genericLiteral();
                this.state = 2198;
                this.match(GremlinParser.COMMA);
                this.state = 2199;
                this.genericArgument();
                this.state = 2202;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 320) {
                    {
                    this.state = 2200;
                    this.match(GremlinParser.COMMA);
                    this.state = 2201;
                    this.genericArgumentVarargs();
                    }
                }

                this.state = 2204;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 5:
                localContext = new TraversalMethod_property_Object_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2206;
                this.match(GremlinParser.K_PROPERTY);
                this.state = 2207;
                this.match(GremlinParser.LPAREN);
                this.state = 2208;
                this.genericLiteral();
                this.state = 2209;
                this.match(GremlinParser.COMMA);
                this.state = 2210;
                this.nestedTraversal();
                this.state = 2211;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 6:
                localContext = new TraversalMethod_property_ObjectContext(localContext);
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 2213;
                this.match(GremlinParser.K_PROPERTY);
                this.state = 2214;
                this.match(GremlinParser.LPAREN);
                this.state = 2215;
                this.genericMapNullableArgument();
                this.state = 2216;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 7:
                localContext = new TraversalMethod_property_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 2218;
                this.match(GremlinParser.K_PROPERTY);
                this.state = 2219;
                this.match(GremlinParser.LPAREN);
                this.state = 2220;
                this.nestedTraversal();
                this.state = 2221;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_propertyMap(): TraversalMethod_propertyMapContext {
        let localContext = new TraversalMethod_propertyMapContext(this.context, this.state);
        this.enterRule(localContext, 264, GremlinParser.RULE_traversalMethod_propertyMap);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2225;
            this.match(GremlinParser.K_PROPERTYMAP);
            this.state = 2226;
            this.match(GremlinParser.LPAREN);
            this.state = 2227;
            this.stringNullableLiteralVarargs();
            this.state = 2228;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_range(): TraversalMethod_rangeContext {
        let localContext = new TraversalMethod_rangeContext(this.context, this.state);
        this.enterRule(localContext, 266, GremlinParser.RULE_traversalMethod_range);
        try {
            this.state = 2246;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 86, this.context) ) {
            case 1:
                localContext = new TraversalMethod_range_Scope_long_longContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2230;
                this.match(GremlinParser.K_RANGE);
                this.state = 2231;
                this.match(GremlinParser.LPAREN);
                this.state = 2232;
                this.traversalScope();
                this.state = 2233;
                this.match(GremlinParser.COMMA);
                this.state = 2234;
                this.integerArgument();
                this.state = 2235;
                this.match(GremlinParser.COMMA);
                this.state = 2236;
                this.integerArgument();
                this.state = 2237;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_range_long_longContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2239;
                this.match(GremlinParser.K_RANGE);
                this.state = 2240;
                this.match(GremlinParser.LPAREN);
                this.state = 2241;
                this.integerArgument();
                this.state = 2242;
                this.match(GremlinParser.COMMA);
                this.state = 2243;
                this.integerArgument();
                this.state = 2244;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_read(): TraversalMethod_readContext {
        let localContext = new TraversalMethod_readContext(this.context, this.state);
        this.enterRule(localContext, 268, GremlinParser.RULE_traversalMethod_read);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2248;
            this.match(GremlinParser.K_READ);
            this.state = 2249;
            this.match(GremlinParser.LPAREN);
            this.state = 2250;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_repeat(): TraversalMethod_repeatContext {
        let localContext = new TraversalMethod_repeatContext(this.context, this.state);
        this.enterRule(localContext, 270, GremlinParser.RULE_traversalMethod_repeat);
        try {
            this.state = 2264;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 87, this.context) ) {
            case 1:
                localContext = new TraversalMethod_repeat_String_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2252;
                this.match(GremlinParser.K_REPEAT);
                this.state = 2253;
                this.match(GremlinParser.LPAREN);
                this.state = 2254;
                this.stringLiteral();
                this.state = 2255;
                this.match(GremlinParser.COMMA);
                this.state = 2256;
                this.nestedTraversal();
                this.state = 2257;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_repeat_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2259;
                this.match(GremlinParser.K_REPEAT);
                this.state = 2260;
                this.match(GremlinParser.LPAREN);
                this.state = 2261;
                this.nestedTraversal();
                this.state = 2262;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_replace(): TraversalMethod_replaceContext {
        let localContext = new TraversalMethod_replaceContext(this.context, this.state);
        this.enterRule(localContext, 272, GremlinParser.RULE_traversalMethod_replace);
        try {
            this.state = 2282;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 88, this.context) ) {
            case 1:
                localContext = new TraversalMethod_replace_String_StringContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2266;
                this.match(GremlinParser.K_REPLACE);
                this.state = 2267;
                this.match(GremlinParser.LPAREN);
                this.state = 2268;
                this.stringNullableLiteral();
                this.state = 2269;
                this.match(GremlinParser.COMMA);
                this.state = 2270;
                this.stringNullableLiteral();
                this.state = 2271;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_replace_Scope_String_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2273;
                this.match(GremlinParser.K_REPLACE);
                this.state = 2274;
                this.match(GremlinParser.LPAREN);
                this.state = 2275;
                this.traversalScope();
                this.state = 2276;
                this.match(GremlinParser.COMMA);
                this.state = 2277;
                this.stringNullableLiteral();
                this.state = 2278;
                this.match(GremlinParser.COMMA);
                this.state = 2279;
                this.stringNullableLiteral();
                this.state = 2280;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_reverse(): TraversalMethod_reverseContext {
        let localContext = new TraversalMethod_reverseContext(this.context, this.state);
        this.enterRule(localContext, 274, GremlinParser.RULE_traversalMethod_reverse);
        try {
            localContext = new TraversalMethod_reverse_EmptyContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2284;
            this.match(GremlinParser.K_REVERSE);
            this.state = 2285;
            this.match(GremlinParser.LPAREN);
            this.state = 2286;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_rTrim(): TraversalMethod_rTrimContext {
        let localContext = new TraversalMethod_rTrimContext(this.context, this.state);
        this.enterRule(localContext, 276, GremlinParser.RULE_traversalMethod_rTrim);
        try {
            this.state = 2296;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 89, this.context) ) {
            case 1:
                localContext = new TraversalMethod_rTrim_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2288;
                this.match(GremlinParser.K_RTRIM);
                this.state = 2289;
                this.match(GremlinParser.LPAREN);
                this.state = 2290;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_rTrim_ScopeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2291;
                this.match(GremlinParser.K_RTRIM);
                this.state = 2292;
                this.match(GremlinParser.LPAREN);
                this.state = 2293;
                this.traversalScope();
                this.state = 2294;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_sack(): TraversalMethod_sackContext {
        let localContext = new TraversalMethod_sackContext(this.context, this.state);
        this.enterRule(localContext, 278, GremlinParser.RULE_traversalMethod_sack);
        try {
            this.state = 2306;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 90, this.context) ) {
            case 1:
                localContext = new TraversalMethod_sack_BiFunctionContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2298;
                this.match(GremlinParser.K_SACK);
                this.state = 2299;
                this.match(GremlinParser.LPAREN);
                this.state = 2300;
                this.traversalBiFunction();
                this.state = 2301;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_sack_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2303;
                this.match(GremlinParser.K_SACK);
                this.state = 2304;
                this.match(GremlinParser.LPAREN);
                this.state = 2305;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_sample(): TraversalMethod_sampleContext {
        let localContext = new TraversalMethod_sampleContext(this.context, this.state);
        this.enterRule(localContext, 280, GremlinParser.RULE_traversalMethod_sample);
        try {
            this.state = 2320;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 91, this.context) ) {
            case 1:
                localContext = new TraversalMethod_sample_Scope_intContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2308;
                this.match(GremlinParser.K_SAMPLE);
                this.state = 2309;
                this.match(GremlinParser.LPAREN);
                this.state = 2310;
                this.traversalScope();
                this.state = 2311;
                this.match(GremlinParser.COMMA);
                this.state = 2312;
                this.integerLiteral();
                this.state = 2313;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_sample_intContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2315;
                this.match(GremlinParser.K_SAMPLE);
                this.state = 2316;
                this.match(GremlinParser.LPAREN);
                this.state = 2317;
                this.integerLiteral();
                this.state = 2318;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_select(): TraversalMethod_selectContext {
        let localContext = new TraversalMethod_selectContext(this.context, this.state);
        this.enterRule(localContext, 282, GremlinParser.RULE_traversalMethod_select);
        let _la: number;
        try {
            this.state = 2375;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 94, this.context) ) {
            case 1:
                localContext = new TraversalMethod_select_ColumnContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2322;
                this.match(GremlinParser.K_SELECT);
                this.state = 2323;
                this.match(GremlinParser.LPAREN);
                this.state = 2324;
                this.traversalColumn();
                this.state = 2325;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_select_Pop_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2327;
                this.match(GremlinParser.K_SELECT);
                this.state = 2328;
                this.match(GremlinParser.LPAREN);
                this.state = 2329;
                this.traversalPop();
                this.state = 2330;
                this.match(GremlinParser.COMMA);
                this.state = 2331;
                this.stringLiteral();
                this.state = 2332;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_select_Pop_String_String_StringContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2334;
                this.match(GremlinParser.K_SELECT);
                this.state = 2335;
                this.match(GremlinParser.LPAREN);
                this.state = 2336;
                this.traversalPop();
                this.state = 2337;
                this.match(GremlinParser.COMMA);
                this.state = 2338;
                this.stringLiteral();
                this.state = 2339;
                this.match(GremlinParser.COMMA);
                this.state = 2340;
                this.stringLiteral();
                this.state = 2343;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 320) {
                    {
                    this.state = 2341;
                    this.match(GremlinParser.COMMA);
                    this.state = 2342;
                    this.stringNullableLiteralVarargs();
                    }
                }

                this.state = 2345;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 4:
                localContext = new TraversalMethod_select_Pop_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2347;
                this.match(GremlinParser.K_SELECT);
                this.state = 2348;
                this.match(GremlinParser.LPAREN);
                this.state = 2349;
                this.traversalPop();
                this.state = 2350;
                this.match(GremlinParser.COMMA);
                this.state = 2351;
                this.nestedTraversal();
                this.state = 2352;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 5:
                localContext = new TraversalMethod_select_StringContext(localContext);
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2354;
                this.match(GremlinParser.K_SELECT);
                this.state = 2355;
                this.match(GremlinParser.LPAREN);
                this.state = 2356;
                this.stringLiteral();
                this.state = 2357;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 6:
                localContext = new TraversalMethod_select_String_String_StringContext(localContext);
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 2359;
                this.match(GremlinParser.K_SELECT);
                this.state = 2360;
                this.match(GremlinParser.LPAREN);
                this.state = 2361;
                this.stringLiteral();
                this.state = 2362;
                this.match(GremlinParser.COMMA);
                this.state = 2363;
                this.stringLiteral();
                this.state = 2366;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 320) {
                    {
                    this.state = 2364;
                    this.match(GremlinParser.COMMA);
                    this.state = 2365;
                    this.stringNullableLiteralVarargs();
                    }
                }

                this.state = 2368;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 7:
                localContext = new TraversalMethod_select_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 2370;
                this.match(GremlinParser.K_SELECT);
                this.state = 2371;
                this.match(GremlinParser.LPAREN);
                this.state = 2372;
                this.nestedTraversal();
                this.state = 2373;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_shortestPath(): TraversalMethod_shortestPathContext {
        let localContext = new TraversalMethod_shortestPathContext(this.context, this.state);
        this.enterRule(localContext, 284, GremlinParser.RULE_traversalMethod_shortestPath);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2377;
            this.match(GremlinParser.K_SHORTESTPATH);
            this.state = 2378;
            this.match(GremlinParser.LPAREN);
            this.state = 2379;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_sideEffect(): TraversalMethod_sideEffectContext {
        let localContext = new TraversalMethod_sideEffectContext(this.context, this.state);
        this.enterRule(localContext, 286, GremlinParser.RULE_traversalMethod_sideEffect);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2381;
            this.match(GremlinParser.K_SIDEEFFECT);
            this.state = 2382;
            this.match(GremlinParser.LPAREN);
            this.state = 2383;
            this.nestedTraversal();
            this.state = 2384;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_simplePath(): TraversalMethod_simplePathContext {
        let localContext = new TraversalMethod_simplePathContext(this.context, this.state);
        this.enterRule(localContext, 288, GremlinParser.RULE_traversalMethod_simplePath);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2386;
            this.match(GremlinParser.K_SIMPLEPATH);
            this.state = 2387;
            this.match(GremlinParser.LPAREN);
            this.state = 2388;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_skip(): TraversalMethod_skipContext {
        let localContext = new TraversalMethod_skipContext(this.context, this.state);
        this.enterRule(localContext, 290, GremlinParser.RULE_traversalMethod_skip);
        try {
            this.state = 2402;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 95, this.context) ) {
            case 1:
                localContext = new TraversalMethod_skip_Scope_longContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2390;
                this.match(GremlinParser.K_SKIP);
                this.state = 2391;
                this.match(GremlinParser.LPAREN);
                this.state = 2392;
                this.traversalScope();
                this.state = 2393;
                this.match(GremlinParser.COMMA);
                this.state = 2394;
                this.integerArgument();
                this.state = 2395;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_skip_longContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2397;
                this.match(GremlinParser.K_SKIP);
                this.state = 2398;
                this.match(GremlinParser.LPAREN);
                this.state = 2399;
                this.integerArgument();
                this.state = 2400;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_split(): TraversalMethod_splitContext {
        let localContext = new TraversalMethod_splitContext(this.context, this.state);
        this.enterRule(localContext, 292, GremlinParser.RULE_traversalMethod_split);
        try {
            this.state = 2416;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 96, this.context) ) {
            case 1:
                localContext = new TraversalMethod_split_StringContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2404;
                this.match(GremlinParser.K_SPLIT);
                this.state = 2405;
                this.match(GremlinParser.LPAREN);
                this.state = 2406;
                this.stringNullableLiteral();
                this.state = 2407;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_split_Scope_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2409;
                this.match(GremlinParser.K_SPLIT);
                this.state = 2410;
                this.match(GremlinParser.LPAREN);
                this.state = 2411;
                this.traversalScope();
                this.state = 2412;
                this.match(GremlinParser.COMMA);
                this.state = 2413;
                this.stringNullableLiteral();
                this.state = 2414;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_subgraph(): TraversalMethod_subgraphContext {
        let localContext = new TraversalMethod_subgraphContext(this.context, this.state);
        this.enterRule(localContext, 294, GremlinParser.RULE_traversalMethod_subgraph);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2418;
            this.match(GremlinParser.K_SUBGRAPH);
            this.state = 2419;
            this.match(GremlinParser.LPAREN);
            this.state = 2420;
            this.stringLiteral();
            this.state = 2421;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_substring(): TraversalMethod_substringContext {
        let localContext = new TraversalMethod_substringContext(this.context, this.state);
        this.enterRule(localContext, 296, GremlinParser.RULE_traversalMethod_substring);
        try {
            this.state = 2451;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 97, this.context) ) {
            case 1:
                localContext = new TraversalMethod_substring_intContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2423;
                this.match(GremlinParser.K_SUBSTRING);
                this.state = 2424;
                this.match(GremlinParser.LPAREN);
                this.state = 2425;
                this.integerLiteral();
                this.state = 2426;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_substring_Scope_intContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2428;
                this.match(GremlinParser.K_SUBSTRING);
                this.state = 2429;
                this.match(GremlinParser.LPAREN);
                this.state = 2430;
                this.traversalScope();
                this.state = 2431;
                this.match(GremlinParser.COMMA);
                this.state = 2432;
                this.integerLiteral();
                this.state = 2433;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_substring_int_intContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2435;
                this.match(GremlinParser.K_SUBSTRING);
                this.state = 2436;
                this.match(GremlinParser.LPAREN);
                this.state = 2437;
                this.integerLiteral();
                this.state = 2438;
                this.match(GremlinParser.COMMA);
                this.state = 2439;
                this.integerLiteral();
                this.state = 2440;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 4:
                localContext = new TraversalMethod_substring_Scope_int_intContext(localContext);
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2442;
                this.match(GremlinParser.K_SUBSTRING);
                this.state = 2443;
                this.match(GremlinParser.LPAREN);
                this.state = 2444;
                this.traversalScope();
                this.state = 2445;
                this.match(GremlinParser.COMMA);
                this.state = 2446;
                this.integerLiteral();
                this.state = 2447;
                this.match(GremlinParser.COMMA);
                this.state = 2448;
                this.integerLiteral();
                this.state = 2449;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_sum(): TraversalMethod_sumContext {
        let localContext = new TraversalMethod_sumContext(this.context, this.state);
        this.enterRule(localContext, 298, GremlinParser.RULE_traversalMethod_sum);
        try {
            this.state = 2461;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 98, this.context) ) {
            case 1:
                localContext = new TraversalMethod_sum_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2453;
                this.match(GremlinParser.K_SUM);
                this.state = 2454;
                this.match(GremlinParser.LPAREN);
                this.state = 2455;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_sum_ScopeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2456;
                this.match(GremlinParser.K_SUM);
                this.state = 2457;
                this.match(GremlinParser.LPAREN);
                this.state = 2458;
                this.traversalScope();
                this.state = 2459;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_tail(): TraversalMethod_tailContext {
        let localContext = new TraversalMethod_tailContext(this.context, this.state);
        this.enterRule(localContext, 300, GremlinParser.RULE_traversalMethod_tail);
        try {
            this.state = 2483;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 99, this.context) ) {
            case 1:
                localContext = new TraversalMethod_tail_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2463;
                this.match(GremlinParser.K_TAIL);
                this.state = 2464;
                this.match(GremlinParser.LPAREN);
                this.state = 2465;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_tail_ScopeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2466;
                this.match(GremlinParser.K_TAIL);
                this.state = 2467;
                this.match(GremlinParser.LPAREN);
                this.state = 2468;
                this.traversalScope();
                this.state = 2469;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_tail_Scope_longContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2471;
                this.match(GremlinParser.K_TAIL);
                this.state = 2472;
                this.match(GremlinParser.LPAREN);
                this.state = 2473;
                this.traversalScope();
                this.state = 2474;
                this.match(GremlinParser.COMMA);
                this.state = 2475;
                this.integerArgument();
                this.state = 2476;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 4:
                localContext = new TraversalMethod_tail_longContext(localContext);
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2478;
                this.match(GremlinParser.K_TAIL);
                this.state = 2479;
                this.match(GremlinParser.LPAREN);
                this.state = 2480;
                this.integerArgument();
                this.state = 2481;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_timeLimit(): TraversalMethod_timeLimitContext {
        let localContext = new TraversalMethod_timeLimitContext(this.context, this.state);
        this.enterRule(localContext, 302, GremlinParser.RULE_traversalMethod_timeLimit);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2485;
            this.match(GremlinParser.K_TIMELIMIT);
            this.state = 2486;
            this.match(GremlinParser.LPAREN);
            this.state = 2487;
            this.integerLiteral();
            this.state = 2488;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_times(): TraversalMethod_timesContext {
        let localContext = new TraversalMethod_timesContext(this.context, this.state);
        this.enterRule(localContext, 304, GremlinParser.RULE_traversalMethod_times);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2490;
            this.match(GremlinParser.K_TIMES);
            this.state = 2491;
            this.match(GremlinParser.LPAREN);
            this.state = 2492;
            this.integerLiteral();
            this.state = 2493;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_to(): TraversalMethod_toContext {
        let localContext = new TraversalMethod_toContext(this.context, this.state);
        this.enterRule(localContext, 306, GremlinParser.RULE_traversalMethod_to);
        let _la: number;
        try {
            this.state = 2514;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 101, this.context) ) {
            case 1:
                localContext = new TraversalMethod_to_Direction_StringContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2495;
                this.match(GremlinParser.K_TO);
                this.state = 2496;
                this.match(GremlinParser.LPAREN);
                this.state = 2497;
                this.traversalDirection();
                this.state = 2500;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 320) {
                    {
                    this.state = 2498;
                    this.match(GremlinParser.COMMA);
                    this.state = 2499;
                    this.stringNullableArgumentVarargs();
                    }
                }

                this.state = 2502;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_to_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2504;
                this.match(GremlinParser.K_TO);
                this.state = 2505;
                this.match(GremlinParser.LPAREN);
                this.state = 2506;
                this.stringLiteral();
                this.state = 2507;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_to_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2509;
                this.match(GremlinParser.K_TO);
                this.state = 2510;
                this.match(GremlinParser.LPAREN);
                this.state = 2511;
                this.nestedTraversal();
                this.state = 2512;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_toE(): TraversalMethod_toEContext {
        let localContext = new TraversalMethod_toEContext(this.context, this.state);
        this.enterRule(localContext, 308, GremlinParser.RULE_traversalMethod_toE);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2516;
            this.match(GremlinParser.K_TOE);
            this.state = 2517;
            this.match(GremlinParser.LPAREN);
            this.state = 2518;
            this.traversalDirection();
            this.state = 2521;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 320) {
                {
                this.state = 2519;
                this.match(GremlinParser.COMMA);
                this.state = 2520;
                this.stringNullableArgumentVarargs();
                }
            }

            this.state = 2523;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_toLower(): TraversalMethod_toLowerContext {
        let localContext = new TraversalMethod_toLowerContext(this.context, this.state);
        this.enterRule(localContext, 310, GremlinParser.RULE_traversalMethod_toLower);
        try {
            this.state = 2533;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 103, this.context) ) {
            case 1:
                localContext = new TraversalMethod_toLower_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2525;
                this.match(GremlinParser.K_TOLOWER);
                this.state = 2526;
                this.match(GremlinParser.LPAREN);
                this.state = 2527;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_toLower_ScopeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2528;
                this.match(GremlinParser.K_TOLOWER);
                this.state = 2529;
                this.match(GremlinParser.LPAREN);
                this.state = 2530;
                this.traversalScope();
                this.state = 2531;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_toUpper(): TraversalMethod_toUpperContext {
        let localContext = new TraversalMethod_toUpperContext(this.context, this.state);
        this.enterRule(localContext, 312, GremlinParser.RULE_traversalMethod_toUpper);
        try {
            this.state = 2543;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 104, this.context) ) {
            case 1:
                localContext = new TraversalMethod_toUpper_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2535;
                this.match(GremlinParser.K_TOUPPER);
                this.state = 2536;
                this.match(GremlinParser.LPAREN);
                this.state = 2537;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_toUpper_ScopeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2538;
                this.match(GremlinParser.K_TOUPPER);
                this.state = 2539;
                this.match(GremlinParser.LPAREN);
                this.state = 2540;
                this.traversalScope();
                this.state = 2541;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_toV(): TraversalMethod_toVContext {
        let localContext = new TraversalMethod_toVContext(this.context, this.state);
        this.enterRule(localContext, 314, GremlinParser.RULE_traversalMethod_toV);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2545;
            this.match(GremlinParser.K_TOV);
            this.state = 2546;
            this.match(GremlinParser.LPAREN);
            this.state = 2547;
            this.traversalDirection();
            this.state = 2548;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_tree(): TraversalMethod_treeContext {
        let localContext = new TraversalMethod_treeContext(this.context, this.state);
        this.enterRule(localContext, 316, GremlinParser.RULE_traversalMethod_tree);
        try {
            this.state = 2558;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 105, this.context) ) {
            case 1:
                localContext = new TraversalMethod_tree_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2550;
                this.match(GremlinParser.K_TREE);
                this.state = 2551;
                this.match(GremlinParser.LPAREN);
                this.state = 2552;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_tree_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2553;
                this.match(GremlinParser.K_TREE);
                this.state = 2554;
                this.match(GremlinParser.LPAREN);
                this.state = 2555;
                this.stringLiteral();
                this.state = 2556;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_trim(): TraversalMethod_trimContext {
        let localContext = new TraversalMethod_trimContext(this.context, this.state);
        this.enterRule(localContext, 318, GremlinParser.RULE_traversalMethod_trim);
        try {
            this.state = 2568;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 106, this.context) ) {
            case 1:
                localContext = new TraversalMethod_trim_EmptyContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2560;
                this.match(GremlinParser.K_TRIM);
                this.state = 2561;
                this.match(GremlinParser.LPAREN);
                this.state = 2562;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_trim_ScopeContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2563;
                this.match(GremlinParser.K_TRIM);
                this.state = 2564;
                this.match(GremlinParser.LPAREN);
                this.state = 2565;
                this.traversalScope();
                this.state = 2566;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_unfold(): TraversalMethod_unfoldContext {
        let localContext = new TraversalMethod_unfoldContext(this.context, this.state);
        this.enterRule(localContext, 320, GremlinParser.RULE_traversalMethod_unfold);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2570;
            this.match(GremlinParser.K_UNFOLD);
            this.state = 2571;
            this.match(GremlinParser.LPAREN);
            this.state = 2572;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_union(): TraversalMethod_unionContext {
        let localContext = new TraversalMethod_unionContext(this.context, this.state);
        this.enterRule(localContext, 322, GremlinParser.RULE_traversalMethod_union);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2574;
            this.match(GremlinParser.K_UNION);
            this.state = 2575;
            this.match(GremlinParser.LPAREN);
            this.state = 2576;
            this.nestedTraversalList();
            this.state = 2577;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_until(): TraversalMethod_untilContext {
        let localContext = new TraversalMethod_untilContext(this.context, this.state);
        this.enterRule(localContext, 324, GremlinParser.RULE_traversalMethod_until);
        try {
            this.state = 2589;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 107, this.context) ) {
            case 1:
                localContext = new TraversalMethod_until_PredicateContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2579;
                this.match(GremlinParser.K_UNTIL);
                this.state = 2580;
                this.match(GremlinParser.LPAREN);
                this.state = 2581;
                this.traversalPredicate(0);
                this.state = 2582;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_until_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2584;
                this.match(GremlinParser.K_UNTIL);
                this.state = 2585;
                this.match(GremlinParser.LPAREN);
                this.state = 2586;
                this.nestedTraversal();
                this.state = 2587;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_value(): TraversalMethod_valueContext {
        let localContext = new TraversalMethod_valueContext(this.context, this.state);
        this.enterRule(localContext, 326, GremlinParser.RULE_traversalMethod_value);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2591;
            this.match(GremlinParser.K_VALUE);
            this.state = 2592;
            this.match(GremlinParser.LPAREN);
            this.state = 2593;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_valueMap(): TraversalMethod_valueMapContext {
        let localContext = new TraversalMethod_valueMapContext(this.context, this.state);
        this.enterRule(localContext, 328, GremlinParser.RULE_traversalMethod_valueMap);
        let _la: number;
        try {
            this.state = 2609;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 109, this.context) ) {
            case 1:
                localContext = new TraversalMethod_valueMap_StringContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2595;
                this.match(GremlinParser.K_VALUEMAP);
                this.state = 2596;
                this.match(GremlinParser.LPAREN);
                this.state = 2597;
                this.stringNullableLiteralVarargs();
                this.state = 2598;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_valueMap_boolean_StringContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2600;
                this.match(GremlinParser.K_VALUEMAP);
                this.state = 2601;
                this.match(GremlinParser.LPAREN);
                this.state = 2602;
                this.booleanLiteral();
                this.state = 2605;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 320) {
                    {
                    this.state = 2603;
                    this.match(GremlinParser.COMMA);
                    this.state = 2604;
                    this.stringNullableLiteralVarargs();
                    }
                }

                this.state = 2607;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_values(): TraversalMethod_valuesContext {
        let localContext = new TraversalMethod_valuesContext(this.context, this.state);
        this.enterRule(localContext, 330, GremlinParser.RULE_traversalMethod_values);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2611;
            this.match(GremlinParser.K_VALUES);
            this.state = 2612;
            this.match(GremlinParser.LPAREN);
            this.state = 2613;
            this.stringNullableLiteralVarargs();
            this.state = 2614;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_where(): TraversalMethod_whereContext {
        let localContext = new TraversalMethod_whereContext(this.context, this.state);
        this.enterRule(localContext, 332, GremlinParser.RULE_traversalMethod_where);
        try {
            this.state = 2633;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 110, this.context) ) {
            case 1:
                localContext = new TraversalMethod_where_PContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2616;
                this.match(GremlinParser.K_WHERE);
                this.state = 2617;
                this.match(GremlinParser.LPAREN);
                this.state = 2618;
                this.traversalPredicate(0);
                this.state = 2619;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_where_String_PContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2621;
                this.match(GremlinParser.K_WHERE);
                this.state = 2622;
                this.match(GremlinParser.LPAREN);
                this.state = 2623;
                this.stringLiteral();
                this.state = 2624;
                this.match(GremlinParser.COMMA);
                this.state = 2625;
                this.traversalPredicate(0);
                this.state = 2626;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                localContext = new TraversalMethod_where_TraversalContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2628;
                this.match(GremlinParser.K_WHERE);
                this.state = 2629;
                this.match(GremlinParser.LPAREN);
                this.state = 2630;
                this.nestedTraversal();
                this.state = 2631;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_with(): TraversalMethod_withContext {
        let localContext = new TraversalMethod_withContext(this.context, this.state);
        this.enterRule(localContext, 334, GremlinParser.RULE_traversalMethod_with);
        try {
            this.state = 2657;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 114, this.context) ) {
            case 1:
                localContext = new TraversalMethod_with_StringContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2635;
                this.match(GremlinParser.K_WITH);
                this.state = 2636;
                this.match(GremlinParser.LPAREN);
                this.state = 2639;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_CONNECTEDCOMPONENTU:
                case GremlinParser.K_IOU:
                case GremlinParser.K_PAGERANKU:
                case GremlinParser.K_PEERPRESSUREU:
                case GremlinParser.K_SHORTESTPATHU:
                case GremlinParser.K_WITHOPTOPTIONS:
                    {
                    this.state = 2637;
                    this.withOptionKeys();
                    }
                    break;
                case GremlinParser.StringSuffixLiteral:
                case GremlinParser.EmptyStringSuffixLiteral:
                case GremlinParser.NonEmptyStringLiteral:
                case GremlinParser.EmptyStringLiteral:
                    {
                    this.state = 2638;
                    this.stringLiteral();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 2641;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                localContext = new TraversalMethod_with_String_ObjectContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2643;
                this.match(GremlinParser.K_WITH);
                this.state = 2644;
                this.match(GremlinParser.LPAREN);
                this.state = 2647;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_CONNECTEDCOMPONENTU:
                case GremlinParser.K_IOU:
                case GremlinParser.K_PAGERANKU:
                case GremlinParser.K_PEERPRESSUREU:
                case GremlinParser.K_SHORTESTPATHU:
                case GremlinParser.K_WITHOPTOPTIONS:
                    {
                    this.state = 2645;
                    this.withOptionKeys();
                    }
                    break;
                case GremlinParser.StringSuffixLiteral:
                case GremlinParser.EmptyStringSuffixLiteral:
                case GremlinParser.NonEmptyStringLiteral:
                case GremlinParser.EmptyStringLiteral:
                    {
                    this.state = 2646;
                    this.stringLiteral();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 2649;
                this.match(GremlinParser.COMMA);
                this.state = 2653;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_WITHOPTOPTIONS:
                    {
                    this.state = 2650;
                    this.withOptionsValues();
                    }
                    break;
                case GremlinParser.K_IOU:
                    {
                    this.state = 2651;
                    this.ioOptionsValues();
                    }
                    break;
                case GremlinParser.K_ADDE:
                case GremlinParser.K_ADDLABEL:
                case GremlinParser.K_ADDV:
                case GremlinParser.K_AGGREGATE:
                case GremlinParser.K_ALL:
                case GremlinParser.K_AND:
                case GremlinParser.K_ANY:
                case GremlinParser.K_AS:
                case GremlinParser.K_ASBOOL:
                case GremlinParser.K_ASDATE:
                case GremlinParser.K_ASNUMBER:
                case GremlinParser.K_ASSTRING:
                case GremlinParser.K_BARRIER:
                case GremlinParser.K_BIGDECIMAL:
                case GremlinParser.K_BIGDECIMALU:
                case GremlinParser.K_BIGINT:
                case GremlinParser.K_BIGINTU:
                case GremlinParser.K_BINARY:
                case GremlinParser.K_BINARYC:
                case GremlinParser.K_BINARYU:
                case GremlinParser.K_BOOLEAN:
                case GremlinParser.K_BOOLEANU:
                case GremlinParser.K_BOTH:
                case GremlinParser.K_BOTHU:
                case GremlinParser.K_BOTHE:
                case GremlinParser.K_BOTHV:
                case GremlinParser.K_BRANCH:
                case GremlinParser.K_BY:
                case GremlinParser.K_BYTE:
                case GremlinParser.K_BYTEU:
                case GremlinParser.K_CALL:
                case GremlinParser.K_CAP:
                case GremlinParser.K_CARDINALITY:
                case GremlinParser.K_CHAR:
                case GremlinParser.K_CHARU:
                case GremlinParser.K_CHOOSE:
                case GremlinParser.K_COALESCE:
                case GremlinParser.K_COIN:
                case GremlinParser.K_COMBINE:
                case GremlinParser.K_CONCAT:
                case GremlinParser.K_CONJOIN:
                case GremlinParser.K_CONNECTEDCOMPONENT:
                case GremlinParser.K_CONSTANT:
                case GremlinParser.K_COUNT:
                case GremlinParser.K_CYCLICPATH:
                case GremlinParser.K_DAY:
                case GremlinParser.K_DATEADD:
                case GremlinParser.K_DATEDIFF:
                case GremlinParser.K_DATETIME:
                case GremlinParser.K_DATETIMEC:
                case GremlinParser.K_DATETIMEU:
                case GremlinParser.K_DEDUP:
                case GremlinParser.K_DIFFERENCE:
                case GremlinParser.K_DISCARD:
                case GremlinParser.K_DIRECTION:
                case GremlinParser.K_DISJUNCT:
                case GremlinParser.K_DOUBLE:
                case GremlinParser.K_DOUBLEU:
                case GremlinParser.K_DROP:
                case GremlinParser.K_DROPLABEL:
                case GremlinParser.K_DROPLABELS:
                case GremlinParser.K_DT:
                case GremlinParser.K_DURATION:
                case GremlinParser.K_DURATIONC:
                case GremlinParser.K_DURATIONU:
                case GremlinParser.K_E:
                case GremlinParser.K_EDGE:
                case GremlinParser.K_EDGEU:
                case GremlinParser.K_ELEMENTMAP:
                case GremlinParser.K_ELEMENT:
                case GremlinParser.K_EMIT:
                case GremlinParser.K_FAIL:
                case GremlinParser.K_FALSE:
                case GremlinParser.K_FILTER:
                case GremlinParser.K_FLATMAP:
                case GremlinParser.K_FLOAT:
                case GremlinParser.K_FLOATU:
                case GremlinParser.K_FOLD:
                case GremlinParser.K_FORMAT:
                case GremlinParser.K_FROM:
                case GremlinParser.K_GTYPE:
                case GremlinParser.K_GROUPCOUNT:
                case GremlinParser.K_GROUP:
                case GremlinParser.K_GRAPH:
                case GremlinParser.K_GRAPHU:
                case GremlinParser.K_HAS:
                case GremlinParser.K_HASID:
                case GremlinParser.K_HASKEY:
                case GremlinParser.K_HASLABEL:
                case GremlinParser.K_HASNOT:
                case GremlinParser.K_HASVALUE:
                case GremlinParser.K_HOUR:
                case GremlinParser.K_ID:
                case GremlinParser.K_IDENTITY:
                case GremlinParser.K_IN:
                case GremlinParser.K_INU:
                case GremlinParser.K_INE:
                case GremlinParser.K_INDEX:
                case GremlinParser.K_INFINITY:
                case GremlinParser.K_INJECT:
                case GremlinParser.K_INT:
                case GremlinParser.K_INTU:
                case GremlinParser.K_INTERSECT:
                case GremlinParser.K_INV:
                case GremlinParser.K_IS:
                case GremlinParser.K_KEY:
                case GremlinParser.K_LABELS:
                case GremlinParser.K_LABEL:
                case GremlinParser.K_LENGTH:
                case GremlinParser.K_LIMIT:
                case GremlinParser.K_LIST:
                case GremlinParser.K_LISTU:
                case GremlinParser.K_LOCAL:
                case GremlinParser.K_LONG:
                case GremlinParser.K_LONGU:
                case GremlinParser.K_LOOPS:
                case GremlinParser.K_LTRIM:
                case GremlinParser.K_MAP:
                case GremlinParser.K_MAPU:
                case GremlinParser.K_MATCH:
                case GremlinParser.K_MATH:
                case GremlinParser.K_MAX:
                case GremlinParser.K_MEAN:
                case GremlinParser.K_MERGEU:
                case GremlinParser.K_MERGE:
                case GremlinParser.K_MERGEE:
                case GremlinParser.K_MERGEV:
                case GremlinParser.K_MIN:
                case GremlinParser.K_MINUTE:
                case GremlinParser.K_NAN:
                case GremlinParser.K_NONE:
                case GremlinParser.K_NOT:
                case GremlinParser.K_NULL:
                case GremlinParser.K_NULLU:
                case GremlinParser.K_NUMBER:
                case GremlinParser.K_NUMBERU:
                case GremlinParser.K_ONCREATE:
                case GremlinParser.K_ONMATCH:
                case GremlinParser.K_OPTION:
                case GremlinParser.K_OPTIONAL:
                case GremlinParser.K_ORDER:
                case GremlinParser.K_OR:
                case GremlinParser.K_OTHERV:
                case GremlinParser.K_OUTU:
                case GremlinParser.K_OUT:
                case GremlinParser.K_OUTE:
                case GremlinParser.K_OUTV:
                case GremlinParser.K_PAGERANK:
                case GremlinParser.K_PATH:
                case GremlinParser.K_PATHU:
                case GremlinParser.K_PDT:
                case GremlinParser.K_PEERPRESSURE:
                case GremlinParser.K_PICK:
                case GremlinParser.K_PROFILE:
                case GremlinParser.K_PROJECT:
                case GremlinParser.K_PROPERTIES:
                case GremlinParser.K_PROPERTYMAP:
                case GremlinParser.K_PROPERTY:
                case GremlinParser.K_PROPERTYU:
                case GremlinParser.K_PRODUCT:
                case GremlinParser.K_RANGE:
                case GremlinParser.K_READ:
                case GremlinParser.K_REPLACE:
                case GremlinParser.K_REPEAT:
                case GremlinParser.K_REVERSE:
                case GremlinParser.K_RTRIM:
                case GremlinParser.K_SACK:
                case GremlinParser.K_SAMPLE:
                case GremlinParser.K_SECOND:
                case GremlinParser.K_SELECT:
                case GremlinParser.K_SET:
                case GremlinParser.K_SETU:
                case GremlinParser.K_SHORTESTPATH:
                case GremlinParser.K_SHORT:
                case GremlinParser.K_SHORTU:
                case GremlinParser.K_SIDEEFFECT:
                case GremlinParser.K_SIMPLEPATH:
                case GremlinParser.K_SINGLE:
                case GremlinParser.K_SKIP:
                case GremlinParser.K_SPLIT:
                case GremlinParser.K_STRING:
                case GremlinParser.K_STRINGU:
                case GremlinParser.K_SUBGRAPH:
                case GremlinParser.K_SUBSTRING:
                case GremlinParser.K_SUM:
                case GremlinParser.K_T:
                case GremlinParser.K_TAIL:
                case GremlinParser.K_TIMELIMIT:
                case GremlinParser.K_TIMES:
                case GremlinParser.K_TO:
                case GremlinParser.K_TOLOWER:
                case GremlinParser.K_TOUPPER:
                case GremlinParser.K_TOE:
                case GremlinParser.K_TOV:
                case GremlinParser.K_TREE:
                case GremlinParser.K_TREEU:
                case GremlinParser.K_TRIM:
                case GremlinParser.K_TRUE:
                case GremlinParser.K_UNFOLD:
                case GremlinParser.K_UNION:
                case GremlinParser.K_UNPRODUCTIVE:
                case GremlinParser.K_UNTIL:
                case GremlinParser.K_UUID:
                case GremlinParser.K_UUIDL:
                case GremlinParser.K_V:
                case GremlinParser.K_VALUEMAP:
                case GremlinParser.K_VALUES:
                case GremlinParser.K_VALUE:
                case GremlinParser.K_VERTEX:
                case GremlinParser.K_VERTEXU:
                case GremlinParser.K_VPROPERTY:
                case GremlinParser.K_VPROPERTYU:
                case GremlinParser.K_WHERE:
                case GremlinParser.K_WITH:
                case GremlinParser.K_WRITE:
                case GremlinParser.IntegerLiteral:
                case GremlinParser.FloatingPointLiteral:
                case GremlinParser.SignedInfLiteral:
                case GremlinParser.CharacterLiteral:
                case GremlinParser.StringSuffixLiteral:
                case GremlinParser.EmptyStringSuffixLiteral:
                case GremlinParser.NonEmptyStringLiteral:
                case GremlinParser.EmptyStringLiteral:
                case GremlinParser.LBRACE:
                case GremlinParser.LBRACK:
                case GremlinParser.TRAVERSAL_ROOT:
                case GremlinParser.ANON_TRAVERSAL_ROOT:
                    {
                    this.state = 2652;
                    this.genericLiteral();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 2655;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMethod_write(): TraversalMethod_writeContext {
        let localContext = new TraversalMethod_writeContext(this.context, this.state);
        this.enterRule(localContext, 336, GremlinParser.RULE_traversalMethod_write);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2659;
            this.match(GremlinParser.K_WRITE);
            this.state = 2660;
            this.match(GremlinParser.LPAREN);
            this.state = 2661;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalStrategy(): TraversalStrategyContext {
        let localContext = new TraversalStrategyContext(this.context, this.state);
        this.enterRule(localContext, 338, GremlinParser.RULE_traversalStrategy);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2664;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 184) {
                {
                this.state = 2663;
                this.match(GremlinParser.K_NEW);
                }
            }

            this.state = 2666;
            this.classType();
            this.state = 2679;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 313) {
                {
                this.state = 2667;
                this.match(GremlinParser.LPAREN);
                this.state = 2676;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4294967295) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967295) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967295) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 131071) !== 0) || _la === 323 || _la === 327) {
                    {
                    this.state = 2668;
                    this.configuration();
                    this.state = 2673;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 320) {
                        {
                        {
                        this.state = 2669;
                        this.match(GremlinParser.COMMA);
                        this.state = 2670;
                        this.configuration();
                        }
                        }
                        this.state = 2675;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    }
                }

                this.state = 2678;
                this.match(GremlinParser.RPAREN);
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public configuration(): ConfigurationContext {
        let localContext = new ConfigurationContext(this.context, this.state);
        this.enterRule(localContext, 340, GremlinParser.RULE_configuration);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2683;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_ADDALL:
            case GremlinParser.K_ADDE:
            case GremlinParser.K_ADDLABEL:
            case GremlinParser.K_ADDV:
            case GremlinParser.K_AGGREGATE:
            case GremlinParser.K_ALL:
            case GremlinParser.K_AND:
            case GremlinParser.K_ANY:
            case GremlinParser.K_AS:
            case GremlinParser.K_ASBOOL:
            case GremlinParser.K_ASC:
            case GremlinParser.K_ASDATE:
            case GremlinParser.K_ASNUMBER:
            case GremlinParser.K_ASSTRING:
            case GremlinParser.K_ASSIGN:
            case GremlinParser.K_BARRIER:
            case GremlinParser.K_BARRIERU:
            case GremlinParser.K_BEGIN:
            case GremlinParser.K_BETWEEN:
            case GremlinParser.K_BIGDECIMAL:
            case GremlinParser.K_BIGDECIMALU:
            case GremlinParser.K_BIGINT:
            case GremlinParser.K_BIGINTU:
            case GremlinParser.K_BINARY:
            case GremlinParser.K_BINARYC:
            case GremlinParser.K_BINARYU:
            case GremlinParser.K_BOOLEAN:
            case GremlinParser.K_BOOLEANU:
            case GremlinParser.K_BOTH:
            case GremlinParser.K_BOTHU:
            case GremlinParser.K_BOTHE:
            case GremlinParser.K_BOTHV:
            case GremlinParser.K_BRANCH:
            case GremlinParser.K_BY:
            case GremlinParser.K_BYTE:
            case GremlinParser.K_BYTEU:
            case GremlinParser.K_CALL:
            case GremlinParser.K_CAP:
            case GremlinParser.K_CARDINALITY:
            case GremlinParser.K_CHAR:
            case GremlinParser.K_CHARU:
            case GremlinParser.K_CHOOSE:
            case GremlinParser.K_COALESCE:
            case GremlinParser.K_COIN:
            case GremlinParser.K_COLUMN:
            case GremlinParser.K_COMBINE:
            case GremlinParser.K_COMMIT:
            case GremlinParser.K_COMPONENT:
            case GremlinParser.K_CONCAT:
            case GremlinParser.K_CONJOIN:
            case GremlinParser.K_CONNECTEDCOMPONENT:
            case GremlinParser.K_CONNECTEDCOMPONENTU:
            case GremlinParser.K_CONSTANT:
            case GremlinParser.K_CONTAINING:
            case GremlinParser.K_COUNT:
            case GremlinParser.K_CYCLICPATH:
            case GremlinParser.K_DAY:
            case GremlinParser.K_DATEADD:
            case GremlinParser.K_DATEDIFF:
            case GremlinParser.K_DATETIME:
            case GremlinParser.K_DATETIMEC:
            case GremlinParser.K_DATETIMEU:
            case GremlinParser.K_DECR:
            case GremlinParser.K_DEDUP:
            case GremlinParser.K_DESC:
            case GremlinParser.K_DIFFERENCE:
            case GremlinParser.K_DISCARD:
            case GremlinParser.K_DIRECTION:
            case GremlinParser.K_DISJUNCT:
            case GremlinParser.K_DISTANCE:
            case GremlinParser.K_DIV:
            case GremlinParser.K_DOUBLE:
            case GremlinParser.K_DOUBLEU:
            case GremlinParser.K_DROP:
            case GremlinParser.K_DROPLABEL:
            case GremlinParser.K_DROPLABELS:
            case GremlinParser.K_DT:
            case GremlinParser.K_DURATION:
            case GremlinParser.K_DURATIONC:
            case GremlinParser.K_DURATIONU:
            case GremlinParser.K_E:
            case GremlinParser.K_EDGE:
            case GremlinParser.K_EDGEU:
            case GremlinParser.K_EDGES:
            case GremlinParser.K_ELEMENTMAP:
            case GremlinParser.K_ELEMENT:
            case GremlinParser.K_EMIT:
            case GremlinParser.K_ENDINGWITH:
            case GremlinParser.K_EQ:
            case GremlinParser.K_EXPLAIN:
            case GremlinParser.K_FAIL:
            case GremlinParser.K_FALSE:
            case GremlinParser.K_FILTER:
            case GremlinParser.K_FIRST:
            case GremlinParser.K_FLATMAP:
            case GremlinParser.K_FLOAT:
            case GremlinParser.K_FLOATU:
            case GremlinParser.K_FOLD:
            case GremlinParser.K_FORMAT:
            case GremlinParser.K_FROM:
            case GremlinParser.K_GLOBAL:
            case GremlinParser.K_GT:
            case GremlinParser.K_GTE:
            case GremlinParser.K_GTYPE:
            case GremlinParser.K_GRAPHML:
            case GremlinParser.K_GRAPHSON:
            case GremlinParser.K_GROUPCOUNT:
            case GremlinParser.K_GROUP:
            case GremlinParser.K_GRYO:
            case GremlinParser.K_GRAPH:
            case GremlinParser.K_GRAPHU:
            case GremlinParser.K_HAS:
            case GremlinParser.K_HASID:
            case GremlinParser.K_HASKEY:
            case GremlinParser.K_HASLABEL:
            case GremlinParser.K_HASNEXT:
            case GremlinParser.K_HASNOT:
            case GremlinParser.K_HASVALUE:
            case GremlinParser.K_HOUR:
            case GremlinParser.K_ID:
            case GremlinParser.K_IDENTITY:
            case GremlinParser.K_IDS:
            case GremlinParser.K_IN:
            case GremlinParser.K_INU:
            case GremlinParser.K_INE:
            case GremlinParser.K_INCLUDEEDGES:
            case GremlinParser.K_INCR:
            case GremlinParser.K_INDEXER:
            case GremlinParser.K_INDEX:
            case GremlinParser.K_INFINITY:
            case GremlinParser.K_INJECT:
            case GremlinParser.K_INSIDE:
            case GremlinParser.K_INT:
            case GremlinParser.K_INTU:
            case GremlinParser.K_INTERSECT:
            case GremlinParser.K_INV:
            case GremlinParser.K_IOU:
            case GremlinParser.K_IO:
            case GremlinParser.K_IS:
            case GremlinParser.K_ITERATE:
            case GremlinParser.K_KEY:
            case GremlinParser.K_KEYS:
            case GremlinParser.K_LABELS:
            case GremlinParser.K_LABEL:
            case GremlinParser.K_LAST:
            case GremlinParser.K_LENGTH:
            case GremlinParser.K_LIMIT:
            case GremlinParser.K_LIST:
            case GremlinParser.K_LISTU:
            case GremlinParser.K_LOCAL:
            case GremlinParser.K_LONG:
            case GremlinParser.K_LONGU:
            case GremlinParser.K_LOOPS:
            case GremlinParser.K_LT:
            case GremlinParser.K_LTE:
            case GremlinParser.K_LTRIM:
            case GremlinParser.K_MAP:
            case GremlinParser.K_MAPU:
            case GremlinParser.K_MATCH:
            case GremlinParser.K_MATH:
            case GremlinParser.K_MAX:
            case GremlinParser.K_MAXDISTANCE:
            case GremlinParser.K_MEAN:
            case GremlinParser.K_MERGEU:
            case GremlinParser.K_MERGE:
            case GremlinParser.K_MERGEE:
            case GremlinParser.K_MERGEV:
            case GremlinParser.K_MIN:
            case GremlinParser.K_MINUTE:
            case GremlinParser.K_MINUS:
            case GremlinParser.K_MIXED:
            case GremlinParser.K_MULT:
            case GremlinParser.K_N:
            case GremlinParser.K_NAN:
            case GremlinParser.K_NEGATE:
            case GremlinParser.K_NEXT:
            case GremlinParser.K_NONE:
            case GremlinParser.K_NOTREGEX:
            case GremlinParser.K_NOTCONTAINING:
            case GremlinParser.K_NOTENDINGWITH:
            case GremlinParser.K_NOTSTARTINGWITH:
            case GremlinParser.K_NOT:
            case GremlinParser.K_NEQ:
            case GremlinParser.K_NEW:
            case GremlinParser.K_NORMSACK:
            case GremlinParser.K_NULL:
            case GremlinParser.K_NULLU:
            case GremlinParser.K_NUMBER:
            case GremlinParser.K_NUMBERU:
            case GremlinParser.K_ONCREATE:
            case GremlinParser.K_ONMATCH:
            case GremlinParser.K_OPERATOR:
            case GremlinParser.K_OPTION:
            case GremlinParser.K_OPTIONAL:
            case GremlinParser.K_ORDERU:
            case GremlinParser.K_ORDER:
            case GremlinParser.K_OR:
            case GremlinParser.K_OTHERV:
            case GremlinParser.K_OUTU:
            case GremlinParser.K_OUT:
            case GremlinParser.K_OUTE:
            case GremlinParser.K_OUTSIDE:
            case GremlinParser.K_OUTV:
            case GremlinParser.K_P:
            case GremlinParser.K_PAGERANKU:
            case GremlinParser.K_PAGERANK:
            case GremlinParser.K_PATH:
            case GremlinParser.K_PATHU:
            case GremlinParser.K_PDT:
            case GremlinParser.K_PEERPRESSUREU:
            case GremlinParser.K_PEERPRESSURE:
            case GremlinParser.K_PICK:
            case GremlinParser.K_POP:
            case GremlinParser.K_PROFILE:
            case GremlinParser.K_PROJECT:
            case GremlinParser.K_PROPERTIES:
            case GremlinParser.K_PROPERTYMAP:
            case GremlinParser.K_PROPERTYNAME:
            case GremlinParser.K_PROPERTY:
            case GremlinParser.K_PROPERTYU:
            case GremlinParser.K_PRODUCT:
            case GremlinParser.K_RANGE:
            case GremlinParser.K_READ:
            case GremlinParser.K_READER:
            case GremlinParser.K_REGEX:
            case GremlinParser.K_REPLACE:
            case GremlinParser.K_REPEAT:
            case GremlinParser.K_REVERSE:
            case GremlinParser.K_ROLLBACK:
            case GremlinParser.K_RTRIM:
            case GremlinParser.K_SACK:
            case GremlinParser.K_SAMPLE:
            case GremlinParser.K_SCOPE:
            case GremlinParser.K_SECOND:
            case GremlinParser.K_SELECT:
            case GremlinParser.K_SET:
            case GremlinParser.K_SETU:
            case GremlinParser.K_SHORTESTPATHU:
            case GremlinParser.K_SHORTESTPATH:
            case GremlinParser.K_SHUFFLE:
            case GremlinParser.K_SHORT:
            case GremlinParser.K_SHORTU:
            case GremlinParser.K_SIDEEFFECT:
            case GremlinParser.K_SIMPLEPATH:
            case GremlinParser.K_SINGLE:
            case GremlinParser.K_SKIP:
            case GremlinParser.K_SPLIT:
            case GremlinParser.K_STARTINGWITH:
            case GremlinParser.K_STRING:
            case GremlinParser.K_STRINGU:
            case GremlinParser.K_SUBGRAPH:
            case GremlinParser.K_SUBSTRING:
            case GremlinParser.K_SUM:
            case GremlinParser.K_SUMLONG:
            case GremlinParser.K_T:
            case GremlinParser.K_TAIL:
            case GremlinParser.K_TARGET:
            case GremlinParser.K_TEXTP:
            case GremlinParser.K_TIMELIMIT:
            case GremlinParser.K_TIMES:
            case GremlinParser.K_TO:
            case GremlinParser.K_TOBULKSET:
            case GremlinParser.K_TOKENS:
            case GremlinParser.K_TOLIST:
            case GremlinParser.K_TOLOWER:
            case GremlinParser.K_TOSET:
            case GremlinParser.K_TOSTRING:
            case GremlinParser.K_TOUPPER:
            case GremlinParser.K_TOE:
            case GremlinParser.K_TOV:
            case GremlinParser.K_TREE:
            case GremlinParser.K_TREEU:
            case GremlinParser.K_TRIM:
            case GremlinParser.K_TRUE:
            case GremlinParser.K_TRYNEXT:
            case GremlinParser.K_TYPEOF:
            case GremlinParser.K_TX:
            case GremlinParser.K_UNFOLD:
            case GremlinParser.K_UNION:
            case GremlinParser.K_UNPRODUCTIVE:
            case GremlinParser.K_UNTIL:
            case GremlinParser.K_UUID:
            case GremlinParser.K_UUIDL:
            case GremlinParser.K_V:
            case GremlinParser.K_VALUEMAP:
            case GremlinParser.K_VALUES:
            case GremlinParser.K_VALUE:
            case GremlinParser.K_VERTEX:
            case GremlinParser.K_VERTEXU:
            case GremlinParser.K_VPROPERTY:
            case GremlinParser.K_VPROPERTYU:
            case GremlinParser.K_WHERE:
            case GremlinParser.K_WITH:
            case GremlinParser.K_WITHBULK:
            case GremlinParser.K_WITHIN:
            case GremlinParser.K_WITHOPTOPTIONS:
            case GremlinParser.K_WITHOUT:
            case GremlinParser.K_WITHOUTSTRATEGIES:
            case GremlinParser.K_WITHPATH:
            case GremlinParser.K_WITHSACK:
            case GremlinParser.K_WITHSIDEEFFECT:
            case GremlinParser.K_WITHSTRATEGIES:
            case GremlinParser.K_WRITE:
            case GremlinParser.K_WRITER:
            case GremlinParser.TRAVERSAL_ROOT:
                {
                this.state = 2681;
                this.keyword();
                }
                break;
            case GremlinParser.Identifier:
                {
                this.state = 2682;
                this.nakedKey();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
            this.state = 2685;
            this.match(GremlinParser.COLON);
            this.state = 2686;
            this.genericArgument();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalScope(): TraversalScopeContext {
        let localContext = new TraversalScopeContext(this.context, this.state);
        this.enterRule(localContext, 342, GremlinParser.RULE_traversalScope);
        try {
            this.state = 2696;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 120, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2688;
                this.match(GremlinParser.K_LOCAL);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2689;
                this.match(GremlinParser.K_SCOPE);
                this.state = 2690;
                this.match(GremlinParser.DOT);
                this.state = 2691;
                this.match(GremlinParser.K_LOCAL);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2692;
                this.match(GremlinParser.K_GLOBAL);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2693;
                this.match(GremlinParser.K_SCOPE);
                this.state = 2694;
                this.match(GremlinParser.DOT);
                this.state = 2695;
                this.match(GremlinParser.K_GLOBAL);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalBarrier(): TraversalBarrierContext {
        let localContext = new TraversalBarrierContext(this.context, this.state);
        this.enterRule(localContext, 344, GremlinParser.RULE_traversalBarrier);
        try {
            this.state = 2702;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_NORMSACK:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2698;
                this.match(GremlinParser.K_NORMSACK);
                }
                break;
            case GremlinParser.K_BARRIERU:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2699;
                this.match(GremlinParser.K_BARRIERU);
                this.state = 2700;
                this.match(GremlinParser.DOT);
                this.state = 2701;
                this.match(GremlinParser.K_NORMSACK);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalT(): TraversalTContext {
        let localContext = new TraversalTContext(this.context, this.state);
        this.enterRule(localContext, 346, GremlinParser.RULE_traversalT);
        try {
            this.state = 2706;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_ID:
            case GremlinParser.K_KEY:
            case GremlinParser.K_LABEL:
            case GremlinParser.K_VALUE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2704;
                this.traversalTShort();
                }
                break;
            case GremlinParser.K_T:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2705;
                this.traversalTLong();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalTShort(): TraversalTShortContext {
        let localContext = new TraversalTShortContext(this.context, this.state);
        this.enterRule(localContext, 348, GremlinParser.RULE_traversalTShort);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2708;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 120)) & ~0x1F) === 0 && ((1 << (_la - 120)) & 18874369) !== 0) || _la === 287)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalTLong(): TraversalTLongContext {
        let localContext = new TraversalTLongContext(this.context, this.state);
        this.enterRule(localContext, 350, GremlinParser.RULE_traversalTLong);
        try {
            this.state = 2722;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 123, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2710;
                this.match(GremlinParser.K_T);
                this.state = 2711;
                this.match(GremlinParser.DOT);
                this.state = 2712;
                this.match(GremlinParser.K_ID);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2713;
                this.match(GremlinParser.K_T);
                this.state = 2714;
                this.match(GremlinParser.DOT);
                this.state = 2715;
                this.match(GremlinParser.K_LABEL);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2716;
                this.match(GremlinParser.K_T);
                this.state = 2717;
                this.match(GremlinParser.DOT);
                this.state = 2718;
                this.match(GremlinParser.K_KEY);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2719;
                this.match(GremlinParser.K_T);
                this.state = 2720;
                this.match(GremlinParser.DOT);
                this.state = 2721;
                this.match(GremlinParser.K_VALUE);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalMerge(): TraversalMergeContext {
        let localContext = new TraversalMergeContext(this.context, this.state);
        this.enterRule(localContext, 352, GremlinParser.RULE_traversalMerge);
        try {
            this.state = 2740;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 124, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2724;
                this.match(GremlinParser.K_ONCREATE);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2725;
                this.match(GremlinParser.K_MERGEU);
                this.state = 2726;
                this.match(GremlinParser.DOT);
                this.state = 2727;
                this.match(GremlinParser.K_ONCREATE);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2728;
                this.match(GremlinParser.K_ONMATCH);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2729;
                this.match(GremlinParser.K_MERGEU);
                this.state = 2730;
                this.match(GremlinParser.DOT);
                this.state = 2731;
                this.match(GremlinParser.K_ONMATCH);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2732;
                this.match(GremlinParser.K_OUTV);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 2733;
                this.match(GremlinParser.K_MERGEU);
                this.state = 2734;
                this.match(GremlinParser.DOT);
                this.state = 2735;
                this.match(GremlinParser.K_OUTV);
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 2736;
                this.match(GremlinParser.K_INV);
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 2737;
                this.match(GremlinParser.K_MERGEU);
                this.state = 2738;
                this.match(GremlinParser.DOT);
                this.state = 2739;
                this.match(GremlinParser.K_INV);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalOrder(): TraversalOrderContext {
        let localContext = new TraversalOrderContext(this.context, this.state);
        this.enterRule(localContext, 354, GremlinParser.RULE_traversalOrder);
        try {
            this.state = 2754;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 125, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2742;
                this.match(GremlinParser.K_ASC);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2743;
                this.match(GremlinParser.K_ORDERU);
                this.state = 2744;
                this.match(GremlinParser.DOT);
                this.state = 2745;
                this.match(GremlinParser.K_ASC);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2746;
                this.match(GremlinParser.K_DESC);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2747;
                this.match(GremlinParser.K_ORDERU);
                this.state = 2748;
                this.match(GremlinParser.DOT);
                this.state = 2749;
                this.match(GremlinParser.K_DESC);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2750;
                this.match(GremlinParser.K_SHUFFLE);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 2751;
                this.match(GremlinParser.K_ORDERU);
                this.state = 2752;
                this.match(GremlinParser.DOT);
                this.state = 2753;
                this.match(GremlinParser.K_SHUFFLE);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalDirection(): TraversalDirectionContext {
        let localContext = new TraversalDirectionContext(this.context, this.state);
        this.enterRule(localContext, 356, GremlinParser.RULE_traversalDirection);
        try {
            this.state = 2758;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_BOTHU:
            case GremlinParser.K_FROM:
            case GremlinParser.K_INU:
            case GremlinParser.K_OUTU:
            case GremlinParser.K_TO:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2756;
                this.traversalDirectionShort();
                }
                break;
            case GremlinParser.K_DIRECTION:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2757;
                this.traversalDirectionLong();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalDirectionShort(): TraversalDirectionShortContext {
        let localContext = new TraversalDirectionShortContext(this.context, this.state);
        this.enterRule(localContext, 358, GremlinParser.RULE_traversalDirectionShort);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2760;
            _la = this.tokenStream.LA(1);
            if(!(_la === 30 || _la === 100 || _la === 124 || _la === 199 || _la === 261)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalDirectionLong(): TraversalDirectionLongContext {
        let localContext = new TraversalDirectionLongContext(this.context, this.state);
        this.enterRule(localContext, 360, GremlinParser.RULE_traversalDirectionLong);
        try {
            this.state = 2777;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 127, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2762;
                this.match(GremlinParser.K_DIRECTION);
                this.state = 2763;
                this.match(GremlinParser.DOT);
                this.state = 2764;
                this.match(GremlinParser.K_INU);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2765;
                this.match(GremlinParser.K_DIRECTION);
                this.state = 2766;
                this.match(GremlinParser.DOT);
                this.state = 2767;
                this.match(GremlinParser.K_FROM);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2768;
                this.match(GremlinParser.K_DIRECTION);
                this.state = 2769;
                this.match(GremlinParser.DOT);
                this.state = 2770;
                this.match(GremlinParser.K_OUTU);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2771;
                this.match(GremlinParser.K_DIRECTION);
                this.state = 2772;
                this.match(GremlinParser.DOT);
                this.state = 2773;
                this.match(GremlinParser.K_TO);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2774;
                this.match(GremlinParser.K_DIRECTION);
                this.state = 2775;
                this.match(GremlinParser.DOT);
                this.state = 2776;
                this.match(GremlinParser.K_BOTHU);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalCardinality(): TraversalCardinalityContext {
        let localContext = new TraversalCardinalityContext(this.context, this.state);
        this.enterRule(localContext, 362, GremlinParser.RULE_traversalCardinality);
        try {
            this.state = 2821;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 131, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2783;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_CARDINALITY:
                    {
                    this.state = 2779;
                    this.match(GremlinParser.K_CARDINALITY);
                    this.state = 2780;
                    this.match(GremlinParser.DOT);
                    this.state = 2781;
                    this.match(GremlinParser.K_SINGLE);
                    }
                    break;
                case GremlinParser.K_SINGLE:
                    {
                    this.state = 2782;
                    this.match(GremlinParser.K_SINGLE);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 2785;
                this.match(GremlinParser.LPAREN);
                this.state = 2786;
                this.genericLiteral();
                this.state = 2787;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2793;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_CARDINALITY:
                    {
                    this.state = 2789;
                    this.match(GremlinParser.K_CARDINALITY);
                    this.state = 2790;
                    this.match(GremlinParser.DOT);
                    this.state = 2791;
                    this.match(GremlinParser.K_SET);
                    }
                    break;
                case GremlinParser.K_SET:
                    {
                    this.state = 2792;
                    this.match(GremlinParser.K_SET);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 2795;
                this.match(GremlinParser.LPAREN);
                this.state = 2796;
                this.genericLiteral();
                this.state = 2797;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2803;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_CARDINALITY:
                    {
                    this.state = 2799;
                    this.match(GremlinParser.K_CARDINALITY);
                    this.state = 2800;
                    this.match(GremlinParser.DOT);
                    this.state = 2801;
                    this.match(GremlinParser.K_LIST);
                    }
                    break;
                case GremlinParser.K_LIST:
                    {
                    this.state = 2802;
                    this.match(GremlinParser.K_LIST);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 2805;
                this.match(GremlinParser.LPAREN);
                this.state = 2806;
                this.genericLiteral();
                this.state = 2807;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2809;
                this.match(GremlinParser.K_SINGLE);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2810;
                this.match(GremlinParser.K_CARDINALITY);
                this.state = 2811;
                this.match(GremlinParser.DOT);
                this.state = 2812;
                this.match(GremlinParser.K_SINGLE);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 2813;
                this.match(GremlinParser.K_SET);
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 2814;
                this.match(GremlinParser.K_CARDINALITY);
                this.state = 2815;
                this.match(GremlinParser.DOT);
                this.state = 2816;
                this.match(GremlinParser.K_SET);
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 2817;
                this.match(GremlinParser.K_LIST);
                }
                break;
            case 9:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 2818;
                this.match(GremlinParser.K_CARDINALITY);
                this.state = 2819;
                this.match(GremlinParser.DOT);
                this.state = 2820;
                this.match(GremlinParser.K_LIST);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalColumn(): TraversalColumnContext {
        let localContext = new TraversalColumnContext(this.context, this.state);
        this.enterRule(localContext, 364, GremlinParser.RULE_traversalColumn);
        try {
            this.state = 2831;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 132, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2823;
                this.match(GremlinParser.K_KEYS);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2824;
                this.match(GremlinParser.K_COLUMN);
                this.state = 2825;
                this.match(GremlinParser.DOT);
                this.state = 2826;
                this.match(GremlinParser.K_KEYS);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2827;
                this.match(GremlinParser.K_VALUES);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2828;
                this.match(GremlinParser.K_COLUMN);
                this.state = 2829;
                this.match(GremlinParser.DOT);
                this.state = 2830;
                this.match(GremlinParser.K_VALUES);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPop(): TraversalPopContext {
        let localContext = new TraversalPopContext(this.context, this.state);
        this.enterRule(localContext, 366, GremlinParser.RULE_traversalPop);
        try {
            this.state = 2849;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 133, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2833;
                this.match(GremlinParser.K_FIRST);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2834;
                this.match(GremlinParser.K_POP);
                this.state = 2835;
                this.match(GremlinParser.DOT);
                this.state = 2836;
                this.match(GremlinParser.K_FIRST);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2837;
                this.match(GremlinParser.K_LAST);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2838;
                this.match(GremlinParser.K_POP);
                this.state = 2839;
                this.match(GremlinParser.DOT);
                this.state = 2840;
                this.match(GremlinParser.K_LAST);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2841;
                this.match(GremlinParser.K_ALL);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 2842;
                this.match(GremlinParser.K_POP);
                this.state = 2843;
                this.match(GremlinParser.DOT);
                this.state = 2844;
                this.match(GremlinParser.K_ALL);
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 2845;
                this.match(GremlinParser.K_MIXED);
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 2846;
                this.match(GremlinParser.K_POP);
                this.state = 2847;
                this.match(GremlinParser.DOT);
                this.state = 2848;
                this.match(GremlinParser.K_MIXED);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalOperator(): TraversalOperatorContext {
        let localContext = new TraversalOperatorContext(this.context, this.state);
        this.enterRule(localContext, 368, GremlinParser.RULE_traversalOperator);
        try {
            this.state = 2895;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 134, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2851;
                this.match(GremlinParser.K_ADDALL);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2852;
                this.match(GremlinParser.K_OPERATOR);
                this.state = 2853;
                this.match(GremlinParser.DOT);
                this.state = 2854;
                this.match(GremlinParser.K_ADDALL);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2855;
                this.match(GremlinParser.K_AND);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2856;
                this.match(GremlinParser.K_OPERATOR);
                this.state = 2857;
                this.match(GremlinParser.DOT);
                this.state = 2858;
                this.match(GremlinParser.K_AND);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2859;
                this.match(GremlinParser.K_ASSIGN);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 2860;
                this.match(GremlinParser.K_OPERATOR);
                this.state = 2861;
                this.match(GremlinParser.DOT);
                this.state = 2862;
                this.match(GremlinParser.K_ASSIGN);
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 2863;
                this.match(GremlinParser.K_DIV);
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 2864;
                this.match(GremlinParser.K_OPERATOR);
                this.state = 2865;
                this.match(GremlinParser.DOT);
                this.state = 2866;
                this.match(GremlinParser.K_DIV);
                }
                break;
            case 9:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 2867;
                this.match(GremlinParser.K_MAX);
                }
                break;
            case 10:
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 2868;
                this.match(GremlinParser.K_OPERATOR);
                this.state = 2869;
                this.match(GremlinParser.DOT);
                this.state = 2870;
                this.match(GremlinParser.K_MAX);
                }
                break;
            case 11:
                this.enterOuterAlt(localContext, 11);
                {
                this.state = 2871;
                this.match(GremlinParser.K_MIN);
                }
                break;
            case 12:
                this.enterOuterAlt(localContext, 12);
                {
                this.state = 2872;
                this.match(GremlinParser.K_OPERATOR);
                this.state = 2873;
                this.match(GremlinParser.DOT);
                this.state = 2874;
                this.match(GremlinParser.K_MIN);
                }
                break;
            case 13:
                this.enterOuterAlt(localContext, 13);
                {
                this.state = 2875;
                this.match(GremlinParser.K_MINUS);
                }
                break;
            case 14:
                this.enterOuterAlt(localContext, 14);
                {
                this.state = 2876;
                this.match(GremlinParser.K_OPERATOR);
                this.state = 2877;
                this.match(GremlinParser.DOT);
                this.state = 2878;
                this.match(GremlinParser.K_MINUS);
                }
                break;
            case 15:
                this.enterOuterAlt(localContext, 15);
                {
                this.state = 2879;
                this.match(GremlinParser.K_MULT);
                }
                break;
            case 16:
                this.enterOuterAlt(localContext, 16);
                {
                this.state = 2880;
                this.match(GremlinParser.K_OPERATOR);
                this.state = 2881;
                this.match(GremlinParser.DOT);
                this.state = 2882;
                this.match(GremlinParser.K_MULT);
                }
                break;
            case 17:
                this.enterOuterAlt(localContext, 17);
                {
                this.state = 2883;
                this.match(GremlinParser.K_OR);
                }
                break;
            case 18:
                this.enterOuterAlt(localContext, 18);
                {
                this.state = 2884;
                this.match(GremlinParser.K_OPERATOR);
                this.state = 2885;
                this.match(GremlinParser.DOT);
                this.state = 2886;
                this.match(GremlinParser.K_OR);
                }
                break;
            case 19:
                this.enterOuterAlt(localContext, 19);
                {
                this.state = 2887;
                this.match(GremlinParser.K_SUM);
                }
                break;
            case 20:
                this.enterOuterAlt(localContext, 20);
                {
                this.state = 2888;
                this.match(GremlinParser.K_OPERATOR);
                this.state = 2889;
                this.match(GremlinParser.DOT);
                this.state = 2890;
                this.match(GremlinParser.K_SUM);
                }
                break;
            case 21:
                this.enterOuterAlt(localContext, 21);
                {
                this.state = 2891;
                this.match(GremlinParser.K_SUMLONG);
                }
                break;
            case 22:
                this.enterOuterAlt(localContext, 22);
                {
                this.state = 2892;
                this.match(GremlinParser.K_OPERATOR);
                this.state = 2893;
                this.match(GremlinParser.DOT);
                this.state = 2894;
                this.match(GremlinParser.K_SUMLONG);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPick(): TraversalPickContext {
        let localContext = new TraversalPickContext(this.context, this.state);
        this.enterRule(localContext, 370, GremlinParser.RULE_traversalPick);
        try {
            this.state = 2909;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 135, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2897;
                this.match(GremlinParser.K_ANY);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2898;
                this.match(GremlinParser.K_PICK);
                this.state = 2899;
                this.match(GremlinParser.DOT);
                this.state = 2900;
                this.match(GremlinParser.K_ANY);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2901;
                this.match(GremlinParser.K_NONE);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2902;
                this.match(GremlinParser.K_PICK);
                this.state = 2903;
                this.match(GremlinParser.DOT);
                this.state = 2904;
                this.match(GremlinParser.K_NONE);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2905;
                this.match(GremlinParser.K_UNPRODUCTIVE);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 2906;
                this.match(GremlinParser.K_PICK);
                this.state = 2907;
                this.match(GremlinParser.DOT);
                this.state = 2908;
                this.match(GremlinParser.K_UNPRODUCTIVE);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalDT(): TraversalDTContext {
        let localContext = new TraversalDTContext(this.context, this.state);
        this.enterRule(localContext, 372, GremlinParser.RULE_traversalDT);
        try {
            this.state = 2927;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 136, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2911;
                this.match(GremlinParser.K_SECOND);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2912;
                this.match(GremlinParser.K_DT);
                this.state = 2913;
                this.match(GremlinParser.DOT);
                this.state = 2914;
                this.match(GremlinParser.K_SECOND);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2915;
                this.match(GremlinParser.K_MINUTE);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2916;
                this.match(GremlinParser.K_DT);
                this.state = 2917;
                this.match(GremlinParser.DOT);
                this.state = 2918;
                this.match(GremlinParser.K_MINUTE);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2919;
                this.match(GremlinParser.K_HOUR);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 2920;
                this.match(GremlinParser.K_DT);
                this.state = 2921;
                this.match(GremlinParser.DOT);
                this.state = 2922;
                this.match(GremlinParser.K_HOUR);
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 2923;
                this.match(GremlinParser.K_DAY);
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 2924;
                this.match(GremlinParser.K_DT);
                this.state = 2925;
                this.match(GremlinParser.DOT);
                this.state = 2926;
                this.match(GremlinParser.K_DAY);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalGType(): TraversalGTypeContext {
        let localContext = new TraversalGTypeContext(this.context, this.state);
        this.enterRule(localContext, 374, GremlinParser.RULE_traversalGType);
        try {
            this.state = 3145;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 137, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2929;
                this.match(GremlinParser.K_BIGDECIMAL);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2930;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2931;
                this.match(GremlinParser.DOT);
                this.state = 2932;
                this.match(GremlinParser.K_BIGDECIMAL);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2933;
                this.match(GremlinParser.K_BIGDECIMALU);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2934;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2935;
                this.match(GremlinParser.DOT);
                this.state = 2936;
                this.match(GremlinParser.K_BIGDECIMALU);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2937;
                this.match(GremlinParser.K_BIGINT);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 2938;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2939;
                this.match(GremlinParser.DOT);
                this.state = 2940;
                this.match(GremlinParser.K_BIGINT);
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 2941;
                this.match(GremlinParser.K_BIGINTU);
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 2942;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2943;
                this.match(GremlinParser.DOT);
                this.state = 2944;
                this.match(GremlinParser.K_BIGINTU);
                }
                break;
            case 9:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 2945;
                this.match(GremlinParser.K_BINARY);
                }
                break;
            case 10:
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 2946;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2947;
                this.match(GremlinParser.DOT);
                this.state = 2948;
                this.match(GremlinParser.K_BINARY);
                }
                break;
            case 11:
                this.enterOuterAlt(localContext, 11);
                {
                this.state = 2949;
                this.match(GremlinParser.K_BINARYU);
                }
                break;
            case 12:
                this.enterOuterAlt(localContext, 12);
                {
                this.state = 2950;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2951;
                this.match(GremlinParser.DOT);
                this.state = 2952;
                this.match(GremlinParser.K_BINARYU);
                }
                break;
            case 13:
                this.enterOuterAlt(localContext, 13);
                {
                this.state = 2953;
                this.match(GremlinParser.K_BOOLEAN);
                }
                break;
            case 14:
                this.enterOuterAlt(localContext, 14);
                {
                this.state = 2954;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2955;
                this.match(GremlinParser.DOT);
                this.state = 2956;
                this.match(GremlinParser.K_BOOLEAN);
                }
                break;
            case 15:
                this.enterOuterAlt(localContext, 15);
                {
                this.state = 2957;
                this.match(GremlinParser.K_BOOLEANU);
                }
                break;
            case 16:
                this.enterOuterAlt(localContext, 16);
                {
                this.state = 2958;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2959;
                this.match(GremlinParser.DOT);
                this.state = 2960;
                this.match(GremlinParser.K_BOOLEANU);
                }
                break;
            case 17:
                this.enterOuterAlt(localContext, 17);
                {
                this.state = 2961;
                this.match(GremlinParser.K_BYTE);
                }
                break;
            case 18:
                this.enterOuterAlt(localContext, 18);
                {
                this.state = 2962;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2963;
                this.match(GremlinParser.DOT);
                this.state = 2964;
                this.match(GremlinParser.K_BYTE);
                }
                break;
            case 19:
                this.enterOuterAlt(localContext, 19);
                {
                this.state = 2965;
                this.match(GremlinParser.K_BYTEU);
                }
                break;
            case 20:
                this.enterOuterAlt(localContext, 20);
                {
                this.state = 2966;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2967;
                this.match(GremlinParser.DOT);
                this.state = 2968;
                this.match(GremlinParser.K_BYTEU);
                }
                break;
            case 21:
                this.enterOuterAlt(localContext, 21);
                {
                this.state = 2969;
                this.match(GremlinParser.K_CHAR);
                }
                break;
            case 22:
                this.enterOuterAlt(localContext, 22);
                {
                this.state = 2970;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2971;
                this.match(GremlinParser.DOT);
                this.state = 2972;
                this.match(GremlinParser.K_CHAR);
                }
                break;
            case 23:
                this.enterOuterAlt(localContext, 23);
                {
                this.state = 2973;
                this.match(GremlinParser.K_CHARU);
                }
                break;
            case 24:
                this.enterOuterAlt(localContext, 24);
                {
                this.state = 2974;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2975;
                this.match(GremlinParser.DOT);
                this.state = 2976;
                this.match(GremlinParser.K_CHARU);
                }
                break;
            case 25:
                this.enterOuterAlt(localContext, 25);
                {
                this.state = 2977;
                this.match(GremlinParser.K_DATETIME);
                }
                break;
            case 26:
                this.enterOuterAlt(localContext, 26);
                {
                this.state = 2978;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2979;
                this.match(GremlinParser.DOT);
                this.state = 2980;
                this.match(GremlinParser.K_DATETIME);
                }
                break;
            case 27:
                this.enterOuterAlt(localContext, 27);
                {
                this.state = 2981;
                this.match(GremlinParser.K_DATETIMEU);
                }
                break;
            case 28:
                this.enterOuterAlt(localContext, 28);
                {
                this.state = 2982;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2983;
                this.match(GremlinParser.DOT);
                this.state = 2984;
                this.match(GremlinParser.K_DATETIMEU);
                }
                break;
            case 29:
                this.enterOuterAlt(localContext, 29);
                {
                this.state = 2985;
                this.match(GremlinParser.K_DOUBLE);
                }
                break;
            case 30:
                this.enterOuterAlt(localContext, 30);
                {
                this.state = 2986;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2987;
                this.match(GremlinParser.DOT);
                this.state = 2988;
                this.match(GremlinParser.K_DOUBLE);
                }
                break;
            case 31:
                this.enterOuterAlt(localContext, 31);
                {
                this.state = 2989;
                this.match(GremlinParser.K_DOUBLEU);
                }
                break;
            case 32:
                this.enterOuterAlt(localContext, 32);
                {
                this.state = 2990;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2991;
                this.match(GremlinParser.DOT);
                this.state = 2992;
                this.match(GremlinParser.K_DOUBLEU);
                }
                break;
            case 33:
                this.enterOuterAlt(localContext, 33);
                {
                this.state = 2993;
                this.match(GremlinParser.K_DURATION);
                }
                break;
            case 34:
                this.enterOuterAlt(localContext, 34);
                {
                this.state = 2994;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2995;
                this.match(GremlinParser.DOT);
                this.state = 2996;
                this.match(GremlinParser.K_DURATION);
                }
                break;
            case 35:
                this.enterOuterAlt(localContext, 35);
                {
                this.state = 2997;
                this.match(GremlinParser.K_DURATIONU);
                }
                break;
            case 36:
                this.enterOuterAlt(localContext, 36);
                {
                this.state = 2998;
                this.match(GremlinParser.K_GTYPE);
                this.state = 2999;
                this.match(GremlinParser.DOT);
                this.state = 3000;
                this.match(GremlinParser.K_DURATIONU);
                }
                break;
            case 37:
                this.enterOuterAlt(localContext, 37);
                {
                this.state = 3001;
                this.match(GremlinParser.K_EDGE);
                }
                break;
            case 38:
                this.enterOuterAlt(localContext, 38);
                {
                this.state = 3002;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3003;
                this.match(GremlinParser.DOT);
                this.state = 3004;
                this.match(GremlinParser.K_EDGE);
                }
                break;
            case 39:
                this.enterOuterAlt(localContext, 39);
                {
                this.state = 3005;
                this.match(GremlinParser.K_EDGEU);
                }
                break;
            case 40:
                this.enterOuterAlt(localContext, 40);
                {
                this.state = 3006;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3007;
                this.match(GremlinParser.DOT);
                this.state = 3008;
                this.match(GremlinParser.K_EDGEU);
                }
                break;
            case 41:
                this.enterOuterAlt(localContext, 41);
                {
                this.state = 3009;
                this.match(GremlinParser.K_FLOAT);
                }
                break;
            case 42:
                this.enterOuterAlt(localContext, 42);
                {
                this.state = 3010;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3011;
                this.match(GremlinParser.DOT);
                this.state = 3012;
                this.match(GremlinParser.K_FLOAT);
                }
                break;
            case 43:
                this.enterOuterAlt(localContext, 43);
                {
                this.state = 3013;
                this.match(GremlinParser.K_FLOATU);
                }
                break;
            case 44:
                this.enterOuterAlt(localContext, 44);
                {
                this.state = 3014;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3015;
                this.match(GremlinParser.DOT);
                this.state = 3016;
                this.match(GremlinParser.K_FLOATU);
                }
                break;
            case 45:
                this.enterOuterAlt(localContext, 45);
                {
                this.state = 3017;
                this.match(GremlinParser.K_GRAPH);
                }
                break;
            case 46:
                this.enterOuterAlt(localContext, 46);
                {
                this.state = 3018;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3019;
                this.match(GremlinParser.DOT);
                this.state = 3020;
                this.match(GremlinParser.K_GRAPH);
                }
                break;
            case 47:
                this.enterOuterAlt(localContext, 47);
                {
                this.state = 3021;
                this.match(GremlinParser.K_GRAPHU);
                }
                break;
            case 48:
                this.enterOuterAlt(localContext, 48);
                {
                this.state = 3022;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3023;
                this.match(GremlinParser.DOT);
                this.state = 3024;
                this.match(GremlinParser.K_GRAPHU);
                }
                break;
            case 49:
                this.enterOuterAlt(localContext, 49);
                {
                this.state = 3025;
                this.match(GremlinParser.K_INT);
                }
                break;
            case 50:
                this.enterOuterAlt(localContext, 50);
                {
                this.state = 3026;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3027;
                this.match(GremlinParser.DOT);
                this.state = 3028;
                this.match(GremlinParser.K_INT);
                }
                break;
            case 51:
                this.enterOuterAlt(localContext, 51);
                {
                this.state = 3029;
                this.match(GremlinParser.K_INTU);
                }
                break;
            case 52:
                this.enterOuterAlt(localContext, 52);
                {
                this.state = 3030;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3031;
                this.match(GremlinParser.DOT);
                this.state = 3032;
                this.match(GremlinParser.K_INTU);
                }
                break;
            case 53:
                this.enterOuterAlt(localContext, 53);
                {
                this.state = 3033;
                this.match(GremlinParser.K_LIST);
                }
                break;
            case 54:
                this.enterOuterAlt(localContext, 54);
                {
                this.state = 3034;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3035;
                this.match(GremlinParser.DOT);
                this.state = 3036;
                this.match(GremlinParser.K_LIST);
                }
                break;
            case 55:
                this.enterOuterAlt(localContext, 55);
                {
                this.state = 3037;
                this.match(GremlinParser.K_LISTU);
                }
                break;
            case 56:
                this.enterOuterAlt(localContext, 56);
                {
                this.state = 3038;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3039;
                this.match(GremlinParser.DOT);
                this.state = 3040;
                this.match(GremlinParser.K_LISTU);
                }
                break;
            case 57:
                this.enterOuterAlt(localContext, 57);
                {
                this.state = 3041;
                this.match(GremlinParser.K_LONG);
                }
                break;
            case 58:
                this.enterOuterAlt(localContext, 58);
                {
                this.state = 3042;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3043;
                this.match(GremlinParser.DOT);
                this.state = 3044;
                this.match(GremlinParser.K_LONG);
                }
                break;
            case 59:
                this.enterOuterAlt(localContext, 59);
                {
                this.state = 3045;
                this.match(GremlinParser.K_LONGU);
                }
                break;
            case 60:
                this.enterOuterAlt(localContext, 60);
                {
                this.state = 3046;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3047;
                this.match(GremlinParser.DOT);
                this.state = 3048;
                this.match(GremlinParser.K_LONGU);
                }
                break;
            case 61:
                this.enterOuterAlt(localContext, 61);
                {
                this.state = 3049;
                this.match(GremlinParser.K_MAP);
                }
                break;
            case 62:
                this.enterOuterAlt(localContext, 62);
                {
                this.state = 3050;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3051;
                this.match(GremlinParser.DOT);
                this.state = 3052;
                this.match(GremlinParser.K_MAP);
                }
                break;
            case 63:
                this.enterOuterAlt(localContext, 63);
                {
                this.state = 3053;
                this.match(GremlinParser.K_MAPU);
                }
                break;
            case 64:
                this.enterOuterAlt(localContext, 64);
                {
                this.state = 3054;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3055;
                this.match(GremlinParser.DOT);
                this.state = 3056;
                this.match(GremlinParser.K_MAPU);
                }
                break;
            case 65:
                this.enterOuterAlt(localContext, 65);
                {
                this.state = 3057;
                this.match(GremlinParser.K_NULL);
                }
                break;
            case 66:
                this.enterOuterAlt(localContext, 66);
                {
                this.state = 3058;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3059;
                this.match(GremlinParser.DOT);
                this.state = 3060;
                this.match(GremlinParser.K_NULL);
                }
                break;
            case 67:
                this.enterOuterAlt(localContext, 67);
                {
                this.state = 3061;
                this.match(GremlinParser.K_NULLU);
                }
                break;
            case 68:
                this.enterOuterAlt(localContext, 68);
                {
                this.state = 3062;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3063;
                this.match(GremlinParser.DOT);
                this.state = 3064;
                this.match(GremlinParser.K_NULLU);
                }
                break;
            case 69:
                this.enterOuterAlt(localContext, 69);
                {
                this.state = 3065;
                this.match(GremlinParser.K_NUMBER);
                }
                break;
            case 70:
                this.enterOuterAlt(localContext, 70);
                {
                this.state = 3066;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3067;
                this.match(GremlinParser.DOT);
                this.state = 3068;
                this.match(GremlinParser.K_NUMBER);
                }
                break;
            case 71:
                this.enterOuterAlt(localContext, 71);
                {
                this.state = 3069;
                this.match(GremlinParser.K_NUMBERU);
                }
                break;
            case 72:
                this.enterOuterAlt(localContext, 72);
                {
                this.state = 3070;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3071;
                this.match(GremlinParser.DOT);
                this.state = 3072;
                this.match(GremlinParser.K_NUMBERU);
                }
                break;
            case 73:
                this.enterOuterAlt(localContext, 73);
                {
                this.state = 3073;
                this.match(GremlinParser.K_PATH);
                }
                break;
            case 74:
                this.enterOuterAlt(localContext, 74);
                {
                this.state = 3074;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3075;
                this.match(GremlinParser.DOT);
                this.state = 3076;
                this.match(GremlinParser.K_PATH);
                }
                break;
            case 75:
                this.enterOuterAlt(localContext, 75);
                {
                this.state = 3077;
                this.match(GremlinParser.K_PATHU);
                }
                break;
            case 76:
                this.enterOuterAlt(localContext, 76);
                {
                this.state = 3078;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3079;
                this.match(GremlinParser.DOT);
                this.state = 3080;
                this.match(GremlinParser.K_PATHU);
                }
                break;
            case 77:
                this.enterOuterAlt(localContext, 77);
                {
                this.state = 3081;
                this.match(GremlinParser.K_PROPERTY);
                }
                break;
            case 78:
                this.enterOuterAlt(localContext, 78);
                {
                this.state = 3082;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3083;
                this.match(GremlinParser.DOT);
                this.state = 3084;
                this.match(GremlinParser.K_PROPERTY);
                }
                break;
            case 79:
                this.enterOuterAlt(localContext, 79);
                {
                this.state = 3085;
                this.match(GremlinParser.K_PROPERTYU);
                }
                break;
            case 80:
                this.enterOuterAlt(localContext, 80);
                {
                this.state = 3086;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3087;
                this.match(GremlinParser.DOT);
                this.state = 3088;
                this.match(GremlinParser.K_PROPERTYU);
                }
                break;
            case 81:
                this.enterOuterAlt(localContext, 81);
                {
                this.state = 3089;
                this.match(GremlinParser.K_SET);
                }
                break;
            case 82:
                this.enterOuterAlt(localContext, 82);
                {
                this.state = 3090;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3091;
                this.match(GremlinParser.DOT);
                this.state = 3092;
                this.match(GremlinParser.K_SET);
                }
                break;
            case 83:
                this.enterOuterAlt(localContext, 83);
                {
                this.state = 3093;
                this.match(GremlinParser.K_SETU);
                }
                break;
            case 84:
                this.enterOuterAlt(localContext, 84);
                {
                this.state = 3094;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3095;
                this.match(GremlinParser.DOT);
                this.state = 3096;
                this.match(GremlinParser.K_SETU);
                }
                break;
            case 85:
                this.enterOuterAlt(localContext, 85);
                {
                this.state = 3097;
                this.match(GremlinParser.K_SHORT);
                }
                break;
            case 86:
                this.enterOuterAlt(localContext, 86);
                {
                this.state = 3098;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3099;
                this.match(GremlinParser.DOT);
                this.state = 3100;
                this.match(GremlinParser.K_SHORT);
                }
                break;
            case 87:
                this.enterOuterAlt(localContext, 87);
                {
                this.state = 3101;
                this.match(GremlinParser.K_SHORTU);
                }
                break;
            case 88:
                this.enterOuterAlt(localContext, 88);
                {
                this.state = 3102;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3103;
                this.match(GremlinParser.DOT);
                this.state = 3104;
                this.match(GremlinParser.K_SHORTU);
                }
                break;
            case 89:
                this.enterOuterAlt(localContext, 89);
                {
                this.state = 3105;
                this.match(GremlinParser.K_STRING);
                }
                break;
            case 90:
                this.enterOuterAlt(localContext, 90);
                {
                this.state = 3106;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3107;
                this.match(GremlinParser.DOT);
                this.state = 3108;
                this.match(GremlinParser.K_STRING);
                }
                break;
            case 91:
                this.enterOuterAlt(localContext, 91);
                {
                this.state = 3109;
                this.match(GremlinParser.K_STRINGU);
                }
                break;
            case 92:
                this.enterOuterAlt(localContext, 92);
                {
                this.state = 3110;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3111;
                this.match(GremlinParser.DOT);
                this.state = 3112;
                this.match(GremlinParser.K_STRINGU);
                }
                break;
            case 93:
                this.enterOuterAlt(localContext, 93);
                {
                this.state = 3113;
                this.match(GremlinParser.K_TREE);
                }
                break;
            case 94:
                this.enterOuterAlt(localContext, 94);
                {
                this.state = 3114;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3115;
                this.match(GremlinParser.DOT);
                this.state = 3116;
                this.match(GremlinParser.K_TREE);
                }
                break;
            case 95:
                this.enterOuterAlt(localContext, 95);
                {
                this.state = 3117;
                this.match(GremlinParser.K_TREEU);
                }
                break;
            case 96:
                this.enterOuterAlt(localContext, 96);
                {
                this.state = 3118;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3119;
                this.match(GremlinParser.DOT);
                this.state = 3120;
                this.match(GremlinParser.K_TREEU);
                }
                break;
            case 97:
                this.enterOuterAlt(localContext, 97);
                {
                this.state = 3121;
                this.match(GremlinParser.K_UUID);
                }
                break;
            case 98:
                this.enterOuterAlt(localContext, 98);
                {
                this.state = 3122;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3123;
                this.match(GremlinParser.DOT);
                this.state = 3124;
                this.match(GremlinParser.K_UUID);
                }
                break;
            case 99:
                this.enterOuterAlt(localContext, 99);
                {
                this.state = 3125;
                this.match(GremlinParser.K_UUIDL);
                }
                break;
            case 100:
                this.enterOuterAlt(localContext, 100);
                {
                this.state = 3126;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3127;
                this.match(GremlinParser.DOT);
                this.state = 3128;
                this.match(GremlinParser.K_UUIDL);
                }
                break;
            case 101:
                this.enterOuterAlt(localContext, 101);
                {
                this.state = 3129;
                this.match(GremlinParser.K_VERTEX);
                }
                break;
            case 102:
                this.enterOuterAlt(localContext, 102);
                {
                this.state = 3130;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3131;
                this.match(GremlinParser.DOT);
                this.state = 3132;
                this.match(GremlinParser.K_VERTEX);
                }
                break;
            case 103:
                this.enterOuterAlt(localContext, 103);
                {
                this.state = 3133;
                this.match(GremlinParser.K_VERTEXU);
                }
                break;
            case 104:
                this.enterOuterAlt(localContext, 104);
                {
                this.state = 3134;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3135;
                this.match(GremlinParser.DOT);
                this.state = 3136;
                this.match(GremlinParser.K_VERTEXU);
                }
                break;
            case 105:
                this.enterOuterAlt(localContext, 105);
                {
                this.state = 3137;
                this.match(GremlinParser.K_VPROPERTY);
                }
                break;
            case 106:
                this.enterOuterAlt(localContext, 106);
                {
                this.state = 3138;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3139;
                this.match(GremlinParser.DOT);
                this.state = 3140;
                this.match(GremlinParser.K_VPROPERTY);
                }
                break;
            case 107:
                this.enterOuterAlt(localContext, 107);
                {
                this.state = 3141;
                this.match(GremlinParser.K_VPROPERTYU);
                }
                break;
            case 108:
                this.enterOuterAlt(localContext, 108);
                {
                this.state = 3142;
                this.match(GremlinParser.K_GTYPE);
                this.state = 3143;
                this.match(GremlinParser.DOT);
                this.state = 3144;
                this.match(GremlinParser.K_VPROPERTYU);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }

    public traversalPredicate(): TraversalPredicateContext;
    public traversalPredicate(_p: number): TraversalPredicateContext;
    public traversalPredicate(_p?: number): TraversalPredicateContext {
        if (_p === undefined) {
            _p = 0;
        }

        let parentContext = this.context;
        let parentState = this.state;
        let localContext = new TraversalPredicateContext(this.context, parentState);
        let previousContext = localContext;
        let _startState = 376;
        this.enterRecursionRule(localContext, 376, GremlinParser.RULE_traversalPredicate, _p);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3169;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 138, this.context) ) {
            case 1:
                {
                this.state = 3148;
                this.traversalPredicate_eq();
                }
                break;
            case 2:
                {
                this.state = 3149;
                this.traversalPredicate_neq();
                }
                break;
            case 3:
                {
                this.state = 3150;
                this.traversalPredicate_lt();
                }
                break;
            case 4:
                {
                this.state = 3151;
                this.traversalPredicate_lte();
                }
                break;
            case 5:
                {
                this.state = 3152;
                this.traversalPredicate_gt();
                }
                break;
            case 6:
                {
                this.state = 3153;
                this.traversalPredicate_gte();
                }
                break;
            case 7:
                {
                this.state = 3154;
                this.traversalPredicate_inside();
                }
                break;
            case 8:
                {
                this.state = 3155;
                this.traversalPredicate_outside();
                }
                break;
            case 9:
                {
                this.state = 3156;
                this.traversalPredicate_between();
                }
                break;
            case 10:
                {
                this.state = 3157;
                this.traversalPredicate_typeOf();
                }
                break;
            case 11:
                {
                this.state = 3158;
                this.traversalPredicate_within();
                }
                break;
            case 12:
                {
                this.state = 3159;
                this.traversalPredicate_without();
                }
                break;
            case 13:
                {
                this.state = 3160;
                this.traversalPredicate_not();
                }
                break;
            case 14:
                {
                this.state = 3161;
                this.traversalPredicate_startingWith();
                }
                break;
            case 15:
                {
                this.state = 3162;
                this.traversalPredicate_notStartingWith();
                }
                break;
            case 16:
                {
                this.state = 3163;
                this.traversalPredicate_endingWith();
                }
                break;
            case 17:
                {
                this.state = 3164;
                this.traversalPredicate_notEndingWith();
                }
                break;
            case 18:
                {
                this.state = 3165;
                this.traversalPredicate_containing();
                }
                break;
            case 19:
                {
                this.state = 3166;
                this.traversalPredicate_notContaining();
                }
                break;
            case 20:
                {
                this.state = 3167;
                this.traversalPredicate_regex();
                }
                break;
            case 21:
                {
                this.state = 3168;
                this.traversalPredicate_notRegex();
                }
                break;
            }
            this.context!.stop = this.tokenStream.LT(-1);
            this.state = 3192;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 140, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    if (this.parseListeners != null) {
                        this.triggerExitRuleEvent();
                    }
                    previousContext = localContext;
                    {
                    this.state = 3190;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 139, this.context) ) {
                    case 1:
                        {
                        localContext = new TraversalPredicateContext(parentContext, parentState);
                        this.pushNewRecursionContext(localContext, _startState, GremlinParser.RULE_traversalPredicate);
                        this.state = 3171;
                        if (!(this.precpred(this.context, 3))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 3)");
                        }
                        this.state = 3172;
                        this.match(GremlinParser.DOT);
                        this.state = 3173;
                        this.match(GremlinParser.K_AND);
                        this.state = 3174;
                        this.match(GremlinParser.LPAREN);
                        this.state = 3175;
                        this.traversalPredicate(0);
                        this.state = 3176;
                        this.match(GremlinParser.RPAREN);
                        }
                        break;
                    case 2:
                        {
                        localContext = new TraversalPredicateContext(parentContext, parentState);
                        this.pushNewRecursionContext(localContext, _startState, GremlinParser.RULE_traversalPredicate);
                        this.state = 3178;
                        if (!(this.precpred(this.context, 2))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 2)");
                        }
                        this.state = 3179;
                        this.match(GremlinParser.DOT);
                        this.state = 3180;
                        this.match(GremlinParser.K_OR);
                        this.state = 3181;
                        this.match(GremlinParser.LPAREN);
                        this.state = 3182;
                        this.traversalPredicate(0);
                        this.state = 3183;
                        this.match(GremlinParser.RPAREN);
                        }
                        break;
                    case 3:
                        {
                        localContext = new TraversalPredicateContext(parentContext, parentState);
                        this.pushNewRecursionContext(localContext, _startState, GremlinParser.RULE_traversalPredicate);
                        this.state = 3185;
                        if (!(this.precpred(this.context, 1))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 1)");
                        }
                        this.state = 3186;
                        this.match(GremlinParser.DOT);
                        this.state = 3187;
                        this.match(GremlinParser.K_NEGATE);
                        this.state = 3188;
                        this.match(GremlinParser.LPAREN);
                        this.state = 3189;
                        this.match(GremlinParser.RPAREN);
                        }
                        break;
                    }
                    }
                }
                this.state = 3194;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 140, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.unrollRecursionContexts(parentContext);
        }
        return localContext;
    }
    public traversalTerminalMethod(): TraversalTerminalMethodContext {
        let localContext = new TraversalTerminalMethodContext(this.context, this.state);
        this.enterRule(localContext, 378, GremlinParser.RULE_traversalTerminalMethod);
        try {
            this.state = 3203;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_EXPLAIN:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3195;
                this.traversalTerminalMethod_explain();
                }
                break;
            case GremlinParser.K_ITERATE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3196;
                this.traversalTerminalMethod_iterate();
                }
                break;
            case GremlinParser.K_HASNEXT:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3197;
                this.traversalTerminalMethod_hasNext();
                }
                break;
            case GremlinParser.K_TRYNEXT:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3198;
                this.traversalTerminalMethod_tryNext();
                }
                break;
            case GremlinParser.K_NEXT:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 3199;
                this.traversalTerminalMethod_next();
                }
                break;
            case GremlinParser.K_TOLIST:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 3200;
                this.traversalTerminalMethod_toList();
                }
                break;
            case GremlinParser.K_TOSET:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 3201;
                this.traversalTerminalMethod_toSet();
                }
                break;
            case GremlinParser.K_TOBULKSET:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 3202;
                this.traversalTerminalMethod_toBulkSet();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalSackMethod(): TraversalSackMethodContext {
        let localContext = new TraversalSackMethodContext(this.context, this.state);
        this.enterRule(localContext, 380, GremlinParser.RULE_traversalSackMethod);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3205;
            this.traversalBarrier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalComparator(): TraversalComparatorContext {
        let localContext = new TraversalComparatorContext(this.context, this.state);
        this.enterRule(localContext, 382, GremlinParser.RULE_traversalComparator);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3207;
            this.traversalOrder();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalFunction(): TraversalFunctionContext {
        let localContext = new TraversalFunctionContext(this.context, this.state);
        this.enterRule(localContext, 384, GremlinParser.RULE_traversalFunction);
        try {
            this.state = 3211;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_ID:
            case GremlinParser.K_KEY:
            case GremlinParser.K_LABEL:
            case GremlinParser.K_T:
            case GremlinParser.K_VALUE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3209;
                this.traversalT();
                }
                break;
            case GremlinParser.K_COLUMN:
            case GremlinParser.K_KEYS:
            case GremlinParser.K_VALUES:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3210;
                this.traversalColumn();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalBiFunction(): TraversalBiFunctionContext {
        let localContext = new TraversalBiFunctionContext(this.context, this.state);
        this.enterRule(localContext, 386, GremlinParser.RULE_traversalBiFunction);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3213;
            this.traversalOperator();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_eq(): TraversalPredicate_eqContext {
        let localContext = new TraversalPredicate_eqContext(this.context, this.state);
        this.enterRule(localContext, 388, GremlinParser.RULE_traversalPredicate_eq);
        try {
            this.state = 3235;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 145, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3219;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3215;
                    this.match(GremlinParser.K_P);
                    this.state = 3216;
                    this.match(GremlinParser.DOT);
                    this.state = 3217;
                    this.match(GremlinParser.K_EQ);
                    }
                    break;
                case GremlinParser.K_EQ:
                    {
                    this.state = 3218;
                    this.match(GremlinParser.K_EQ);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3221;
                this.match(GremlinParser.LPAREN);
                this.state = 3222;
                this.genericArgument();
                this.state = 3223;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3229;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3225;
                    this.match(GremlinParser.K_P);
                    this.state = 3226;
                    this.match(GremlinParser.DOT);
                    this.state = 3227;
                    this.match(GremlinParser.K_EQ);
                    }
                    break;
                case GremlinParser.K_EQ:
                    {
                    this.state = 3228;
                    this.match(GremlinParser.K_EQ);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3231;
                this.match(GremlinParser.LPAREN);
                this.state = 3232;
                this.nestedTraversal();
                this.state = 3233;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_neq(): TraversalPredicate_neqContext {
        let localContext = new TraversalPredicate_neqContext(this.context, this.state);
        this.enterRule(localContext, 390, GremlinParser.RULE_traversalPredicate_neq);
        try {
            this.state = 3257;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 148, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3241;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3237;
                    this.match(GremlinParser.K_P);
                    this.state = 3238;
                    this.match(GremlinParser.DOT);
                    this.state = 3239;
                    this.match(GremlinParser.K_NEQ);
                    }
                    break;
                case GremlinParser.K_NEQ:
                    {
                    this.state = 3240;
                    this.match(GremlinParser.K_NEQ);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3243;
                this.match(GremlinParser.LPAREN);
                this.state = 3244;
                this.genericArgument();
                this.state = 3245;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3251;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3247;
                    this.match(GremlinParser.K_P);
                    this.state = 3248;
                    this.match(GremlinParser.DOT);
                    this.state = 3249;
                    this.match(GremlinParser.K_NEQ);
                    }
                    break;
                case GremlinParser.K_NEQ:
                    {
                    this.state = 3250;
                    this.match(GremlinParser.K_NEQ);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3253;
                this.match(GremlinParser.LPAREN);
                this.state = 3254;
                this.nestedTraversal();
                this.state = 3255;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_typeOf(): TraversalPredicate_typeOfContext {
        let localContext = new TraversalPredicate_typeOfContext(this.context, this.state);
        this.enterRule(localContext, 392, GremlinParser.RULE_traversalPredicate_typeOf);
        try {
            this.state = 3279;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 151, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3263;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3259;
                    this.match(GremlinParser.K_P);
                    this.state = 3260;
                    this.match(GremlinParser.DOT);
                    this.state = 3261;
                    this.match(GremlinParser.K_TYPEOF);
                    }
                    break;
                case GremlinParser.K_TYPEOF:
                    {
                    this.state = 3262;
                    this.match(GremlinParser.K_TYPEOF);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3265;
                this.match(GremlinParser.LPAREN);
                this.state = 3266;
                this.traversalGType();
                this.state = 3267;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3273;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3269;
                    this.match(GremlinParser.K_P);
                    this.state = 3270;
                    this.match(GremlinParser.DOT);
                    this.state = 3271;
                    this.match(GremlinParser.K_TYPEOF);
                    }
                    break;
                case GremlinParser.K_TYPEOF:
                    {
                    this.state = 3272;
                    this.match(GremlinParser.K_TYPEOF);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3275;
                this.match(GremlinParser.LPAREN);
                this.state = 3276;
                this.stringLiteral();
                this.state = 3277;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_lt(): TraversalPredicate_ltContext {
        let localContext = new TraversalPredicate_ltContext(this.context, this.state);
        this.enterRule(localContext, 394, GremlinParser.RULE_traversalPredicate_lt);
        try {
            this.state = 3301;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 154, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3285;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3281;
                    this.match(GremlinParser.K_P);
                    this.state = 3282;
                    this.match(GremlinParser.DOT);
                    this.state = 3283;
                    this.match(GremlinParser.K_LT);
                    }
                    break;
                case GremlinParser.K_LT:
                    {
                    this.state = 3284;
                    this.match(GremlinParser.K_LT);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3287;
                this.match(GremlinParser.LPAREN);
                this.state = 3288;
                this.genericArgument();
                this.state = 3289;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3295;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3291;
                    this.match(GremlinParser.K_P);
                    this.state = 3292;
                    this.match(GremlinParser.DOT);
                    this.state = 3293;
                    this.match(GremlinParser.K_LT);
                    }
                    break;
                case GremlinParser.K_LT:
                    {
                    this.state = 3294;
                    this.match(GremlinParser.K_LT);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3297;
                this.match(GremlinParser.LPAREN);
                this.state = 3298;
                this.nestedTraversal();
                this.state = 3299;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_lte(): TraversalPredicate_lteContext {
        let localContext = new TraversalPredicate_lteContext(this.context, this.state);
        this.enterRule(localContext, 396, GremlinParser.RULE_traversalPredicate_lte);
        try {
            this.state = 3323;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 157, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3307;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3303;
                    this.match(GremlinParser.K_P);
                    this.state = 3304;
                    this.match(GremlinParser.DOT);
                    this.state = 3305;
                    this.match(GremlinParser.K_LTE);
                    }
                    break;
                case GremlinParser.K_LTE:
                    {
                    this.state = 3306;
                    this.match(GremlinParser.K_LTE);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3309;
                this.match(GremlinParser.LPAREN);
                this.state = 3310;
                this.genericArgument();
                this.state = 3311;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3317;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3313;
                    this.match(GremlinParser.K_P);
                    this.state = 3314;
                    this.match(GremlinParser.DOT);
                    this.state = 3315;
                    this.match(GremlinParser.K_LTE);
                    }
                    break;
                case GremlinParser.K_LTE:
                    {
                    this.state = 3316;
                    this.match(GremlinParser.K_LTE);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3319;
                this.match(GremlinParser.LPAREN);
                this.state = 3320;
                this.nestedTraversal();
                this.state = 3321;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_gt(): TraversalPredicate_gtContext {
        let localContext = new TraversalPredicate_gtContext(this.context, this.state);
        this.enterRule(localContext, 398, GremlinParser.RULE_traversalPredicate_gt);
        try {
            this.state = 3345;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 160, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3329;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3325;
                    this.match(GremlinParser.K_P);
                    this.state = 3326;
                    this.match(GremlinParser.DOT);
                    this.state = 3327;
                    this.match(GremlinParser.K_GT);
                    }
                    break;
                case GremlinParser.K_GT:
                    {
                    this.state = 3328;
                    this.match(GremlinParser.K_GT);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3331;
                this.match(GremlinParser.LPAREN);
                this.state = 3332;
                this.genericArgument();
                this.state = 3333;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3339;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3335;
                    this.match(GremlinParser.K_P);
                    this.state = 3336;
                    this.match(GremlinParser.DOT);
                    this.state = 3337;
                    this.match(GremlinParser.K_GT);
                    }
                    break;
                case GremlinParser.K_GT:
                    {
                    this.state = 3338;
                    this.match(GremlinParser.K_GT);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3341;
                this.match(GremlinParser.LPAREN);
                this.state = 3342;
                this.nestedTraversal();
                this.state = 3343;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_gte(): TraversalPredicate_gteContext {
        let localContext = new TraversalPredicate_gteContext(this.context, this.state);
        this.enterRule(localContext, 400, GremlinParser.RULE_traversalPredicate_gte);
        try {
            this.state = 3367;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 163, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3351;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3347;
                    this.match(GremlinParser.K_P);
                    this.state = 3348;
                    this.match(GremlinParser.DOT);
                    this.state = 3349;
                    this.match(GremlinParser.K_GTE);
                    }
                    break;
                case GremlinParser.K_GTE:
                    {
                    this.state = 3350;
                    this.match(GremlinParser.K_GTE);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3353;
                this.match(GremlinParser.LPAREN);
                this.state = 3354;
                this.genericArgument();
                this.state = 3355;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3361;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3357;
                    this.match(GremlinParser.K_P);
                    this.state = 3358;
                    this.match(GremlinParser.DOT);
                    this.state = 3359;
                    this.match(GremlinParser.K_GTE);
                    }
                    break;
                case GremlinParser.K_GTE:
                    {
                    this.state = 3360;
                    this.match(GremlinParser.K_GTE);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3363;
                this.match(GremlinParser.LPAREN);
                this.state = 3364;
                this.nestedTraversal();
                this.state = 3365;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_inside(): TraversalPredicate_insideContext {
        let localContext = new TraversalPredicate_insideContext(this.context, this.state);
        this.enterRule(localContext, 402, GremlinParser.RULE_traversalPredicate_inside);
        try {
            this.state = 3393;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 166, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3373;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3369;
                    this.match(GremlinParser.K_P);
                    this.state = 3370;
                    this.match(GremlinParser.DOT);
                    this.state = 3371;
                    this.match(GremlinParser.K_INSIDE);
                    }
                    break;
                case GremlinParser.K_INSIDE:
                    {
                    this.state = 3372;
                    this.match(GremlinParser.K_INSIDE);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3375;
                this.match(GremlinParser.LPAREN);
                this.state = 3376;
                this.genericArgument();
                this.state = 3377;
                this.match(GremlinParser.COMMA);
                this.state = 3378;
                this.genericArgument();
                this.state = 3379;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3385;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3381;
                    this.match(GremlinParser.K_P);
                    this.state = 3382;
                    this.match(GremlinParser.DOT);
                    this.state = 3383;
                    this.match(GremlinParser.K_INSIDE);
                    }
                    break;
                case GremlinParser.K_INSIDE:
                    {
                    this.state = 3384;
                    this.match(GremlinParser.K_INSIDE);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3387;
                this.match(GremlinParser.LPAREN);
                this.state = 3388;
                this.nestedTraversal();
                this.state = 3389;
                this.match(GremlinParser.COMMA);
                this.state = 3390;
                this.nestedTraversal();
                this.state = 3391;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_outside(): TraversalPredicate_outsideContext {
        let localContext = new TraversalPredicate_outsideContext(this.context, this.state);
        this.enterRule(localContext, 404, GremlinParser.RULE_traversalPredicate_outside);
        try {
            this.state = 3419;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 169, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3399;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3395;
                    this.match(GremlinParser.K_P);
                    this.state = 3396;
                    this.match(GremlinParser.DOT);
                    this.state = 3397;
                    this.match(GremlinParser.K_OUTSIDE);
                    }
                    break;
                case GremlinParser.K_OUTSIDE:
                    {
                    this.state = 3398;
                    this.match(GremlinParser.K_OUTSIDE);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3401;
                this.match(GremlinParser.LPAREN);
                this.state = 3402;
                this.genericArgument();
                this.state = 3403;
                this.match(GremlinParser.COMMA);
                this.state = 3404;
                this.genericArgument();
                this.state = 3405;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3411;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3407;
                    this.match(GremlinParser.K_P);
                    this.state = 3408;
                    this.match(GremlinParser.DOT);
                    this.state = 3409;
                    this.match(GremlinParser.K_OUTSIDE);
                    }
                    break;
                case GremlinParser.K_OUTSIDE:
                    {
                    this.state = 3410;
                    this.match(GremlinParser.K_OUTSIDE);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3413;
                this.match(GremlinParser.LPAREN);
                this.state = 3414;
                this.nestedTraversal();
                this.state = 3415;
                this.match(GremlinParser.COMMA);
                this.state = 3416;
                this.nestedTraversal();
                this.state = 3417;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_between(): TraversalPredicate_betweenContext {
        let localContext = new TraversalPredicate_betweenContext(this.context, this.state);
        this.enterRule(localContext, 406, GremlinParser.RULE_traversalPredicate_between);
        try {
            this.state = 3445;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 172, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3425;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3421;
                    this.match(GremlinParser.K_P);
                    this.state = 3422;
                    this.match(GremlinParser.DOT);
                    this.state = 3423;
                    this.match(GremlinParser.K_BETWEEN);
                    }
                    break;
                case GremlinParser.K_BETWEEN:
                    {
                    this.state = 3424;
                    this.match(GremlinParser.K_BETWEEN);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3427;
                this.match(GremlinParser.LPAREN);
                this.state = 3428;
                this.genericArgument();
                this.state = 3429;
                this.match(GremlinParser.COMMA);
                this.state = 3430;
                this.genericArgument();
                this.state = 3431;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3437;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3433;
                    this.match(GremlinParser.K_P);
                    this.state = 3434;
                    this.match(GremlinParser.DOT);
                    this.state = 3435;
                    this.match(GremlinParser.K_BETWEEN);
                    }
                    break;
                case GremlinParser.K_BETWEEN:
                    {
                    this.state = 3436;
                    this.match(GremlinParser.K_BETWEEN);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3439;
                this.match(GremlinParser.LPAREN);
                this.state = 3440;
                this.nestedTraversal();
                this.state = 3441;
                this.match(GremlinParser.COMMA);
                this.state = 3442;
                this.nestedTraversal();
                this.state = 3443;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_within(): TraversalPredicate_withinContext {
        let localContext = new TraversalPredicate_withinContext(this.context, this.state);
        this.enterRule(localContext, 408, GremlinParser.RULE_traversalPredicate_within);
        try {
            this.state = 3475;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 176, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3451;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3447;
                    this.match(GremlinParser.K_P);
                    this.state = 3448;
                    this.match(GremlinParser.DOT);
                    this.state = 3449;
                    this.match(GremlinParser.K_WITHIN);
                    }
                    break;
                case GremlinParser.K_WITHIN:
                    {
                    this.state = 3450;
                    this.match(GremlinParser.K_WITHIN);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3453;
                this.match(GremlinParser.LPAREN);
                this.state = 3454;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3459;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3455;
                    this.match(GremlinParser.K_P);
                    this.state = 3456;
                    this.match(GremlinParser.DOT);
                    this.state = 3457;
                    this.match(GremlinParser.K_WITHIN);
                    }
                    break;
                case GremlinParser.K_WITHIN:
                    {
                    this.state = 3458;
                    this.match(GremlinParser.K_WITHIN);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3461;
                this.match(GremlinParser.LPAREN);
                this.state = 3462;
                this.genericArgumentVarargs();
                this.state = 3463;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3469;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3465;
                    this.match(GremlinParser.K_P);
                    this.state = 3466;
                    this.match(GremlinParser.DOT);
                    this.state = 3467;
                    this.match(GremlinParser.K_WITHIN);
                    }
                    break;
                case GremlinParser.K_WITHIN:
                    {
                    this.state = 3468;
                    this.match(GremlinParser.K_WITHIN);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3471;
                this.match(GremlinParser.LPAREN);
                this.state = 3472;
                this.nestedTraversal();
                this.state = 3473;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_without(): TraversalPredicate_withoutContext {
        let localContext = new TraversalPredicate_withoutContext(this.context, this.state);
        this.enterRule(localContext, 410, GremlinParser.RULE_traversalPredicate_without);
        try {
            this.state = 3505;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 180, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3481;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3477;
                    this.match(GremlinParser.K_P);
                    this.state = 3478;
                    this.match(GremlinParser.DOT);
                    this.state = 3479;
                    this.match(GremlinParser.K_WITHOUT);
                    }
                    break;
                case GremlinParser.K_WITHOUT:
                    {
                    this.state = 3480;
                    this.match(GremlinParser.K_WITHOUT);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3483;
                this.match(GremlinParser.LPAREN);
                this.state = 3484;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3489;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3485;
                    this.match(GremlinParser.K_P);
                    this.state = 3486;
                    this.match(GremlinParser.DOT);
                    this.state = 3487;
                    this.match(GremlinParser.K_WITHOUT);
                    }
                    break;
                case GremlinParser.K_WITHOUT:
                    {
                    this.state = 3488;
                    this.match(GremlinParser.K_WITHOUT);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3491;
                this.match(GremlinParser.LPAREN);
                this.state = 3492;
                this.genericArgumentVarargs();
                this.state = 3493;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3499;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_P:
                    {
                    this.state = 3495;
                    this.match(GremlinParser.K_P);
                    this.state = 3496;
                    this.match(GremlinParser.DOT);
                    this.state = 3497;
                    this.match(GremlinParser.K_WITHOUT);
                    }
                    break;
                case GremlinParser.K_WITHOUT:
                    {
                    this.state = 3498;
                    this.match(GremlinParser.K_WITHOUT);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3501;
                this.match(GremlinParser.LPAREN);
                this.state = 3502;
                this.nestedTraversal();
                this.state = 3503;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_not(): TraversalPredicate_notContext {
        let localContext = new TraversalPredicate_notContext(this.context, this.state);
        this.enterRule(localContext, 412, GremlinParser.RULE_traversalPredicate_not);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3511;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_P:
                {
                this.state = 3507;
                this.match(GremlinParser.K_P);
                this.state = 3508;
                this.match(GremlinParser.DOT);
                this.state = 3509;
                this.match(GremlinParser.K_NOT);
                }
                break;
            case GremlinParser.K_NOT:
                {
                this.state = 3510;
                this.match(GremlinParser.K_NOT);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
            this.state = 3513;
            this.match(GremlinParser.LPAREN);
            this.state = 3514;
            this.traversalPredicate(0);
            this.state = 3515;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_containing(): TraversalPredicate_containingContext {
        let localContext = new TraversalPredicate_containingContext(this.context, this.state);
        this.enterRule(localContext, 414, GremlinParser.RULE_traversalPredicate_containing);
        try {
            this.state = 3537;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 184, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3521;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_TEXTP:
                    {
                    this.state = 3517;
                    this.match(GremlinParser.K_TEXTP);
                    this.state = 3518;
                    this.match(GremlinParser.DOT);
                    this.state = 3519;
                    this.match(GremlinParser.K_CONTAINING);
                    }
                    break;
                case GremlinParser.K_CONTAINING:
                    {
                    this.state = 3520;
                    this.match(GremlinParser.K_CONTAINING);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3523;
                this.match(GremlinParser.LPAREN);
                this.state = 3524;
                this.stringArgument();
                this.state = 3525;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3531;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_TEXTP:
                    {
                    this.state = 3527;
                    this.match(GremlinParser.K_TEXTP);
                    this.state = 3528;
                    this.match(GremlinParser.DOT);
                    this.state = 3529;
                    this.match(GremlinParser.K_CONTAINING);
                    }
                    break;
                case GremlinParser.K_CONTAINING:
                    {
                    this.state = 3530;
                    this.match(GremlinParser.K_CONTAINING);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3533;
                this.match(GremlinParser.LPAREN);
                this.state = 3534;
                this.nestedTraversal();
                this.state = 3535;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_notContaining(): TraversalPredicate_notContainingContext {
        let localContext = new TraversalPredicate_notContainingContext(this.context, this.state);
        this.enterRule(localContext, 416, GremlinParser.RULE_traversalPredicate_notContaining);
        try {
            this.state = 3559;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 187, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3543;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_TEXTP:
                    {
                    this.state = 3539;
                    this.match(GremlinParser.K_TEXTP);
                    this.state = 3540;
                    this.match(GremlinParser.DOT);
                    this.state = 3541;
                    this.match(GremlinParser.K_NOTCONTAINING);
                    }
                    break;
                case GremlinParser.K_NOTCONTAINING:
                    {
                    this.state = 3542;
                    this.match(GremlinParser.K_NOTCONTAINING);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3545;
                this.match(GremlinParser.LPAREN);
                this.state = 3546;
                this.stringArgument();
                this.state = 3547;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3553;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_TEXTP:
                    {
                    this.state = 3549;
                    this.match(GremlinParser.K_TEXTP);
                    this.state = 3550;
                    this.match(GremlinParser.DOT);
                    this.state = 3551;
                    this.match(GremlinParser.K_NOTCONTAINING);
                    }
                    break;
                case GremlinParser.K_NOTCONTAINING:
                    {
                    this.state = 3552;
                    this.match(GremlinParser.K_NOTCONTAINING);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3555;
                this.match(GremlinParser.LPAREN);
                this.state = 3556;
                this.nestedTraversal();
                this.state = 3557;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_startingWith(): TraversalPredicate_startingWithContext {
        let localContext = new TraversalPredicate_startingWithContext(this.context, this.state);
        this.enterRule(localContext, 418, GremlinParser.RULE_traversalPredicate_startingWith);
        try {
            this.state = 3581;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 190, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3565;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_TEXTP:
                    {
                    this.state = 3561;
                    this.match(GremlinParser.K_TEXTP);
                    this.state = 3562;
                    this.match(GremlinParser.DOT);
                    this.state = 3563;
                    this.match(GremlinParser.K_STARTINGWITH);
                    }
                    break;
                case GremlinParser.K_STARTINGWITH:
                    {
                    this.state = 3564;
                    this.match(GremlinParser.K_STARTINGWITH);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3567;
                this.match(GremlinParser.LPAREN);
                this.state = 3568;
                this.stringArgument();
                this.state = 3569;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3575;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_TEXTP:
                    {
                    this.state = 3571;
                    this.match(GremlinParser.K_TEXTP);
                    this.state = 3572;
                    this.match(GremlinParser.DOT);
                    this.state = 3573;
                    this.match(GremlinParser.K_STARTINGWITH);
                    }
                    break;
                case GremlinParser.K_STARTINGWITH:
                    {
                    this.state = 3574;
                    this.match(GremlinParser.K_STARTINGWITH);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3577;
                this.match(GremlinParser.LPAREN);
                this.state = 3578;
                this.nestedTraversal();
                this.state = 3579;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_notStartingWith(): TraversalPredicate_notStartingWithContext {
        let localContext = new TraversalPredicate_notStartingWithContext(this.context, this.state);
        this.enterRule(localContext, 420, GremlinParser.RULE_traversalPredicate_notStartingWith);
        try {
            this.state = 3603;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 193, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3587;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_TEXTP:
                    {
                    this.state = 3583;
                    this.match(GremlinParser.K_TEXTP);
                    this.state = 3584;
                    this.match(GremlinParser.DOT);
                    this.state = 3585;
                    this.match(GremlinParser.K_NOTSTARTINGWITH);
                    }
                    break;
                case GremlinParser.K_NOTSTARTINGWITH:
                    {
                    this.state = 3586;
                    this.match(GremlinParser.K_NOTSTARTINGWITH);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3589;
                this.match(GremlinParser.LPAREN);
                this.state = 3590;
                this.stringArgument();
                this.state = 3591;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3597;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_TEXTP:
                    {
                    this.state = 3593;
                    this.match(GremlinParser.K_TEXTP);
                    this.state = 3594;
                    this.match(GremlinParser.DOT);
                    this.state = 3595;
                    this.match(GremlinParser.K_NOTSTARTINGWITH);
                    }
                    break;
                case GremlinParser.K_NOTSTARTINGWITH:
                    {
                    this.state = 3596;
                    this.match(GremlinParser.K_NOTSTARTINGWITH);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3599;
                this.match(GremlinParser.LPAREN);
                this.state = 3600;
                this.nestedTraversal();
                this.state = 3601;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_endingWith(): TraversalPredicate_endingWithContext {
        let localContext = new TraversalPredicate_endingWithContext(this.context, this.state);
        this.enterRule(localContext, 422, GremlinParser.RULE_traversalPredicate_endingWith);
        try {
            this.state = 3625;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 196, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3609;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_TEXTP:
                    {
                    this.state = 3605;
                    this.match(GremlinParser.K_TEXTP);
                    this.state = 3606;
                    this.match(GremlinParser.DOT);
                    this.state = 3607;
                    this.match(GremlinParser.K_ENDINGWITH);
                    }
                    break;
                case GremlinParser.K_ENDINGWITH:
                    {
                    this.state = 3608;
                    this.match(GremlinParser.K_ENDINGWITH);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3611;
                this.match(GremlinParser.LPAREN);
                this.state = 3612;
                this.stringArgument();
                this.state = 3613;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3619;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_TEXTP:
                    {
                    this.state = 3615;
                    this.match(GremlinParser.K_TEXTP);
                    this.state = 3616;
                    this.match(GremlinParser.DOT);
                    this.state = 3617;
                    this.match(GremlinParser.K_ENDINGWITH);
                    }
                    break;
                case GremlinParser.K_ENDINGWITH:
                    {
                    this.state = 3618;
                    this.match(GremlinParser.K_ENDINGWITH);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3621;
                this.match(GremlinParser.LPAREN);
                this.state = 3622;
                this.nestedTraversal();
                this.state = 3623;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_notEndingWith(): TraversalPredicate_notEndingWithContext {
        let localContext = new TraversalPredicate_notEndingWithContext(this.context, this.state);
        this.enterRule(localContext, 424, GremlinParser.RULE_traversalPredicate_notEndingWith);
        try {
            this.state = 3647;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 199, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3631;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_TEXTP:
                    {
                    this.state = 3627;
                    this.match(GremlinParser.K_TEXTP);
                    this.state = 3628;
                    this.match(GremlinParser.DOT);
                    this.state = 3629;
                    this.match(GremlinParser.K_NOTENDINGWITH);
                    }
                    break;
                case GremlinParser.K_NOTENDINGWITH:
                    {
                    this.state = 3630;
                    this.match(GremlinParser.K_NOTENDINGWITH);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3633;
                this.match(GremlinParser.LPAREN);
                this.state = 3634;
                this.stringArgument();
                this.state = 3635;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3641;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_TEXTP:
                    {
                    this.state = 3637;
                    this.match(GremlinParser.K_TEXTP);
                    this.state = 3638;
                    this.match(GremlinParser.DOT);
                    this.state = 3639;
                    this.match(GremlinParser.K_NOTENDINGWITH);
                    }
                    break;
                case GremlinParser.K_NOTENDINGWITH:
                    {
                    this.state = 3640;
                    this.match(GremlinParser.K_NOTENDINGWITH);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3643;
                this.match(GremlinParser.LPAREN);
                this.state = 3644;
                this.nestedTraversal();
                this.state = 3645;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_regex(): TraversalPredicate_regexContext {
        let localContext = new TraversalPredicate_regexContext(this.context, this.state);
        this.enterRule(localContext, 426, GremlinParser.RULE_traversalPredicate_regex);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3653;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_TEXTP:
                {
                this.state = 3649;
                this.match(GremlinParser.K_TEXTP);
                this.state = 3650;
                this.match(GremlinParser.DOT);
                this.state = 3651;
                this.match(GremlinParser.K_REGEX);
                }
                break;
            case GremlinParser.K_REGEX:
                {
                this.state = 3652;
                this.match(GremlinParser.K_REGEX);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
            this.state = 3655;
            this.match(GremlinParser.LPAREN);
            this.state = 3656;
            this.stringArgument();
            this.state = 3657;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalPredicate_notRegex(): TraversalPredicate_notRegexContext {
        let localContext = new TraversalPredicate_notRegexContext(this.context, this.state);
        this.enterRule(localContext, 428, GremlinParser.RULE_traversalPredicate_notRegex);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3663;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_TEXTP:
                {
                this.state = 3659;
                this.match(GremlinParser.K_TEXTP);
                this.state = 3660;
                this.match(GremlinParser.DOT);
                this.state = 3661;
                this.match(GremlinParser.K_NOTREGEX);
                }
                break;
            case GremlinParser.K_NOTREGEX:
                {
                this.state = 3662;
                this.match(GremlinParser.K_NOTREGEX);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
            this.state = 3665;
            this.match(GremlinParser.LPAREN);
            this.state = 3666;
            this.stringArgument();
            this.state = 3667;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalTerminalMethod_explain(): TraversalTerminalMethod_explainContext {
        let localContext = new TraversalTerminalMethod_explainContext(this.context, this.state);
        this.enterRule(localContext, 430, GremlinParser.RULE_traversalTerminalMethod_explain);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3669;
            this.match(GremlinParser.K_EXPLAIN);
            this.state = 3670;
            this.match(GremlinParser.LPAREN);
            this.state = 3671;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalTerminalMethod_hasNext(): TraversalTerminalMethod_hasNextContext {
        let localContext = new TraversalTerminalMethod_hasNextContext(this.context, this.state);
        this.enterRule(localContext, 432, GremlinParser.RULE_traversalTerminalMethod_hasNext);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3673;
            this.match(GremlinParser.K_HASNEXT);
            this.state = 3674;
            this.match(GremlinParser.LPAREN);
            this.state = 3675;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalTerminalMethod_iterate(): TraversalTerminalMethod_iterateContext {
        let localContext = new TraversalTerminalMethod_iterateContext(this.context, this.state);
        this.enterRule(localContext, 434, GremlinParser.RULE_traversalTerminalMethod_iterate);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3677;
            this.match(GremlinParser.K_ITERATE);
            this.state = 3678;
            this.match(GremlinParser.LPAREN);
            this.state = 3679;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalTerminalMethod_tryNext(): TraversalTerminalMethod_tryNextContext {
        let localContext = new TraversalTerminalMethod_tryNextContext(this.context, this.state);
        this.enterRule(localContext, 436, GremlinParser.RULE_traversalTerminalMethod_tryNext);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3681;
            this.match(GremlinParser.K_TRYNEXT);
            this.state = 3682;
            this.match(GremlinParser.LPAREN);
            this.state = 3683;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalTerminalMethod_next(): TraversalTerminalMethod_nextContext {
        let localContext = new TraversalTerminalMethod_nextContext(this.context, this.state);
        this.enterRule(localContext, 438, GremlinParser.RULE_traversalTerminalMethod_next);
        try {
            this.state = 3693;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 202, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3685;
                this.match(GremlinParser.K_NEXT);
                this.state = 3686;
                this.match(GremlinParser.LPAREN);
                this.state = 3687;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3688;
                this.match(GremlinParser.K_NEXT);
                this.state = 3689;
                this.match(GremlinParser.LPAREN);
                this.state = 3690;
                this.integerLiteral();
                this.state = 3691;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalTerminalMethod_toList(): TraversalTerminalMethod_toListContext {
        let localContext = new TraversalTerminalMethod_toListContext(this.context, this.state);
        this.enterRule(localContext, 440, GremlinParser.RULE_traversalTerminalMethod_toList);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3695;
            this.match(GremlinParser.K_TOLIST);
            this.state = 3696;
            this.match(GremlinParser.LPAREN);
            this.state = 3697;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalTerminalMethod_toSet(): TraversalTerminalMethod_toSetContext {
        let localContext = new TraversalTerminalMethod_toSetContext(this.context, this.state);
        this.enterRule(localContext, 442, GremlinParser.RULE_traversalTerminalMethod_toSet);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3699;
            this.match(GremlinParser.K_TOSET);
            this.state = 3700;
            this.match(GremlinParser.LPAREN);
            this.state = 3701;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalTerminalMethod_toBulkSet(): TraversalTerminalMethod_toBulkSetContext {
        let localContext = new TraversalTerminalMethod_toBulkSetContext(this.context, this.state);
        this.enterRule(localContext, 444, GremlinParser.RULE_traversalTerminalMethod_toBulkSet);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3703;
            this.match(GremlinParser.K_TOBULKSET);
            this.state = 3704;
            this.match(GremlinParser.LPAREN);
            this.state = 3705;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public withOptionKeys(): WithOptionKeysContext {
        let localContext = new WithOptionKeysContext(this.context, this.state);
        this.enterRule(localContext, 446, GremlinParser.RULE_withOptionKeys);
        try {
            this.state = 3714;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 203, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3707;
                this.shortestPathConstants();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3708;
                this.connectedComponentConstants();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3709;
                this.pageRankConstants();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3710;
                this.peerPressureConstants();
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 3711;
                this.ioOptionsKeys();
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 3712;
                this.withOptionsConstants_tokens();
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 3713;
                this.withOptionsConstants_indexer();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public connectedComponentConstants(): ConnectedComponentConstantsContext {
        let localContext = new ConnectedComponentConstantsContext(this.context, this.state);
        this.enterRule(localContext, 448, GremlinParser.RULE_connectedComponentConstants);
        try {
            this.state = 3719;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 204, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3716;
                this.connectedComponentConstants_component();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3717;
                this.connectedComponentConstants_edges();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3718;
                this.connectedComponentConstants_propertyName();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public pageRankConstants(): PageRankConstantsContext {
        let localContext = new PageRankConstantsContext(this.context, this.state);
        this.enterRule(localContext, 450, GremlinParser.RULE_pageRankConstants);
        try {
            this.state = 3724;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 205, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3721;
                this.pageRankConstants_edges();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3722;
                this.pageRankConstants_times();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3723;
                this.pageRankConstants_propertyName();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public peerPressureConstants(): PeerPressureConstantsContext {
        let localContext = new PeerPressureConstantsContext(this.context, this.state);
        this.enterRule(localContext, 452, GremlinParser.RULE_peerPressureConstants);
        try {
            this.state = 3729;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 206, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3726;
                this.peerPressureConstants_edges();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3727;
                this.peerPressureConstants_times();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3728;
                this.peerPressureConstants_propertyName();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public shortestPathConstants(): ShortestPathConstantsContext {
        let localContext = new ShortestPathConstantsContext(this.context, this.state);
        this.enterRule(localContext, 454, GremlinParser.RULE_shortestPathConstants);
        try {
            this.state = 3736;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 207, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3731;
                this.shortestPathConstants_target();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3732;
                this.shortestPathConstants_edges();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3733;
                this.shortestPathConstants_distance();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3734;
                this.shortestPathConstants_maxDistance();
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 3735;
                this.shortestPathConstants_includeEdges();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public withOptionsValues(): WithOptionsValuesContext {
        let localContext = new WithOptionsValuesContext(this.context, this.state);
        this.enterRule(localContext, 456, GremlinParser.RULE_withOptionsValues);
        try {
            this.state = 3747;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 208, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3738;
                this.withOptionsConstants_tokens();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3739;
                this.withOptionsConstants_none();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3740;
                this.withOptionsConstants_ids();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3741;
                this.withOptionsConstants_labels();
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 3742;
                this.withOptionsConstants_keys();
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 3743;
                this.withOptionsConstants_values();
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 3744;
                this.withOptionsConstants_all();
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 3745;
                this.withOptionsConstants_list();
                }
                break;
            case 9:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 3746;
                this.withOptionsConstants_map();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public ioOptionsKeys(): IoOptionsKeysContext {
        let localContext = new IoOptionsKeysContext(this.context, this.state);
        this.enterRule(localContext, 458, GremlinParser.RULE_ioOptionsKeys);
        try {
            this.state = 3751;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 209, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3749;
                this.ioOptionsConstants_reader();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3750;
                this.ioOptionsConstants_writer();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public ioOptionsValues(): IoOptionsValuesContext {
        let localContext = new IoOptionsValuesContext(this.context, this.state);
        this.enterRule(localContext, 460, GremlinParser.RULE_ioOptionsValues);
        try {
            this.state = 3756;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 210, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3753;
                this.ioOptionsConstants_gryo();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3754;
                this.ioOptionsConstants_graphson();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3755;
                this.ioOptionsConstants_graphml();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public connectedComponentConstants_component(): ConnectedComponentConstants_componentContext {
        let localContext = new ConnectedComponentConstants_componentContext(this.context, this.state);
        this.enterRule(localContext, 462, GremlinParser.RULE_connectedComponentConstants_component);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3758;
            this.connectedComponentStringConstant();
            this.state = 3759;
            this.match(GremlinParser.DOT);
            this.state = 3760;
            this.match(GremlinParser.K_COMPONENT);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public connectedComponentConstants_edges(): ConnectedComponentConstants_edgesContext {
        let localContext = new ConnectedComponentConstants_edgesContext(this.context, this.state);
        this.enterRule(localContext, 464, GremlinParser.RULE_connectedComponentConstants_edges);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3762;
            this.connectedComponentStringConstant();
            this.state = 3763;
            this.match(GremlinParser.DOT);
            this.state = 3764;
            this.match(GremlinParser.K_EDGES);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public connectedComponentConstants_propertyName(): ConnectedComponentConstants_propertyNameContext {
        let localContext = new ConnectedComponentConstants_propertyNameContext(this.context, this.state);
        this.enterRule(localContext, 466, GremlinParser.RULE_connectedComponentConstants_propertyName);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3766;
            this.connectedComponentStringConstant();
            this.state = 3767;
            this.match(GremlinParser.DOT);
            this.state = 3768;
            this.match(GremlinParser.K_PROPERTYNAME);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public pageRankConstants_edges(): PageRankConstants_edgesContext {
        let localContext = new PageRankConstants_edgesContext(this.context, this.state);
        this.enterRule(localContext, 468, GremlinParser.RULE_pageRankConstants_edges);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3770;
            this.pageRankStringConstant();
            this.state = 3771;
            this.match(GremlinParser.DOT);
            this.state = 3772;
            this.match(GremlinParser.K_EDGES);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public pageRankConstants_times(): PageRankConstants_timesContext {
        let localContext = new PageRankConstants_timesContext(this.context, this.state);
        this.enterRule(localContext, 470, GremlinParser.RULE_pageRankConstants_times);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3774;
            this.pageRankStringConstant();
            this.state = 3775;
            this.match(GremlinParser.DOT);
            this.state = 3776;
            this.match(GremlinParser.K_TIMES);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public pageRankConstants_propertyName(): PageRankConstants_propertyNameContext {
        let localContext = new PageRankConstants_propertyNameContext(this.context, this.state);
        this.enterRule(localContext, 472, GremlinParser.RULE_pageRankConstants_propertyName);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3778;
            this.pageRankStringConstant();
            this.state = 3779;
            this.match(GremlinParser.DOT);
            this.state = 3780;
            this.match(GremlinParser.K_PROPERTYNAME);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public peerPressureConstants_edges(): PeerPressureConstants_edgesContext {
        let localContext = new PeerPressureConstants_edgesContext(this.context, this.state);
        this.enterRule(localContext, 474, GremlinParser.RULE_peerPressureConstants_edges);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3782;
            this.peerPressureStringConstant();
            this.state = 3783;
            this.match(GremlinParser.DOT);
            this.state = 3784;
            this.match(GremlinParser.K_EDGES);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public peerPressureConstants_times(): PeerPressureConstants_timesContext {
        let localContext = new PeerPressureConstants_timesContext(this.context, this.state);
        this.enterRule(localContext, 476, GremlinParser.RULE_peerPressureConstants_times);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3786;
            this.peerPressureStringConstant();
            this.state = 3787;
            this.match(GremlinParser.DOT);
            this.state = 3788;
            this.match(GremlinParser.K_TIMES);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public peerPressureConstants_propertyName(): PeerPressureConstants_propertyNameContext {
        let localContext = new PeerPressureConstants_propertyNameContext(this.context, this.state);
        this.enterRule(localContext, 478, GremlinParser.RULE_peerPressureConstants_propertyName);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3790;
            this.peerPressureStringConstant();
            this.state = 3791;
            this.match(GremlinParser.DOT);
            this.state = 3792;
            this.match(GremlinParser.K_PROPERTYNAME);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public shortestPathConstants_target(): ShortestPathConstants_targetContext {
        let localContext = new ShortestPathConstants_targetContext(this.context, this.state);
        this.enterRule(localContext, 480, GremlinParser.RULE_shortestPathConstants_target);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3794;
            this.shortestPathStringConstant();
            this.state = 3795;
            this.match(GremlinParser.DOT);
            this.state = 3796;
            this.match(GremlinParser.K_TARGET);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public shortestPathConstants_edges(): ShortestPathConstants_edgesContext {
        let localContext = new ShortestPathConstants_edgesContext(this.context, this.state);
        this.enterRule(localContext, 482, GremlinParser.RULE_shortestPathConstants_edges);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3798;
            this.shortestPathStringConstant();
            this.state = 3799;
            this.match(GremlinParser.DOT);
            this.state = 3800;
            this.match(GremlinParser.K_EDGES);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public shortestPathConstants_distance(): ShortestPathConstants_distanceContext {
        let localContext = new ShortestPathConstants_distanceContext(this.context, this.state);
        this.enterRule(localContext, 484, GremlinParser.RULE_shortestPathConstants_distance);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3802;
            this.shortestPathStringConstant();
            this.state = 3803;
            this.match(GremlinParser.DOT);
            this.state = 3804;
            this.match(GremlinParser.K_DISTANCE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public shortestPathConstants_maxDistance(): ShortestPathConstants_maxDistanceContext {
        let localContext = new ShortestPathConstants_maxDistanceContext(this.context, this.state);
        this.enterRule(localContext, 486, GremlinParser.RULE_shortestPathConstants_maxDistance);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3806;
            this.shortestPathStringConstant();
            this.state = 3807;
            this.match(GremlinParser.DOT);
            this.state = 3808;
            this.match(GremlinParser.K_MAXDISTANCE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public shortestPathConstants_includeEdges(): ShortestPathConstants_includeEdgesContext {
        let localContext = new ShortestPathConstants_includeEdgesContext(this.context, this.state);
        this.enterRule(localContext, 488, GremlinParser.RULE_shortestPathConstants_includeEdges);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3810;
            this.shortestPathStringConstant();
            this.state = 3811;
            this.match(GremlinParser.DOT);
            this.state = 3812;
            this.match(GremlinParser.K_INCLUDEEDGES);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public withOptionsConstants_tokens(): WithOptionsConstants_tokensContext {
        let localContext = new WithOptionsConstants_tokensContext(this.context, this.state);
        this.enterRule(localContext, 490, GremlinParser.RULE_withOptionsConstants_tokens);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3814;
            this.withOptionsStringConstant();
            this.state = 3815;
            this.match(GremlinParser.DOT);
            this.state = 3816;
            this.match(GremlinParser.K_TOKENS);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public withOptionsConstants_none(): WithOptionsConstants_noneContext {
        let localContext = new WithOptionsConstants_noneContext(this.context, this.state);
        this.enterRule(localContext, 492, GremlinParser.RULE_withOptionsConstants_none);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3818;
            this.withOptionsStringConstant();
            this.state = 3819;
            this.match(GremlinParser.DOT);
            this.state = 3820;
            this.match(GremlinParser.K_NONE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public withOptionsConstants_ids(): WithOptionsConstants_idsContext {
        let localContext = new WithOptionsConstants_idsContext(this.context, this.state);
        this.enterRule(localContext, 494, GremlinParser.RULE_withOptionsConstants_ids);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3822;
            this.withOptionsStringConstant();
            this.state = 3823;
            this.match(GremlinParser.DOT);
            this.state = 3824;
            this.match(GremlinParser.K_IDS);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public withOptionsConstants_labels(): WithOptionsConstants_labelsContext {
        let localContext = new WithOptionsConstants_labelsContext(this.context, this.state);
        this.enterRule(localContext, 496, GremlinParser.RULE_withOptionsConstants_labels);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3826;
            this.withOptionsStringConstant();
            this.state = 3827;
            this.match(GremlinParser.DOT);
            this.state = 3828;
            this.match(GremlinParser.K_LABELS);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public withOptionsConstants_keys(): WithOptionsConstants_keysContext {
        let localContext = new WithOptionsConstants_keysContext(this.context, this.state);
        this.enterRule(localContext, 498, GremlinParser.RULE_withOptionsConstants_keys);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3830;
            this.withOptionsStringConstant();
            this.state = 3831;
            this.match(GremlinParser.DOT);
            this.state = 3832;
            this.match(GremlinParser.K_KEYS);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public withOptionsConstants_values(): WithOptionsConstants_valuesContext {
        let localContext = new WithOptionsConstants_valuesContext(this.context, this.state);
        this.enterRule(localContext, 500, GremlinParser.RULE_withOptionsConstants_values);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3834;
            this.withOptionsStringConstant();
            this.state = 3835;
            this.match(GremlinParser.DOT);
            this.state = 3836;
            this.match(GremlinParser.K_VALUES);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public withOptionsConstants_all(): WithOptionsConstants_allContext {
        let localContext = new WithOptionsConstants_allContext(this.context, this.state);
        this.enterRule(localContext, 502, GremlinParser.RULE_withOptionsConstants_all);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3838;
            this.withOptionsStringConstant();
            this.state = 3839;
            this.match(GremlinParser.DOT);
            this.state = 3840;
            this.match(GremlinParser.K_ALL);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public withOptionsConstants_indexer(): WithOptionsConstants_indexerContext {
        let localContext = new WithOptionsConstants_indexerContext(this.context, this.state);
        this.enterRule(localContext, 504, GremlinParser.RULE_withOptionsConstants_indexer);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3842;
            this.withOptionsStringConstant();
            this.state = 3843;
            this.match(GremlinParser.DOT);
            this.state = 3844;
            this.match(GremlinParser.K_INDEXER);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public withOptionsConstants_list(): WithOptionsConstants_listContext {
        let localContext = new WithOptionsConstants_listContext(this.context, this.state);
        this.enterRule(localContext, 506, GremlinParser.RULE_withOptionsConstants_list);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3846;
            this.withOptionsStringConstant();
            this.state = 3847;
            this.match(GremlinParser.DOT);
            this.state = 3848;
            this.match(GremlinParser.K_LIST);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public withOptionsConstants_map(): WithOptionsConstants_mapContext {
        let localContext = new WithOptionsConstants_mapContext(this.context, this.state);
        this.enterRule(localContext, 508, GremlinParser.RULE_withOptionsConstants_map);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3850;
            this.withOptionsStringConstant();
            this.state = 3851;
            this.match(GremlinParser.DOT);
            this.state = 3852;
            this.match(GremlinParser.K_MAP);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public ioOptionsConstants_reader(): IoOptionsConstants_readerContext {
        let localContext = new IoOptionsConstants_readerContext(this.context, this.state);
        this.enterRule(localContext, 510, GremlinParser.RULE_ioOptionsConstants_reader);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3854;
            this.ioOptionsStringConstant();
            this.state = 3855;
            this.match(GremlinParser.DOT);
            this.state = 3856;
            this.match(GremlinParser.K_READER);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public ioOptionsConstants_writer(): IoOptionsConstants_writerContext {
        let localContext = new IoOptionsConstants_writerContext(this.context, this.state);
        this.enterRule(localContext, 512, GremlinParser.RULE_ioOptionsConstants_writer);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3858;
            this.ioOptionsStringConstant();
            this.state = 3859;
            this.match(GremlinParser.DOT);
            this.state = 3860;
            this.match(GremlinParser.K_WRITER);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public ioOptionsConstants_gryo(): IoOptionsConstants_gryoContext {
        let localContext = new IoOptionsConstants_gryoContext(this.context, this.state);
        this.enterRule(localContext, 514, GremlinParser.RULE_ioOptionsConstants_gryo);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3862;
            this.ioOptionsStringConstant();
            this.state = 3863;
            this.match(GremlinParser.DOT);
            this.state = 3864;
            this.match(GremlinParser.K_GRYO);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public ioOptionsConstants_graphson(): IoOptionsConstants_graphsonContext {
        let localContext = new IoOptionsConstants_graphsonContext(this.context, this.state);
        this.enterRule(localContext, 516, GremlinParser.RULE_ioOptionsConstants_graphson);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3866;
            this.ioOptionsStringConstant();
            this.state = 3867;
            this.match(GremlinParser.DOT);
            this.state = 3868;
            this.match(GremlinParser.K_GRAPHSON);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public ioOptionsConstants_graphml(): IoOptionsConstants_graphmlContext {
        let localContext = new IoOptionsConstants_graphmlContext(this.context, this.state);
        this.enterRule(localContext, 518, GremlinParser.RULE_ioOptionsConstants_graphml);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3870;
            this.ioOptionsStringConstant();
            this.state = 3871;
            this.match(GremlinParser.DOT);
            this.state = 3872;
            this.match(GremlinParser.K_GRAPHML);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public connectedComponentStringConstant(): ConnectedComponentStringConstantContext {
        let localContext = new ConnectedComponentStringConstantContext(this.context, this.state);
        this.enterRule(localContext, 520, GremlinParser.RULE_connectedComponentStringConstant);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3874;
            this.match(GremlinParser.K_CONNECTEDCOMPONENTU);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public pageRankStringConstant(): PageRankStringConstantContext {
        let localContext = new PageRankStringConstantContext(this.context, this.state);
        this.enterRule(localContext, 522, GremlinParser.RULE_pageRankStringConstant);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3876;
            this.match(GremlinParser.K_PAGERANKU);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public peerPressureStringConstant(): PeerPressureStringConstantContext {
        let localContext = new PeerPressureStringConstantContext(this.context, this.state);
        this.enterRule(localContext, 524, GremlinParser.RULE_peerPressureStringConstant);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3878;
            this.match(GremlinParser.K_PEERPRESSUREU);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public shortestPathStringConstant(): ShortestPathStringConstantContext {
        let localContext = new ShortestPathStringConstantContext(this.context, this.state);
        this.enterRule(localContext, 526, GremlinParser.RULE_shortestPathStringConstant);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3880;
            this.match(GremlinParser.K_SHORTESTPATHU);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public withOptionsStringConstant(): WithOptionsStringConstantContext {
        let localContext = new WithOptionsStringConstantContext(this.context, this.state);
        this.enterRule(localContext, 528, GremlinParser.RULE_withOptionsStringConstant);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3882;
            this.match(GremlinParser.K_WITHOPTOPTIONS);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public ioOptionsStringConstant(): IoOptionsStringConstantContext {
        let localContext = new IoOptionsStringConstantContext(this.context, this.state);
        this.enterRule(localContext, 530, GremlinParser.RULE_ioOptionsStringConstant);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3884;
            this.match(GremlinParser.K_IOU);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public booleanArgument(): BooleanArgumentContext {
        let localContext = new BooleanArgumentContext(this.context, this.state);
        this.enterRule(localContext, 532, GremlinParser.RULE_booleanArgument);
        try {
            this.state = 3888;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_FALSE:
            case GremlinParser.K_TRUE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3886;
                this.booleanLiteral();
                }
                break;
            case GremlinParser.Identifier:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3887;
                this.variable();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public integerArgument(): IntegerArgumentContext {
        let localContext = new IntegerArgumentContext(this.context, this.state);
        this.enterRule(localContext, 534, GremlinParser.RULE_integerArgument);
        try {
            this.state = 3892;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.IntegerLiteral:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3890;
                this.integerLiteral();
                }
                break;
            case GremlinParser.Identifier:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3891;
                this.variable();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public stringArgument(): StringArgumentContext {
        let localContext = new StringArgumentContext(this.context, this.state);
        this.enterRule(localContext, 536, GremlinParser.RULE_stringArgument);
        try {
            this.state = 3896;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.StringSuffixLiteral:
            case GremlinParser.EmptyStringSuffixLiteral:
            case GremlinParser.NonEmptyStringLiteral:
            case GremlinParser.EmptyStringLiteral:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3894;
                this.stringLiteral();
                }
                break;
            case GremlinParser.Identifier:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3895;
                this.variable();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public stringArgumentVarargs(): StringArgumentVarargsContext {
        let localContext = new StringArgumentVarargsContext(this.context, this.state);
        this.enterRule(localContext, 538, GremlinParser.RULE_stringArgumentVarargs);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3898;
            this.stringArgument();
            this.state = 3903;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 320) {
                {
                {
                this.state = 3899;
                this.match(GremlinParser.COMMA);
                this.state = 3900;
                this.stringArgument();
                }
                }
                this.state = 3905;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public stringNullableArgument(): StringNullableArgumentContext {
        let localContext = new StringNullableArgumentContext(this.context, this.state);
        this.enterRule(localContext, 540, GremlinParser.RULE_stringNullableArgument);
        try {
            this.state = 3908;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_NULL:
            case GremlinParser.StringSuffixLiteral:
            case GremlinParser.EmptyStringSuffixLiteral:
            case GremlinParser.NonEmptyStringLiteral:
            case GremlinParser.EmptyStringLiteral:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3906;
                this.stringNullableLiteral();
                }
                break;
            case GremlinParser.Identifier:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3907;
                this.variable();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public stringNullableArgumentVarargs(): StringNullableArgumentVarargsContext {
        let localContext = new StringNullableArgumentVarargsContext(this.context, this.state);
        this.enterRule(localContext, 542, GremlinParser.RULE_stringNullableArgumentVarargs);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3918;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 186 || ((((_la - 309)) & ~0x1F) === 0 && ((1 << (_la - 309)) & 262159) !== 0)) {
                {
                this.state = 3910;
                this.stringNullableArgument();
                this.state = 3915;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 320) {
                    {
                    {
                    this.state = 3911;
                    this.match(GremlinParser.COMMA);
                    this.state = 3912;
                    this.stringNullableArgument();
                    }
                    }
                    this.state = 3917;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public dateArgument(): DateArgumentContext {
        let localContext = new DateArgumentContext(this.context, this.state);
        this.enterRule(localContext, 544, GremlinParser.RULE_dateArgument);
        try {
            this.state = 3922;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_DATETIME:
            case GremlinParser.K_DATETIMEC:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3920;
                this.dateLiteral();
                }
                break;
            case GremlinParser.Identifier:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3921;
                this.variable();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public genericArgument(): GenericArgumentContext {
        let localContext = new GenericArgumentContext(this.context, this.state);
        this.enterRule(localContext, 546, GremlinParser.RULE_genericArgument);
        try {
            this.state = 3926;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_ADDE:
            case GremlinParser.K_ADDLABEL:
            case GremlinParser.K_ADDV:
            case GremlinParser.K_AGGREGATE:
            case GremlinParser.K_ALL:
            case GremlinParser.K_AND:
            case GremlinParser.K_ANY:
            case GremlinParser.K_AS:
            case GremlinParser.K_ASBOOL:
            case GremlinParser.K_ASDATE:
            case GremlinParser.K_ASNUMBER:
            case GremlinParser.K_ASSTRING:
            case GremlinParser.K_BARRIER:
            case GremlinParser.K_BIGDECIMAL:
            case GremlinParser.K_BIGDECIMALU:
            case GremlinParser.K_BIGINT:
            case GremlinParser.K_BIGINTU:
            case GremlinParser.K_BINARY:
            case GremlinParser.K_BINARYC:
            case GremlinParser.K_BINARYU:
            case GremlinParser.K_BOOLEAN:
            case GremlinParser.K_BOOLEANU:
            case GremlinParser.K_BOTH:
            case GremlinParser.K_BOTHU:
            case GremlinParser.K_BOTHE:
            case GremlinParser.K_BOTHV:
            case GremlinParser.K_BRANCH:
            case GremlinParser.K_BY:
            case GremlinParser.K_BYTE:
            case GremlinParser.K_BYTEU:
            case GremlinParser.K_CALL:
            case GremlinParser.K_CAP:
            case GremlinParser.K_CARDINALITY:
            case GremlinParser.K_CHAR:
            case GremlinParser.K_CHARU:
            case GremlinParser.K_CHOOSE:
            case GremlinParser.K_COALESCE:
            case GremlinParser.K_COIN:
            case GremlinParser.K_COMBINE:
            case GremlinParser.K_CONCAT:
            case GremlinParser.K_CONJOIN:
            case GremlinParser.K_CONNECTEDCOMPONENT:
            case GremlinParser.K_CONSTANT:
            case GremlinParser.K_COUNT:
            case GremlinParser.K_CYCLICPATH:
            case GremlinParser.K_DAY:
            case GremlinParser.K_DATEADD:
            case GremlinParser.K_DATEDIFF:
            case GremlinParser.K_DATETIME:
            case GremlinParser.K_DATETIMEC:
            case GremlinParser.K_DATETIMEU:
            case GremlinParser.K_DEDUP:
            case GremlinParser.K_DIFFERENCE:
            case GremlinParser.K_DISCARD:
            case GremlinParser.K_DIRECTION:
            case GremlinParser.K_DISJUNCT:
            case GremlinParser.K_DOUBLE:
            case GremlinParser.K_DOUBLEU:
            case GremlinParser.K_DROP:
            case GremlinParser.K_DROPLABEL:
            case GremlinParser.K_DROPLABELS:
            case GremlinParser.K_DT:
            case GremlinParser.K_DURATION:
            case GremlinParser.K_DURATIONC:
            case GremlinParser.K_DURATIONU:
            case GremlinParser.K_E:
            case GremlinParser.K_EDGE:
            case GremlinParser.K_EDGEU:
            case GremlinParser.K_ELEMENTMAP:
            case GremlinParser.K_ELEMENT:
            case GremlinParser.K_EMIT:
            case GremlinParser.K_FAIL:
            case GremlinParser.K_FALSE:
            case GremlinParser.K_FILTER:
            case GremlinParser.K_FLATMAP:
            case GremlinParser.K_FLOAT:
            case GremlinParser.K_FLOATU:
            case GremlinParser.K_FOLD:
            case GremlinParser.K_FORMAT:
            case GremlinParser.K_FROM:
            case GremlinParser.K_GTYPE:
            case GremlinParser.K_GROUPCOUNT:
            case GremlinParser.K_GROUP:
            case GremlinParser.K_GRAPH:
            case GremlinParser.K_GRAPHU:
            case GremlinParser.K_HAS:
            case GremlinParser.K_HASID:
            case GremlinParser.K_HASKEY:
            case GremlinParser.K_HASLABEL:
            case GremlinParser.K_HASNOT:
            case GremlinParser.K_HASVALUE:
            case GremlinParser.K_HOUR:
            case GremlinParser.K_ID:
            case GremlinParser.K_IDENTITY:
            case GremlinParser.K_IN:
            case GremlinParser.K_INU:
            case GremlinParser.K_INE:
            case GremlinParser.K_INDEX:
            case GremlinParser.K_INFINITY:
            case GremlinParser.K_INJECT:
            case GremlinParser.K_INT:
            case GremlinParser.K_INTU:
            case GremlinParser.K_INTERSECT:
            case GremlinParser.K_INV:
            case GremlinParser.K_IS:
            case GremlinParser.K_KEY:
            case GremlinParser.K_LABELS:
            case GremlinParser.K_LABEL:
            case GremlinParser.K_LENGTH:
            case GremlinParser.K_LIMIT:
            case GremlinParser.K_LIST:
            case GremlinParser.K_LISTU:
            case GremlinParser.K_LOCAL:
            case GremlinParser.K_LONG:
            case GremlinParser.K_LONGU:
            case GremlinParser.K_LOOPS:
            case GremlinParser.K_LTRIM:
            case GremlinParser.K_MAP:
            case GremlinParser.K_MAPU:
            case GremlinParser.K_MATCH:
            case GremlinParser.K_MATH:
            case GremlinParser.K_MAX:
            case GremlinParser.K_MEAN:
            case GremlinParser.K_MERGEU:
            case GremlinParser.K_MERGE:
            case GremlinParser.K_MERGEE:
            case GremlinParser.K_MERGEV:
            case GremlinParser.K_MIN:
            case GremlinParser.K_MINUTE:
            case GremlinParser.K_NAN:
            case GremlinParser.K_NONE:
            case GremlinParser.K_NOT:
            case GremlinParser.K_NULL:
            case GremlinParser.K_NULLU:
            case GremlinParser.K_NUMBER:
            case GremlinParser.K_NUMBERU:
            case GremlinParser.K_ONCREATE:
            case GremlinParser.K_ONMATCH:
            case GremlinParser.K_OPTION:
            case GremlinParser.K_OPTIONAL:
            case GremlinParser.K_ORDER:
            case GremlinParser.K_OR:
            case GremlinParser.K_OTHERV:
            case GremlinParser.K_OUTU:
            case GremlinParser.K_OUT:
            case GremlinParser.K_OUTE:
            case GremlinParser.K_OUTV:
            case GremlinParser.K_PAGERANK:
            case GremlinParser.K_PATH:
            case GremlinParser.K_PATHU:
            case GremlinParser.K_PDT:
            case GremlinParser.K_PEERPRESSURE:
            case GremlinParser.K_PICK:
            case GremlinParser.K_PROFILE:
            case GremlinParser.K_PROJECT:
            case GremlinParser.K_PROPERTIES:
            case GremlinParser.K_PROPERTYMAP:
            case GremlinParser.K_PROPERTY:
            case GremlinParser.K_PROPERTYU:
            case GremlinParser.K_PRODUCT:
            case GremlinParser.K_RANGE:
            case GremlinParser.K_READ:
            case GremlinParser.K_REPLACE:
            case GremlinParser.K_REPEAT:
            case GremlinParser.K_REVERSE:
            case GremlinParser.K_RTRIM:
            case GremlinParser.K_SACK:
            case GremlinParser.K_SAMPLE:
            case GremlinParser.K_SECOND:
            case GremlinParser.K_SELECT:
            case GremlinParser.K_SET:
            case GremlinParser.K_SETU:
            case GremlinParser.K_SHORTESTPATH:
            case GremlinParser.K_SHORT:
            case GremlinParser.K_SHORTU:
            case GremlinParser.K_SIDEEFFECT:
            case GremlinParser.K_SIMPLEPATH:
            case GremlinParser.K_SINGLE:
            case GremlinParser.K_SKIP:
            case GremlinParser.K_SPLIT:
            case GremlinParser.K_STRING:
            case GremlinParser.K_STRINGU:
            case GremlinParser.K_SUBGRAPH:
            case GremlinParser.K_SUBSTRING:
            case GremlinParser.K_SUM:
            case GremlinParser.K_T:
            case GremlinParser.K_TAIL:
            case GremlinParser.K_TIMELIMIT:
            case GremlinParser.K_TIMES:
            case GremlinParser.K_TO:
            case GremlinParser.K_TOLOWER:
            case GremlinParser.K_TOUPPER:
            case GremlinParser.K_TOE:
            case GremlinParser.K_TOV:
            case GremlinParser.K_TREE:
            case GremlinParser.K_TREEU:
            case GremlinParser.K_TRIM:
            case GremlinParser.K_TRUE:
            case GremlinParser.K_UNFOLD:
            case GremlinParser.K_UNION:
            case GremlinParser.K_UNPRODUCTIVE:
            case GremlinParser.K_UNTIL:
            case GremlinParser.K_UUID:
            case GremlinParser.K_UUIDL:
            case GremlinParser.K_V:
            case GremlinParser.K_VALUEMAP:
            case GremlinParser.K_VALUES:
            case GremlinParser.K_VALUE:
            case GremlinParser.K_VERTEX:
            case GremlinParser.K_VERTEXU:
            case GremlinParser.K_VPROPERTY:
            case GremlinParser.K_VPROPERTYU:
            case GremlinParser.K_WHERE:
            case GremlinParser.K_WITH:
            case GremlinParser.K_WRITE:
            case GremlinParser.IntegerLiteral:
            case GremlinParser.FloatingPointLiteral:
            case GremlinParser.SignedInfLiteral:
            case GremlinParser.CharacterLiteral:
            case GremlinParser.StringSuffixLiteral:
            case GremlinParser.EmptyStringSuffixLiteral:
            case GremlinParser.NonEmptyStringLiteral:
            case GremlinParser.EmptyStringLiteral:
            case GremlinParser.LBRACE:
            case GremlinParser.LBRACK:
            case GremlinParser.TRAVERSAL_ROOT:
            case GremlinParser.ANON_TRAVERSAL_ROOT:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3924;
                this.genericLiteral();
                }
                break;
            case GremlinParser.Identifier:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3925;
                this.variable();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public genericArgumentVarargs(): GenericArgumentVarargsContext {
        let localContext = new GenericArgumentVarargsContext(this.context, this.state);
        this.enterRule(localContext, 548, GremlinParser.RULE_genericArgumentVarargs);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3936;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294014972) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 2142134271) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 3102736189) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 1005574431) !== 0) || ((((_la - 129)) & ~0x1F) === 0 && ((1 << (_la - 129)) & 4194227447) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 2116100605) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 2112742907) !== 0) || ((((_la - 226)) & ~0x1F) === 0 && ((1 << (_la - 226)) & 1874833271) !== 0) || ((((_la - 259)) & ~0x1F) === 0 && ((1 << (_la - 259)) & 4294508103) !== 0) || ((((_la - 291)) & ~0x1F) === 0 && ((1 << (_la - 291)) & 88068103) !== 0) || ((((_la - 323)) & ~0x1F) === 0 && ((1 << (_la - 323)) & 19) !== 0)) {
                {
                this.state = 3928;
                this.genericArgument();
                this.state = 3933;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 320) {
                    {
                    {
                    this.state = 3929;
                    this.match(GremlinParser.COMMA);
                    this.state = 3930;
                    this.genericArgument();
                    }
                    }
                    this.state = 3935;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public genericMapArgument(): GenericMapArgumentContext {
        let localContext = new GenericMapArgumentContext(this.context, this.state);
        this.enterRule(localContext, 550, GremlinParser.RULE_genericMapArgument);
        try {
            this.state = 3940;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.LBRACK:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3938;
                this.genericMapLiteral();
                }
                break;
            case GremlinParser.Identifier:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3939;
                this.variable();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public genericMapNullableArgument(): GenericMapNullableArgumentContext {
        let localContext = new GenericMapNullableArgumentContext(this.context, this.state);
        this.enterRule(localContext, 552, GremlinParser.RULE_genericMapNullableArgument);
        try {
            this.state = 3944;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.K_NULL:
            case GremlinParser.LBRACK:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3942;
                this.genericMapNullableLiteral();
                }
                break;
            case GremlinParser.Identifier:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3943;
                this.variable();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public nullableGenericLiteralMap(): NullableGenericLiteralMapContext {
        let localContext = new NullableGenericLiteralMapContext(this.context, this.state);
        this.enterRule(localContext, 554, GremlinParser.RULE_nullableGenericLiteralMap);
        try {
            this.state = 3948;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.LBRACK:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3946;
                this.genericMapLiteral();
                }
                break;
            case GremlinParser.K_NULL:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3947;
                this.nullLiteral();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalStrategyVarargs(): TraversalStrategyVarargsContext {
        let localContext = new TraversalStrategyVarargsContext(this.context, this.state);
        this.enterRule(localContext, 556, GremlinParser.RULE_traversalStrategyVarargs);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3951;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 184 || _la === 327) {
                {
                this.state = 3950;
                this.traversalStrategyExpr();
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public traversalStrategyExpr(): TraversalStrategyExprContext {
        let localContext = new TraversalStrategyExprContext(this.context, this.state);
        this.enterRule(localContext, 558, GremlinParser.RULE_traversalStrategyExpr);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3953;
            this.traversalStrategy();
            this.state = 3958;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 320) {
                {
                {
                this.state = 3954;
                this.match(GremlinParser.COMMA);
                this.state = 3955;
                this.traversalStrategy();
                }
                }
                this.state = 3960;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public classTypeList(): ClassTypeListContext {
        let localContext = new ClassTypeListContext(this.context, this.state);
        this.enterRule(localContext, 560, GremlinParser.RULE_classTypeList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3962;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 327) {
                {
                this.state = 3961;
                this.classTypeExpr();
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public classTypeExpr(): ClassTypeExprContext {
        let localContext = new ClassTypeExprContext(this.context, this.state);
        this.enterRule(localContext, 562, GremlinParser.RULE_classTypeExpr);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3964;
            this.classType();
            this.state = 3969;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 320) {
                {
                {
                this.state = 3965;
                this.match(GremlinParser.COMMA);
                this.state = 3966;
                this.classType();
                }
                }
                this.state = 3971;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public nestedTraversalList(): NestedTraversalListContext {
        let localContext = new NestedTraversalListContext(this.context, this.state);
        this.enterRule(localContext, 564, GremlinParser.RULE_nestedTraversalList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3973;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 2684450812) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 229530727) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 2833390637) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 2329658887) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & 1984542001) !== 0) || ((((_la - 163)) & ~0x1F) === 0 && ((1 << (_la - 163)) & 3221766205) !== 0) || ((((_la - 196)) & ~0x1F) === 0 && ((1 << (_la - 196)) & 3468463287) !== 0) || ((((_la - 228)) & ~0x1F) === 0 && ((1 << (_la - 228)) & 2475526301) !== 0) || ((((_la - 260)) & ~0x1F) === 0 && ((1 << (_la - 260)) & 254553891) !== 0) || ((((_la - 292)) & ~0x1F) === 0 && ((1 << (_la - 292)) & 2051) !== 0) || _la === 324) {
                {
                this.state = 3972;
                this.nestedTraversalExpr();
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public nestedTraversalExpr(): NestedTraversalExprContext {
        let localContext = new NestedTraversalExprContext(this.context, this.state);
        this.enterRule(localContext, 566, GremlinParser.RULE_nestedTraversalExpr);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3975;
            this.nestedTraversal();
            this.state = 3980;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 320) {
                {
                {
                this.state = 3976;
                this.match(GremlinParser.COMMA);
                this.state = 3977;
                this.nestedTraversal();
                }
                }
                this.state = 3982;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public genericCollectionLiteral(): GenericCollectionLiteralContext {
        let localContext = new GenericCollectionLiteralContext(this.context, this.state);
        this.enterRule(localContext, 568, GremlinParser.RULE_genericCollectionLiteral);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3983;
            this.match(GremlinParser.LBRACK);
            this.state = 3992;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294014972) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 2142134271) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 3102736189) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 1005574431) !== 0) || ((((_la - 129)) & ~0x1F) === 0 && ((1 << (_la - 129)) & 4194227447) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 2116100605) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 2112742907) !== 0) || ((((_la - 226)) & ~0x1F) === 0 && ((1 << (_la - 226)) & 1874833271) !== 0) || ((((_la - 259)) & ~0x1F) === 0 && ((1 << (_la - 259)) & 4294508103) !== 0) || ((((_la - 291)) & ~0x1F) === 0 && ((1 << (_la - 291)) & 88068103) !== 0) || _la === 323 || _la === 324) {
                {
                this.state = 3984;
                this.genericLiteral();
                this.state = 3989;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 320) {
                    {
                    {
                    this.state = 3985;
                    this.match(GremlinParser.COMMA);
                    this.state = 3986;
                    this.genericLiteral();
                    }
                    }
                    this.state = 3991;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            this.state = 3994;
            this.match(GremlinParser.RBRACK);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public genericLiteralVarargs(): GenericLiteralVarargsContext {
        let localContext = new GenericLiteralVarargsContext(this.context, this.state);
        this.enterRule(localContext, 570, GremlinParser.RULE_genericLiteralVarargs);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3997;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294014972) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 2142134271) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 3102736189) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 1005574431) !== 0) || ((((_la - 129)) & ~0x1F) === 0 && ((1 << (_la - 129)) & 4194227447) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 2116100605) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 2112742907) !== 0) || ((((_la - 226)) & ~0x1F) === 0 && ((1 << (_la - 226)) & 1874833271) !== 0) || ((((_la - 259)) & ~0x1F) === 0 && ((1 << (_la - 259)) & 4294508103) !== 0) || ((((_la - 291)) & ~0x1F) === 0 && ((1 << (_la - 291)) & 88068103) !== 0) || _la === 323 || _la === 324) {
                {
                this.state = 3996;
                this.genericLiteralExpr();
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public genericLiteralExpr(): GenericLiteralExprContext {
        let localContext = new GenericLiteralExprContext(this.context, this.state);
        this.enterRule(localContext, 572, GremlinParser.RULE_genericLiteralExpr);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3999;
            this.genericLiteral();
            this.state = 4004;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 320) {
                {
                {
                this.state = 4000;
                this.match(GremlinParser.COMMA);
                this.state = 4001;
                this.genericLiteral();
                }
                }
                this.state = 4006;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public genericMapNullableLiteral(): GenericMapNullableLiteralContext {
        let localContext = new GenericMapNullableLiteralContext(this.context, this.state);
        this.enterRule(localContext, 574, GremlinParser.RULE_genericMapNullableLiteral);
        try {
            this.state = 4009;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.LBRACK:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 4007;
                this.genericMapLiteral();
                }
                break;
            case GremlinParser.K_NULL:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 4008;
                this.nullLiteral();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public genericRangeLiteral(): GenericRangeLiteralContext {
        let localContext = new GenericRangeLiteralContext(this.context, this.state);
        this.enterRule(localContext, 576, GremlinParser.RULE_genericRangeLiteral);
        try {
            this.state = 4021;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.IntegerLiteral:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 4011;
                this.integerLiteral();
                this.state = 4012;
                this.match(GremlinParser.DOT);
                this.state = 4013;
                this.match(GremlinParser.DOT);
                this.state = 4014;
                this.integerLiteral();
                }
                break;
            case GremlinParser.StringSuffixLiteral:
            case GremlinParser.EmptyStringSuffixLiteral:
            case GremlinParser.NonEmptyStringLiteral:
            case GremlinParser.EmptyStringLiteral:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 4016;
                this.stringLiteral();
                this.state = 4017;
                this.match(GremlinParser.DOT);
                this.state = 4018;
                this.match(GremlinParser.DOT);
                this.state = 4019;
                this.stringLiteral();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public genericSetLiteral(): GenericSetLiteralContext {
        let localContext = new GenericSetLiteralContext(this.context, this.state);
        this.enterRule(localContext, 578, GremlinParser.RULE_genericSetLiteral);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4023;
            this.match(GremlinParser.LBRACE);
            this.state = 4032;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294014972) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 2142134271) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 3102736189) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 1005574431) !== 0) || ((((_la - 129)) & ~0x1F) === 0 && ((1 << (_la - 129)) & 4194227447) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 2116100605) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 2112742907) !== 0) || ((((_la - 226)) & ~0x1F) === 0 && ((1 << (_la - 226)) & 1874833271) !== 0) || ((((_la - 259)) & ~0x1F) === 0 && ((1 << (_la - 259)) & 4294508103) !== 0) || ((((_la - 291)) & ~0x1F) === 0 && ((1 << (_la - 291)) & 88068103) !== 0) || _la === 323 || _la === 324) {
                {
                this.state = 4024;
                this.genericLiteral();
                this.state = 4029;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 320) {
                    {
                    {
                    this.state = 4025;
                    this.match(GremlinParser.COMMA);
                    this.state = 4026;
                    this.genericLiteral();
                    }
                    }
                    this.state = 4031;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            this.state = 4034;
            this.match(GremlinParser.RBRACE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext {
        let localContext = new StringNullableLiteralVarargsContext(this.context, this.state);
        this.enterRule(localContext, 580, GremlinParser.RULE_stringNullableLiteralVarargs);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4044;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 186 || ((((_la - 309)) & ~0x1F) === 0 && ((1 << (_la - 309)) & 15) !== 0)) {
                {
                this.state = 4036;
                this.stringNullableLiteral();
                this.state = 4041;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 320) {
                    {
                    {
                    this.state = 4037;
                    this.match(GremlinParser.COMMA);
                    this.state = 4038;
                    this.stringNullableLiteral();
                    }
                    }
                    this.state = 4043;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public stringLiteralVarargs(): StringLiteralVarargsContext {
        let localContext = new StringLiteralVarargsContext(this.context, this.state);
        this.enterRule(localContext, 582, GremlinParser.RULE_stringLiteralVarargs);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4046;
            this.stringLiteral();
            this.state = 4051;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 320) {
                {
                {
                this.state = 4047;
                this.match(GremlinParser.COMMA);
                this.state = 4048;
                this.stringLiteral();
                }
                }
                this.state = 4053;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public genericLiteral(): GenericLiteralContext {
        let localContext = new GenericLiteralContext(this.context, this.state);
        this.enterRule(localContext, 584, GremlinParser.RULE_genericLiteral);
        try {
            this.state = 4077;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 242, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 4054;
                this.numericLiteral();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 4055;
                this.booleanLiteral();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 4056;
                this.stringLiteral();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 4057;
                this.dateLiteral();
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 4058;
                this.nullLiteral();
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 4059;
                this.traversalT();
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 4060;
                this.traversalCardinality();
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 4061;
                this.traversalDirection();
                }
                break;
            case 9:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 4062;
                this.traversalMerge();
                }
                break;
            case 10:
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 4063;
                this.traversalPick();
                }
                break;
            case 11:
                this.enterOuterAlt(localContext, 11);
                {
                this.state = 4064;
                this.traversalDT();
                }
                break;
            case 12:
                this.enterOuterAlt(localContext, 12);
                {
                this.state = 4065;
                this.traversalGType();
                }
                break;
            case 13:
                this.enterOuterAlt(localContext, 13);
                {
                this.state = 4066;
                this.genericSetLiteral();
                }
                break;
            case 14:
                this.enterOuterAlt(localContext, 14);
                {
                this.state = 4067;
                this.genericCollectionLiteral();
                }
                break;
            case 15:
                this.enterOuterAlt(localContext, 15);
                {
                this.state = 4068;
                this.genericRangeLiteral();
                }
                break;
            case 16:
                this.enterOuterAlt(localContext, 16);
                {
                this.state = 4069;
                this.nestedTraversal();
                }
                break;
            case 17:
                this.enterOuterAlt(localContext, 17);
                {
                this.state = 4070;
                this.terminatedTraversal();
                }
                break;
            case 18:
                this.enterOuterAlt(localContext, 18);
                {
                this.state = 4071;
                this.uuidLiteral();
                }
                break;
            case 19:
                this.enterOuterAlt(localContext, 19);
                {
                this.state = 4072;
                this.characterLiteral();
                }
                break;
            case 20:
                this.enterOuterAlt(localContext, 20);
                {
                this.state = 4073;
                this.durationLiteral();
                }
                break;
            case 21:
                this.enterOuterAlt(localContext, 21);
                {
                this.state = 4074;
                this.binaryLiteral();
                }
                break;
            case 22:
                this.enterOuterAlt(localContext, 22);
                {
                this.state = 4075;
                this.pdtLiteral();
                }
                break;
            case 23:
                this.enterOuterAlt(localContext, 23);
                {
                this.state = 4076;
                this.genericMapLiteral();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public genericMapLiteral(): GenericMapLiteralContext {
        let localContext = new GenericMapLiteralContext(this.context, this.state);
        this.enterRule(localContext, 586, GremlinParser.RULE_genericMapLiteral);
        let _la: number;
        try {
            this.state = 4093;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 244, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 4079;
                this.match(GremlinParser.LBRACK);
                this.state = 4080;
                this.match(GremlinParser.COLON);
                this.state = 4081;
                this.match(GremlinParser.RBRACK);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 4082;
                this.match(GremlinParser.LBRACK);
                this.state = 4083;
                this.mapEntry();
                this.state = 4088;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 320) {
                    {
                    {
                    this.state = 4084;
                    this.match(GremlinParser.COMMA);
                    this.state = 4085;
                    this.mapEntry();
                    }
                    }
                    this.state = 4090;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 4091;
                this.match(GremlinParser.RBRACK);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public mapKey(): MapKeyContext {
        let localContext = new MapKeyContext(this.context, this.state);
        this.enterRule(localContext, 588, GremlinParser.RULE_mapKey);
        try {
            this.state = 4148;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 253, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 4100;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.LPAREN:
                    {
                    this.state = 4095;
                    this.match(GremlinParser.LPAREN);
                    this.state = 4096;
                    this.traversalT();
                    this.state = 4097;
                    this.match(GremlinParser.RPAREN);
                    }
                    break;
                case GremlinParser.K_T:
                    {
                    this.state = 4099;
                    this.traversalTLong();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 4107;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.LPAREN:
                    {
                    this.state = 4102;
                    this.match(GremlinParser.LPAREN);
                    this.state = 4103;
                    this.traversalDirection();
                    this.state = 4104;
                    this.match(GremlinParser.RPAREN);
                    }
                    break;
                case GremlinParser.K_DIRECTION:
                    {
                    this.state = 4106;
                    this.traversalDirectionLong();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 4114;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.LPAREN:
                    {
                    this.state = 4109;
                    this.match(GremlinParser.LPAREN);
                    this.state = 4110;
                    this.genericSetLiteral();
                    this.state = 4111;
                    this.match(GremlinParser.RPAREN);
                    }
                    break;
                case GremlinParser.LBRACE:
                    {
                    this.state = 4113;
                    this.genericSetLiteral();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 4121;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.LPAREN:
                    {
                    this.state = 4116;
                    this.match(GremlinParser.LPAREN);
                    this.state = 4117;
                    this.genericCollectionLiteral();
                    this.state = 4118;
                    this.match(GremlinParser.RPAREN);
                    }
                    break;
                case GremlinParser.LBRACK:
                    {
                    this.state = 4120;
                    this.genericCollectionLiteral();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 4128;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.LPAREN:
                    {
                    this.state = 4123;
                    this.match(GremlinParser.LPAREN);
                    this.state = 4124;
                    this.genericMapLiteral();
                    this.state = 4125;
                    this.match(GremlinParser.RPAREN);
                    }
                    break;
                case GremlinParser.LBRACK:
                    {
                    this.state = 4127;
                    this.genericMapLiteral();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 4135;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.LPAREN:
                    {
                    this.state = 4130;
                    this.match(GremlinParser.LPAREN);
                    this.state = 4131;
                    this.stringLiteral();
                    this.state = 4132;
                    this.match(GremlinParser.RPAREN);
                    }
                    break;
                case GremlinParser.StringSuffixLiteral:
                case GremlinParser.EmptyStringSuffixLiteral:
                case GremlinParser.NonEmptyStringLiteral:
                case GremlinParser.EmptyStringLiteral:
                    {
                    this.state = 4134;
                    this.stringLiteral();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 4142;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.LPAREN:
                    {
                    this.state = 4137;
                    this.match(GremlinParser.LPAREN);
                    this.state = 4138;
                    this.numericLiteral();
                    this.state = 4139;
                    this.match(GremlinParser.RPAREN);
                    }
                    break;
                case GremlinParser.K_INFINITY:
                case GremlinParser.K_NAN:
                case GremlinParser.IntegerLiteral:
                case GremlinParser.FloatingPointLiteral:
                case GremlinParser.SignedInfLiteral:
                    {
                    this.state = 4141;
                    this.numericLiteral();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 4146;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case GremlinParser.K_ADDALL:
                case GremlinParser.K_ADDE:
                case GremlinParser.K_ADDLABEL:
                case GremlinParser.K_ADDV:
                case GremlinParser.K_AGGREGATE:
                case GremlinParser.K_ALL:
                case GremlinParser.K_AND:
                case GremlinParser.K_ANY:
                case GremlinParser.K_AS:
                case GremlinParser.K_ASBOOL:
                case GremlinParser.K_ASC:
                case GremlinParser.K_ASDATE:
                case GremlinParser.K_ASNUMBER:
                case GremlinParser.K_ASSTRING:
                case GremlinParser.K_ASSIGN:
                case GremlinParser.K_BARRIER:
                case GremlinParser.K_BARRIERU:
                case GremlinParser.K_BEGIN:
                case GremlinParser.K_BETWEEN:
                case GremlinParser.K_BIGDECIMAL:
                case GremlinParser.K_BIGDECIMALU:
                case GremlinParser.K_BIGINT:
                case GremlinParser.K_BIGINTU:
                case GremlinParser.K_BINARY:
                case GremlinParser.K_BINARYC:
                case GremlinParser.K_BINARYU:
                case GremlinParser.K_BOOLEAN:
                case GremlinParser.K_BOOLEANU:
                case GremlinParser.K_BOTH:
                case GremlinParser.K_BOTHU:
                case GremlinParser.K_BOTHE:
                case GremlinParser.K_BOTHV:
                case GremlinParser.K_BRANCH:
                case GremlinParser.K_BY:
                case GremlinParser.K_BYTE:
                case GremlinParser.K_BYTEU:
                case GremlinParser.K_CALL:
                case GremlinParser.K_CAP:
                case GremlinParser.K_CARDINALITY:
                case GremlinParser.K_CHAR:
                case GremlinParser.K_CHARU:
                case GremlinParser.K_CHOOSE:
                case GremlinParser.K_COALESCE:
                case GremlinParser.K_COIN:
                case GremlinParser.K_COLUMN:
                case GremlinParser.K_COMBINE:
                case GremlinParser.K_COMMIT:
                case GremlinParser.K_COMPONENT:
                case GremlinParser.K_CONCAT:
                case GremlinParser.K_CONJOIN:
                case GremlinParser.K_CONNECTEDCOMPONENT:
                case GremlinParser.K_CONNECTEDCOMPONENTU:
                case GremlinParser.K_CONSTANT:
                case GremlinParser.K_CONTAINING:
                case GremlinParser.K_COUNT:
                case GremlinParser.K_CYCLICPATH:
                case GremlinParser.K_DAY:
                case GremlinParser.K_DATEADD:
                case GremlinParser.K_DATEDIFF:
                case GremlinParser.K_DATETIME:
                case GremlinParser.K_DATETIMEC:
                case GremlinParser.K_DATETIMEU:
                case GremlinParser.K_DECR:
                case GremlinParser.K_DEDUP:
                case GremlinParser.K_DESC:
                case GremlinParser.K_DIFFERENCE:
                case GremlinParser.K_DISCARD:
                case GremlinParser.K_DIRECTION:
                case GremlinParser.K_DISJUNCT:
                case GremlinParser.K_DISTANCE:
                case GremlinParser.K_DIV:
                case GremlinParser.K_DOUBLE:
                case GremlinParser.K_DOUBLEU:
                case GremlinParser.K_DROP:
                case GremlinParser.K_DROPLABEL:
                case GremlinParser.K_DROPLABELS:
                case GremlinParser.K_DT:
                case GremlinParser.K_DURATION:
                case GremlinParser.K_DURATIONC:
                case GremlinParser.K_DURATIONU:
                case GremlinParser.K_E:
                case GremlinParser.K_EDGE:
                case GremlinParser.K_EDGEU:
                case GremlinParser.K_EDGES:
                case GremlinParser.K_ELEMENTMAP:
                case GremlinParser.K_ELEMENT:
                case GremlinParser.K_EMIT:
                case GremlinParser.K_ENDINGWITH:
                case GremlinParser.K_EQ:
                case GremlinParser.K_EXPLAIN:
                case GremlinParser.K_FAIL:
                case GremlinParser.K_FALSE:
                case GremlinParser.K_FILTER:
                case GremlinParser.K_FIRST:
                case GremlinParser.K_FLATMAP:
                case GremlinParser.K_FLOAT:
                case GremlinParser.K_FLOATU:
                case GremlinParser.K_FOLD:
                case GremlinParser.K_FORMAT:
                case GremlinParser.K_FROM:
                case GremlinParser.K_GLOBAL:
                case GremlinParser.K_GT:
                case GremlinParser.K_GTE:
                case GremlinParser.K_GTYPE:
                case GremlinParser.K_GRAPHML:
                case GremlinParser.K_GRAPHSON:
                case GremlinParser.K_GROUPCOUNT:
                case GremlinParser.K_GROUP:
                case GremlinParser.K_GRYO:
                case GremlinParser.K_GRAPH:
                case GremlinParser.K_GRAPHU:
                case GremlinParser.K_HAS:
                case GremlinParser.K_HASID:
                case GremlinParser.K_HASKEY:
                case GremlinParser.K_HASLABEL:
                case GremlinParser.K_HASNEXT:
                case GremlinParser.K_HASNOT:
                case GremlinParser.K_HASVALUE:
                case GremlinParser.K_HOUR:
                case GremlinParser.K_ID:
                case GremlinParser.K_IDENTITY:
                case GremlinParser.K_IDS:
                case GremlinParser.K_IN:
                case GremlinParser.K_INU:
                case GremlinParser.K_INE:
                case GremlinParser.K_INCLUDEEDGES:
                case GremlinParser.K_INCR:
                case GremlinParser.K_INDEXER:
                case GremlinParser.K_INDEX:
                case GremlinParser.K_INFINITY:
                case GremlinParser.K_INJECT:
                case GremlinParser.K_INSIDE:
                case GremlinParser.K_INT:
                case GremlinParser.K_INTU:
                case GremlinParser.K_INTERSECT:
                case GremlinParser.K_INV:
                case GremlinParser.K_IOU:
                case GremlinParser.K_IO:
                case GremlinParser.K_IS:
                case GremlinParser.K_ITERATE:
                case GremlinParser.K_KEY:
                case GremlinParser.K_KEYS:
                case GremlinParser.K_LABELS:
                case GremlinParser.K_LABEL:
                case GremlinParser.K_LAST:
                case GremlinParser.K_LENGTH:
                case GremlinParser.K_LIMIT:
                case GremlinParser.K_LIST:
                case GremlinParser.K_LISTU:
                case GremlinParser.K_LOCAL:
                case GremlinParser.K_LONG:
                case GremlinParser.K_LONGU:
                case GremlinParser.K_LOOPS:
                case GremlinParser.K_LT:
                case GremlinParser.K_LTE:
                case GremlinParser.K_LTRIM:
                case GremlinParser.K_MAP:
                case GremlinParser.K_MAPU:
                case GremlinParser.K_MATCH:
                case GremlinParser.K_MATH:
                case GremlinParser.K_MAX:
                case GremlinParser.K_MAXDISTANCE:
                case GremlinParser.K_MEAN:
                case GremlinParser.K_MERGEU:
                case GremlinParser.K_MERGE:
                case GremlinParser.K_MERGEE:
                case GremlinParser.K_MERGEV:
                case GremlinParser.K_MIN:
                case GremlinParser.K_MINUTE:
                case GremlinParser.K_MINUS:
                case GremlinParser.K_MIXED:
                case GremlinParser.K_MULT:
                case GremlinParser.K_N:
                case GremlinParser.K_NAN:
                case GremlinParser.K_NEGATE:
                case GremlinParser.K_NEXT:
                case GremlinParser.K_NONE:
                case GremlinParser.K_NOTREGEX:
                case GremlinParser.K_NOTCONTAINING:
                case GremlinParser.K_NOTENDINGWITH:
                case GremlinParser.K_NOTSTARTINGWITH:
                case GremlinParser.K_NOT:
                case GremlinParser.K_NEQ:
                case GremlinParser.K_NEW:
                case GremlinParser.K_NORMSACK:
                case GremlinParser.K_NULL:
                case GremlinParser.K_NULLU:
                case GremlinParser.K_NUMBER:
                case GremlinParser.K_NUMBERU:
                case GremlinParser.K_ONCREATE:
                case GremlinParser.K_ONMATCH:
                case GremlinParser.K_OPERATOR:
                case GremlinParser.K_OPTION:
                case GremlinParser.K_OPTIONAL:
                case GremlinParser.K_ORDERU:
                case GremlinParser.K_ORDER:
                case GremlinParser.K_OR:
                case GremlinParser.K_OTHERV:
                case GremlinParser.K_OUTU:
                case GremlinParser.K_OUT:
                case GremlinParser.K_OUTE:
                case GremlinParser.K_OUTSIDE:
                case GremlinParser.K_OUTV:
                case GremlinParser.K_P:
                case GremlinParser.K_PAGERANKU:
                case GremlinParser.K_PAGERANK:
                case GremlinParser.K_PATH:
                case GremlinParser.K_PATHU:
                case GremlinParser.K_PDT:
                case GremlinParser.K_PEERPRESSUREU:
                case GremlinParser.K_PEERPRESSURE:
                case GremlinParser.K_PICK:
                case GremlinParser.K_POP:
                case GremlinParser.K_PROFILE:
                case GremlinParser.K_PROJECT:
                case GremlinParser.K_PROPERTIES:
                case GremlinParser.K_PROPERTYMAP:
                case GremlinParser.K_PROPERTYNAME:
                case GremlinParser.K_PROPERTY:
                case GremlinParser.K_PROPERTYU:
                case GremlinParser.K_PRODUCT:
                case GremlinParser.K_RANGE:
                case GremlinParser.K_READ:
                case GremlinParser.K_READER:
                case GremlinParser.K_REGEX:
                case GremlinParser.K_REPLACE:
                case GremlinParser.K_REPEAT:
                case GremlinParser.K_REVERSE:
                case GremlinParser.K_ROLLBACK:
                case GremlinParser.K_RTRIM:
                case GremlinParser.K_SACK:
                case GremlinParser.K_SAMPLE:
                case GremlinParser.K_SCOPE:
                case GremlinParser.K_SECOND:
                case GremlinParser.K_SELECT:
                case GremlinParser.K_SET:
                case GremlinParser.K_SETU:
                case GremlinParser.K_SHORTESTPATHU:
                case GremlinParser.K_SHORTESTPATH:
                case GremlinParser.K_SHUFFLE:
                case GremlinParser.K_SHORT:
                case GremlinParser.K_SHORTU:
                case GremlinParser.K_SIDEEFFECT:
                case GremlinParser.K_SIMPLEPATH:
                case GremlinParser.K_SINGLE:
                case GremlinParser.K_SKIP:
                case GremlinParser.K_SPLIT:
                case GremlinParser.K_STARTINGWITH:
                case GremlinParser.K_STRING:
                case GremlinParser.K_STRINGU:
                case GremlinParser.K_SUBGRAPH:
                case GremlinParser.K_SUBSTRING:
                case GremlinParser.K_SUM:
                case GremlinParser.K_SUMLONG:
                case GremlinParser.K_T:
                case GremlinParser.K_TAIL:
                case GremlinParser.K_TARGET:
                case GremlinParser.K_TEXTP:
                case GremlinParser.K_TIMELIMIT:
                case GremlinParser.K_TIMES:
                case GremlinParser.K_TO:
                case GremlinParser.K_TOBULKSET:
                case GremlinParser.K_TOKENS:
                case GremlinParser.K_TOLIST:
                case GremlinParser.K_TOLOWER:
                case GremlinParser.K_TOSET:
                case GremlinParser.K_TOSTRING:
                case GremlinParser.K_TOUPPER:
                case GremlinParser.K_TOE:
                case GremlinParser.K_TOV:
                case GremlinParser.K_TREE:
                case GremlinParser.K_TREEU:
                case GremlinParser.K_TRIM:
                case GremlinParser.K_TRUE:
                case GremlinParser.K_TRYNEXT:
                case GremlinParser.K_TYPEOF:
                case GremlinParser.K_TX:
                case GremlinParser.K_UNFOLD:
                case GremlinParser.K_UNION:
                case GremlinParser.K_UNPRODUCTIVE:
                case GremlinParser.K_UNTIL:
                case GremlinParser.K_UUID:
                case GremlinParser.K_UUIDL:
                case GremlinParser.K_V:
                case GremlinParser.K_VALUEMAP:
                case GremlinParser.K_VALUES:
                case GremlinParser.K_VALUE:
                case GremlinParser.K_VERTEX:
                case GremlinParser.K_VERTEXU:
                case GremlinParser.K_VPROPERTY:
                case GremlinParser.K_VPROPERTYU:
                case GremlinParser.K_WHERE:
                case GremlinParser.K_WITH:
                case GremlinParser.K_WITHBULK:
                case GremlinParser.K_WITHIN:
                case GremlinParser.K_WITHOPTOPTIONS:
                case GremlinParser.K_WITHOUT:
                case GremlinParser.K_WITHOUTSTRATEGIES:
                case GremlinParser.K_WITHPATH:
                case GremlinParser.K_WITHSACK:
                case GremlinParser.K_WITHSIDEEFFECT:
                case GremlinParser.K_WITHSTRATEGIES:
                case GremlinParser.K_WRITE:
                case GremlinParser.K_WRITER:
                case GremlinParser.TRAVERSAL_ROOT:
                    {
                    this.state = 4144;
                    this.keyword();
                    }
                    break;
                case GremlinParser.Identifier:
                    {
                    this.state = 4145;
                    this.nakedKey();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public mapEntry(): MapEntryContext {
        let localContext = new MapEntryContext(this.context, this.state);
        this.enterRule(localContext, 590, GremlinParser.RULE_mapEntry);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4150;
            this.mapKey();
            this.state = 4151;
            this.match(GremlinParser.COLON);
            this.state = 4152;
            this.genericLiteral();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public stringLiteral(): StringLiteralContext {
        let localContext = new StringLiteralContext(this.context, this.state);
        this.enterRule(localContext, 592, GremlinParser.RULE_stringLiteral);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4154;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 309)) & ~0x1F) === 0 && ((1 << (_la - 309)) & 15) !== 0))) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public stringNullableLiteral(): StringNullableLiteralContext {
        let localContext = new StringNullableLiteralContext(this.context, this.state);
        this.enterRule(localContext, 594, GremlinParser.RULE_stringNullableLiteral);
        try {
            this.state = 4158;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.StringSuffixLiteral:
            case GremlinParser.EmptyStringSuffixLiteral:
            case GremlinParser.NonEmptyStringLiteral:
            case GremlinParser.EmptyStringLiteral:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 4156;
                this.stringLiteral();
                }
                break;
            case GremlinParser.K_NULL:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 4157;
                this.match(GremlinParser.K_NULL);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public integerLiteral(): IntegerLiteralContext {
        let localContext = new IntegerLiteralContext(this.context, this.state);
        this.enterRule(localContext, 596, GremlinParser.RULE_integerLiteral);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4160;
            this.match(GremlinParser.IntegerLiteral);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public floatLiteral(): FloatLiteralContext {
        let localContext = new FloatLiteralContext(this.context, this.state);
        this.enterRule(localContext, 598, GremlinParser.RULE_floatLiteral);
        try {
            this.state = 4165;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.FloatingPointLiteral:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 4162;
                this.match(GremlinParser.FloatingPointLiteral);
                }
                break;
            case GremlinParser.K_INFINITY:
            case GremlinParser.SignedInfLiteral:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 4163;
                this.infLiteral();
                }
                break;
            case GremlinParser.K_NAN:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 4164;
                this.nanLiteral();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public numericLiteral(): NumericLiteralContext {
        let localContext = new NumericLiteralContext(this.context, this.state);
        this.enterRule(localContext, 600, GremlinParser.RULE_numericLiteral);
        try {
            this.state = 4169;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case GremlinParser.IntegerLiteral:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 4167;
                this.integerLiteral();
                }
                break;
            case GremlinParser.K_INFINITY:
            case GremlinParser.K_NAN:
            case GremlinParser.FloatingPointLiteral:
            case GremlinParser.SignedInfLiteral:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 4168;
                this.floatLiteral();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public booleanLiteral(): BooleanLiteralContext {
        let localContext = new BooleanLiteralContext(this.context, this.state);
        this.enterRule(localContext, 602, GremlinParser.RULE_booleanLiteral);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4171;
            _la = this.tokenStream.LA(1);
            if(!(_la === 92 || _la === 274)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public dateLiteral(): DateLiteralContext {
        let localContext = new DateLiteralContext(this.context, this.state);
        this.enterRule(localContext, 604, GremlinParser.RULE_dateLiteral);
        try {
            this.state = 4189;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 257, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 4173;
                this.match(GremlinParser.K_DATETIME);
                this.state = 4174;
                this.match(GremlinParser.LPAREN);
                this.state = 4175;
                this.stringLiteral();
                this.state = 4176;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 4178;
                this.match(GremlinParser.K_DATETIME);
                this.state = 4179;
                this.match(GremlinParser.LPAREN);
                this.state = 4180;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 4181;
                this.match(GremlinParser.K_DATETIMEC);
                this.state = 4182;
                this.match(GremlinParser.LPAREN);
                this.state = 4183;
                this.stringLiteral();
                this.state = 4184;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 4186;
                this.match(GremlinParser.K_DATETIMEC);
                this.state = 4187;
                this.match(GremlinParser.LPAREN);
                this.state = 4188;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public nullLiteral(): NullLiteralContext {
        let localContext = new NullLiteralContext(this.context, this.state);
        this.enterRule(localContext, 606, GremlinParser.RULE_nullLiteral);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4191;
            this.match(GremlinParser.K_NULL);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public nanLiteral(): NanLiteralContext {
        let localContext = new NanLiteralContext(this.context, this.state);
        this.enterRule(localContext, 608, GremlinParser.RULE_nanLiteral);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4193;
            this.match(GremlinParser.K_NAN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public infLiteral(): InfLiteralContext {
        let localContext = new InfLiteralContext(this.context, this.state);
        this.enterRule(localContext, 610, GremlinParser.RULE_infLiteral);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4195;
            _la = this.tokenStream.LA(1);
            if(!(_la === 130 || _la === 307)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public uuidLiteral(): UuidLiteralContext {
        let localContext = new UuidLiteralContext(this.context, this.state);
        this.enterRule(localContext, 612, GremlinParser.RULE_uuidLiteral);
        try {
            this.state = 4205;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 258, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 4197;
                this.match(GremlinParser.K_UUID);
                this.state = 4198;
                this.match(GremlinParser.LPAREN);
                this.state = 4199;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 4200;
                this.match(GremlinParser.K_UUID);
                this.state = 4201;
                this.match(GremlinParser.LPAREN);
                this.state = 4202;
                this.stringLiteral();
                this.state = 4203;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public characterLiteral(): CharacterLiteralContext {
        let localContext = new CharacterLiteralContext(this.context, this.state);
        this.enterRule(localContext, 614, GremlinParser.RULE_characterLiteral);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4207;
            this.match(GremlinParser.CharacterLiteral);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public durationLiteral(): DurationLiteralContext {
        let localContext = new DurationLiteralContext(this.context, this.state);
        this.enterRule(localContext, 616, GremlinParser.RULE_durationLiteral);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4209;
            this.match(GremlinParser.K_DURATIONC);
            this.state = 4210;
            this.match(GremlinParser.LPAREN);
            this.state = 4211;
            this.integerLiteral();
            this.state = 4212;
            this.match(GremlinParser.COMMA);
            this.state = 4213;
            this.integerLiteral();
            this.state = 4216;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 320) {
                {
                this.state = 4214;
                this.match(GremlinParser.COMMA);
                this.state = 4215;
                this.booleanLiteral();
                }
            }

            this.state = 4218;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public binaryLiteral(): BinaryLiteralContext {
        let localContext = new BinaryLiteralContext(this.context, this.state);
        this.enterRule(localContext, 618, GremlinParser.RULE_binaryLiteral);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4220;
            this.match(GremlinParser.K_BINARYC);
            this.state = 4221;
            this.match(GremlinParser.LPAREN);
            this.state = 4222;
            this.stringLiteral();
            this.state = 4223;
            this.match(GremlinParser.RPAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public pdtLiteral(): PdtLiteralContext {
        let localContext = new PdtLiteralContext(this.context, this.state);
        this.enterRule(localContext, 620, GremlinParser.RULE_pdtLiteral);
        try {
            this.state = 4239;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 260, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 4225;
                this.match(GremlinParser.K_PDT);
                this.state = 4226;
                this.match(GremlinParser.LPAREN);
                this.state = 4227;
                this.stringLiteral();
                this.state = 4228;
                this.match(GremlinParser.COMMA);
                this.state = 4229;
                this.genericMapLiteral();
                this.state = 4230;
                this.match(GremlinParser.RPAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 4232;
                this.match(GremlinParser.K_PDT);
                this.state = 4233;
                this.match(GremlinParser.LPAREN);
                this.state = 4234;
                this.stringLiteral();
                this.state = 4235;
                this.match(GremlinParser.COMMA);
                this.state = 4236;
                this.stringLiteral();
                this.state = 4237;
                this.match(GremlinParser.RPAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public nakedKey(): NakedKeyContext {
        let localContext = new NakedKeyContext(this.context, this.state);
        this.enterRule(localContext, 622, GremlinParser.RULE_nakedKey);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4241;
            this.match(GremlinParser.Identifier);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public classType(): ClassTypeContext {
        let localContext = new ClassTypeContext(this.context, this.state);
        this.enterRule(localContext, 624, GremlinParser.RULE_classType);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4243;
            this.match(GremlinParser.Identifier);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public variable(): VariableContext {
        let localContext = new VariableContext(this.context, this.state);
        this.enterRule(localContext, 626, GremlinParser.RULE_variable);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4245;
            this.match(GremlinParser.Identifier);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public keyword(): KeywordContext {
        let localContext = new KeywordContext(this.context, this.state);
        this.enterRule(localContext, 628, GremlinParser.RULE_keyword);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 4247;
            _la = this.tokenStream.LA(1);
            if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4294967295) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967295) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967295) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 131071) !== 0) || _la === 323)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }

    public override sempred(localContext: antlr.ParserRuleContext | null, ruleIndex: number, predIndex: number): boolean {
        switch (ruleIndex) {
        case 1:
            return this.query_sempred(localContext as QueryContext, predIndex);
        case 3:
            return this.traversalSource_sempred(localContext as TraversalSourceContext, predIndex);
        case 26:
            return this.chainedTraversal_sempred(localContext as ChainedTraversalContext, predIndex);
        case 188:
            return this.traversalPredicate_sempred(localContext as TraversalPredicateContext, predIndex);
        }
        return true;
    }
    private query_sempred(localContext: QueryContext | null, predIndex: number): boolean {
        switch (predIndex) {
        case 0:
            return this.precpred(this.context, 2);
        }
        return true;
    }
    private traversalSource_sempred(localContext: TraversalSourceContext | null, predIndex: number): boolean {
        switch (predIndex) {
        case 1:
            return this.precpred(this.context, 1);
        }
        return true;
    }
    private chainedTraversal_sempred(localContext: ChainedTraversalContext | null, predIndex: number): boolean {
        switch (predIndex) {
        case 2:
            return this.precpred(this.context, 1);
        }
        return true;
    }
    private traversalPredicate_sempred(localContext: TraversalPredicateContext | null, predIndex: number): boolean {
        switch (predIndex) {
        case 3:
            return this.precpred(this.context, 3);
        case 4:
            return this.precpred(this.context, 2);
        case 5:
            return this.precpred(this.context, 1);
        }
        return true;
    }

    public static readonly _serializedATN: number[] = [
        4,1,327,4250,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
        7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
        13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
        20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
        26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
        33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
        39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
        46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
        52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
        59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
        65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
        72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,
        78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2,
        85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7,
        91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,
        98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,
        2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,
        7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,
        2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,
        7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125,7,125,
        2,126,7,126,2,127,7,127,2,128,7,128,2,129,7,129,2,130,7,130,2,131,
        7,131,2,132,7,132,2,133,7,133,2,134,7,134,2,135,7,135,2,136,7,136,
        2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,2,141,7,141,2,142,
        7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,7,146,2,147,7,147,
        2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,7,152,2,153,
        7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,7,158,
        2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164,
        7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,
        2,170,7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175,
        7,175,2,176,7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180,
        2,181,7,181,2,182,7,182,2,183,7,183,2,184,7,184,2,185,7,185,2,186,
        7,186,2,187,7,187,2,188,7,188,2,189,7,189,2,190,7,190,2,191,7,191,
        2,192,7,192,2,193,7,193,2,194,7,194,2,195,7,195,2,196,7,196,2,197,
        7,197,2,198,7,198,2,199,7,199,2,200,7,200,2,201,7,201,2,202,7,202,
        2,203,7,203,2,204,7,204,2,205,7,205,2,206,7,206,2,207,7,207,2,208,
        7,208,2,209,7,209,2,210,7,210,2,211,7,211,2,212,7,212,2,213,7,213,
        2,214,7,214,2,215,7,215,2,216,7,216,2,217,7,217,2,218,7,218,2,219,
        7,219,2,220,7,220,2,221,7,221,2,222,7,222,2,223,7,223,2,224,7,224,
        2,225,7,225,2,226,7,226,2,227,7,227,2,228,7,228,2,229,7,229,2,230,
        7,230,2,231,7,231,2,232,7,232,2,233,7,233,2,234,7,234,2,235,7,235,
        2,236,7,236,2,237,7,237,2,238,7,238,2,239,7,239,2,240,7,240,2,241,
        7,241,2,242,7,242,2,243,7,243,2,244,7,244,2,245,7,245,2,246,7,246,
        2,247,7,247,2,248,7,248,2,249,7,249,2,250,7,250,2,251,7,251,2,252,
        7,252,2,253,7,253,2,254,7,254,2,255,7,255,2,256,7,256,2,257,7,257,
        2,258,7,258,2,259,7,259,2,260,7,260,2,261,7,261,2,262,7,262,2,263,
        7,263,2,264,7,264,2,265,7,265,2,266,7,266,2,267,7,267,2,268,7,268,
        2,269,7,269,2,270,7,270,2,271,7,271,2,272,7,272,2,273,7,273,2,274,
        7,274,2,275,7,275,2,276,7,276,2,277,7,277,2,278,7,278,2,279,7,279,
        2,280,7,280,2,281,7,281,2,282,7,282,2,283,7,283,2,284,7,284,2,285,
        7,285,2,286,7,286,2,287,7,287,2,288,7,288,2,289,7,289,2,290,7,290,
        2,291,7,291,2,292,7,292,2,293,7,293,2,294,7,294,2,295,7,295,2,296,
        7,296,2,297,7,297,2,298,7,298,2,299,7,299,2,300,7,300,2,301,7,301,
        2,302,7,302,2,303,7,303,2,304,7,304,2,305,7,305,2,306,7,306,2,307,
        7,307,2,308,7,308,2,309,7,309,2,310,7,310,2,311,7,311,2,312,7,312,
        2,313,7,313,2,314,7,314,1,0,1,0,3,0,633,8,0,1,0,5,0,636,8,0,10,0,
        12,0,639,9,0,1,0,3,0,642,8,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
        1,1,1,1,1,1,1,1,1,1,3,1,658,8,1,1,1,1,1,1,1,1,1,1,1,5,1,665,8,1,
        10,1,12,1,668,9,1,1,2,1,2,1,3,1,3,1,3,1,3,1,3,3,3,677,8,3,1,3,1,
        3,1,3,5,3,682,8,3,10,3,12,3,685,9,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,
        1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,708,
        8,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,720,8,5,1,6,1,6,
        1,6,1,6,1,6,1,6,1,6,3,6,729,8,6,1,7,1,7,1,7,1,7,1,7,1,8,1,8,1,8,
        1,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,3,9,752,8,9,
        1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,
        1,10,1,10,1,10,3,10,770,8,10,1,11,1,11,1,11,1,11,1,11,3,11,777,8,
        11,1,11,1,11,1,12,1,12,1,12,1,12,1,12,3,12,786,8,12,1,12,1,12,1,
        13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,3,13,802,
        8,13,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,3,14,
        815,8,14,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,
        827,8,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,
        1,16,1,16,5,16,842,8,16,10,16,12,16,845,9,16,1,16,1,16,3,16,849,
        8,16,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,3,17,861,
        8,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,873,
        8,18,1,19,1,19,1,19,1,19,1,19,1,20,1,20,1,20,1,20,1,20,1,21,1,21,
        1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,3,21,895,8,21,1,22,1,22,
        1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,907,8,22,1,23,1,23,
        1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,
        1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,
        1,23,1,23,1,23,3,23,940,8,23,1,24,1,24,1,24,1,24,1,24,1,25,1,25,
        1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,3,25,959,8,25,
        1,26,1,26,1,26,1,26,1,26,1,26,5,26,967,8,26,10,26,12,26,970,9,26,
        1,27,1,27,1,27,1,27,3,27,976,8,27,1,28,1,28,1,28,1,28,1,29,1,29,
        1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,
        1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,
        1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,
        1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,
        1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,
        1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,
        1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,
        1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,
        1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,
        1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,
        1,29,1,29,1,29,1,29,1,29,1,29,1,29,3,29,1121,8,29,1,30,1,30,1,30,
        1,30,1,30,1,30,1,30,1,30,1,30,1,30,3,30,1133,8,30,1,31,1,31,1,31,
        1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,1145,8,31,1,32,1,32,1,32,
        1,32,1,32,1,32,1,32,1,32,1,32,1,32,3,32,1157,8,32,1,33,1,33,1,33,
        1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,5,33,1172,8,33,
        10,33,12,33,1175,9,33,1,33,1,33,3,33,1179,8,33,1,34,1,34,1,34,1,
        34,1,34,1,35,1,35,1,35,1,35,1,35,1,36,1,36,1,36,1,36,1,36,1,37,1,
        37,1,37,1,37,1,37,1,38,1,38,1,38,1,38,1,38,3,38,1206,8,38,1,38,1,
        38,1,39,1,39,1,39,1,39,1,40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,1,
        41,1,41,1,41,1,41,3,41,1226,8,41,1,42,1,42,1,42,1,42,1,42,1,42,1,
        42,1,42,3,42,1236,8,42,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,
        43,1,43,1,43,1,43,1,43,3,43,1251,8,43,1,44,1,44,1,44,1,44,1,44,1,
        45,1,45,1,45,1,45,1,45,1,46,1,46,1,46,1,46,1,47,1,47,1,47,1,47,1,
        47,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,
        48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,
        48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,
        48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,
        48,1,48,1,48,3,48,1326,8,48,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,
        49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,
        49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,3,49,1356,8,49,1,50,1,50,1,
        50,1,50,1,50,3,50,1363,8,50,1,50,1,50,1,51,1,51,1,51,1,51,1,51,1,
        51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,
        51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,
        51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,3,51,1409,8,
        51,1,52,1,52,1,52,1,52,1,52,1,53,1,53,1,53,1,53,1,53,1,54,1,54,1,
        54,1,54,1,54,1,55,1,55,1,55,1,55,1,55,3,55,1431,8,55,1,55,1,55,1,
        55,1,55,1,55,1,55,1,55,3,55,1440,8,55,1,56,1,56,1,56,1,56,1,56,1,
        57,1,57,1,57,1,57,1,58,1,58,1,58,1,58,1,58,1,59,1,59,1,59,1,59,1,
        59,1,59,1,59,1,59,3,59,1464,8,59,1,60,1,60,1,60,1,60,1,61,1,61,1,
        61,1,61,1,61,1,61,1,61,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,
        62,1,62,3,62,1487,8,62,1,63,1,63,1,63,1,63,1,63,3,63,1494,8,63,1,
        63,1,63,1,63,1,63,1,63,1,63,1,63,3,63,1503,8,63,1,64,1,64,1,64,1,
        64,1,64,1,65,1,65,1,65,1,65,1,66,1,66,1,66,1,66,1,66,1,67,1,67,1,
        67,1,67,1,68,1,68,1,68,1,68,1,69,1,69,1,69,1,69,1,69,1,70,1,70,1,
        70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,3,70,1545,8,
        70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1555,8,71,1,72,1,
        72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,3,72,1567,8,72,1,73,1,
        73,1,73,1,73,1,73,1,74,1,74,1,74,1,74,1,74,1,74,1,74,1,74,1,74,1,
        74,3,74,1584,8,74,1,75,1,75,1,75,1,75,1,75,1,76,1,76,1,76,1,76,1,
        76,1,76,1,76,1,76,1,76,1,76,3,76,1601,8,76,1,77,1,77,1,77,1,77,1,
        77,1,77,1,77,1,77,3,77,1611,8,77,1,78,1,78,1,78,1,78,1,78,1,78,1,
        78,1,78,3,78,1621,8,78,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,
        79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,
        79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,
        79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,
        79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,
        79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,
        79,3,79,1697,8,79,1,80,1,80,1,80,1,80,1,80,3,80,1704,8,80,1,80,1,
        80,1,80,1,80,1,80,1,80,1,80,3,80,1713,8,80,1,81,1,81,1,81,1,81,1,
        81,1,81,1,81,1,81,1,81,1,81,3,81,1725,8,81,1,81,1,81,1,81,1,81,1,
        81,1,81,1,81,3,81,1734,8,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,
        82,1,82,1,82,3,82,1746,8,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,
        82,1755,8,82,1,83,1,83,1,83,1,83,1,83,1,84,1,84,1,84,1,84,1,84,3,
        84,1767,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,
        84,1,84,3,84,1781,8,84,1,85,1,85,1,85,1,85,1,86,1,86,1,86,1,86,1,
        87,1,87,1,87,1,87,1,87,1,88,1,88,1,88,1,88,1,88,1,89,1,89,1,89,1,
        89,1,89,1,90,1,90,1,90,1,90,1,91,1,91,1,91,1,91,1,92,1,92,1,92,1,
        92,1,92,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,3,93,1829,
        8,93,1,94,1,94,1,94,1,94,1,95,1,95,1,95,1,95,1,96,1,96,1,96,1,96,
        1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,5,97,1853,8,97,
        10,97,12,97,1856,9,97,1,97,1,97,3,97,1860,8,97,1,98,1,98,1,98,1,
        98,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,1876,8,
        99,10,99,12,99,1879,9,99,1,99,1,99,3,99,1883,8,99,1,100,1,100,1,
        100,1,100,1,100,1,100,1,100,1,100,3,100,1893,8,100,1,101,1,101,1,
        101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,3,101,
        1907,8,101,1,102,1,102,1,102,1,102,1,102,1,103,1,103,1,103,1,103,
        1,103,1,103,1,103,1,103,3,103,1922,8,103,1,104,1,104,1,104,1,104,
        1,104,1,104,1,104,1,104,3,104,1932,8,104,1,105,1,105,1,105,1,105,
        1,105,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,
        1,106,1,106,1,106,1,106,1,106,1,106,1,106,3,106,1956,8,106,1,107,
        1,107,1,107,1,107,1,107,1,108,1,108,1,108,1,108,1,108,1,108,1,108,
        1,108,3,108,1971,8,108,1,109,1,109,1,109,1,109,1,109,1,109,1,109,
        1,109,3,109,1981,8,109,1,110,1,110,1,110,1,110,1,110,1,111,1,111,
        1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,
        3,111,2001,8,111,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,
        1,112,1,112,1,112,1,112,1,112,3,112,2016,8,112,1,113,1,113,1,113,
        1,113,1,113,1,113,1,113,1,113,3,113,2026,8,113,1,114,1,114,1,114,
        1,114,1,114,1,115,1,115,1,115,1,115,1,115,1,116,1,116,1,116,1,116,
        1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,
        1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,
        1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,
        1,116,1,116,1,116,1,116,1,116,3,116,2080,8,116,1,117,1,117,1,117,
        1,117,1,117,1,118,1,118,1,118,1,118,1,118,1,119,1,119,1,119,1,119,
        1,119,1,119,1,119,1,119,3,119,2100,8,119,1,120,1,120,1,120,1,120,
        1,121,1,121,1,121,1,121,1,121,1,122,1,122,1,122,1,122,1,122,1,123,
        1,123,1,123,1,123,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,
        3,124,2128,8,124,1,125,1,125,1,125,1,125,1,126,1,126,1,126,1,126,
        1,127,1,127,1,127,1,127,1,127,1,128,1,128,1,128,1,128,1,128,1,128,
        1,128,1,128,3,128,2151,8,128,1,129,1,129,1,129,1,129,1,129,3,129,
        2158,8,129,1,129,1,129,1,130,1,130,1,130,1,130,1,130,1,131,1,131,
        1,131,1,131,1,131,1,131,1,131,1,131,1,131,3,131,2176,8,131,1,131,
        1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,
        1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,
        1,131,1,131,3,131,2203,8,131,1,131,1,131,1,131,1,131,1,131,1,131,
        1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,
        1,131,1,131,3,131,2224,8,131,1,132,1,132,1,132,1,132,1,132,1,133,
        1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,
        1,133,1,133,1,133,1,133,3,133,2247,8,133,1,134,1,134,1,134,1,134,
        1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,
        1,135,3,135,2265,8,135,1,136,1,136,1,136,1,136,1,136,1,136,1,136,
        1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,3,136,2283,
        8,136,1,137,1,137,1,137,1,137,1,138,1,138,1,138,1,138,1,138,1,138,
        1,138,1,138,3,138,2297,8,138,1,139,1,139,1,139,1,139,1,139,1,139,
        1,139,1,139,3,139,2307,8,139,1,140,1,140,1,140,1,140,1,140,1,140,
        1,140,1,140,1,140,1,140,1,140,1,140,3,140,2321,8,140,1,141,1,141,
        1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,
        1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,3,141,2344,8,141,
        1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,
        1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,3,141,
        2367,8,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,3,141,2376,
        8,141,1,142,1,142,1,142,1,142,1,143,1,143,1,143,1,143,1,143,1,144,
        1,144,1,144,1,144,1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145,
        1,145,1,145,1,145,1,145,3,145,2403,8,145,1,146,1,146,1,146,1,146,
        1,146,1,146,1,146,1,146,1,146,1,146,1,146,1,146,3,146,2417,8,146,
        1,147,1,147,1,147,1,147,1,147,1,148,1,148,1,148,1,148,1,148,1,148,
        1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,
        1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,
        3,148,2452,8,148,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,
        3,149,2462,8,149,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,
        1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,
        1,150,3,150,2484,8,150,1,151,1,151,1,151,1,151,1,151,1,152,1,152,
        1,152,1,152,1,152,1,153,1,153,1,153,1,153,1,153,3,153,2501,8,153,
        1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,
        1,153,3,153,2515,8,153,1,154,1,154,1,154,1,154,1,154,3,154,2522,
        8,154,1,154,1,154,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,
        3,155,2534,8,155,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,
        3,156,2544,8,156,1,157,1,157,1,157,1,157,1,157,1,158,1,158,1,158,
        1,158,1,158,1,158,1,158,1,158,3,158,2559,8,158,1,159,1,159,1,159,
        1,159,1,159,1,159,1,159,1,159,3,159,2569,8,159,1,160,1,160,1,160,
        1,160,1,161,1,161,1,161,1,161,1,161,1,162,1,162,1,162,1,162,1,162,
        1,162,1,162,1,162,1,162,1,162,3,162,2590,8,162,1,163,1,163,1,163,
        1,163,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164,
        3,164,2606,8,164,1,164,1,164,3,164,2610,8,164,1,165,1,165,1,165,
        1,165,1,165,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,
        1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,3,166,2634,8,166,
        1,167,1,167,1,167,1,167,3,167,2640,8,167,1,167,1,167,1,167,1,167,
        1,167,1,167,3,167,2648,8,167,1,167,1,167,1,167,1,167,3,167,2654,
        8,167,1,167,1,167,3,167,2658,8,167,1,168,1,168,1,168,1,168,1,169,
        3,169,2665,8,169,1,169,1,169,1,169,1,169,1,169,5,169,2672,8,169,
        10,169,12,169,2675,9,169,3,169,2677,8,169,1,169,3,169,2680,8,169,
        1,170,1,170,3,170,2684,8,170,1,170,1,170,1,170,1,171,1,171,1,171,
        1,171,1,171,1,171,1,171,1,171,3,171,2697,8,171,1,172,1,172,1,172,
        1,172,3,172,2703,8,172,1,173,1,173,3,173,2707,8,173,1,174,1,174,
        1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,
        1,175,3,175,2723,8,175,1,176,1,176,1,176,1,176,1,176,1,176,1,176,
        1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,3,176,2741,
        8,176,1,177,1,177,1,177,1,177,1,177,1,177,1,177,1,177,1,177,1,177,
        1,177,1,177,3,177,2755,8,177,1,178,1,178,3,178,2759,8,178,1,179,
        1,179,1,180,1,180,1,180,1,180,1,180,1,180,1,180,1,180,1,180,1,180,
        1,180,1,180,1,180,1,180,1,180,3,180,2778,8,180,1,181,1,181,1,181,
        1,181,3,181,2784,8,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,
        1,181,3,181,2794,8,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,
        1,181,3,181,2804,8,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,
        1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,3,181,2822,
        8,181,1,182,1,182,1,182,1,182,1,182,1,182,1,182,1,182,3,182,2832,
        8,182,1,183,1,183,1,183,1,183,1,183,1,183,1,183,1,183,1,183,1,183,
        1,183,1,183,1,183,1,183,1,183,1,183,3,183,2850,8,183,1,184,1,184,
        1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,
        1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,
        1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,
        1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,3,184,2896,
        8,184,1,185,1,185,1,185,1,185,1,185,1,185,1,185,1,185,1,185,1,185,
        1,185,1,185,3,185,2910,8,185,1,186,1,186,1,186,1,186,1,186,1,186,
        1,186,1,186,1,186,1,186,1,186,1,186,1,186,1,186,1,186,1,186,3,186,
        2928,8,186,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,3,187,3146,
        8,187,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,
        1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,
        1,188,3,188,3170,8,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,
        1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,
        1,188,5,188,3191,8,188,10,188,12,188,3194,9,188,1,189,1,189,1,189,
        1,189,1,189,1,189,1,189,1,189,3,189,3204,8,189,1,190,1,190,1,191,
        1,191,1,192,1,192,3,192,3212,8,192,1,193,1,193,1,194,1,194,1,194,
        1,194,3,194,3220,8,194,1,194,1,194,1,194,1,194,1,194,1,194,1,194,
        1,194,3,194,3230,8,194,1,194,1,194,1,194,1,194,3,194,3236,8,194,
        1,195,1,195,1,195,1,195,3,195,3242,8,195,1,195,1,195,1,195,1,195,
        1,195,1,195,1,195,1,195,3,195,3252,8,195,1,195,1,195,1,195,1,195,
        3,195,3258,8,195,1,196,1,196,1,196,1,196,3,196,3264,8,196,1,196,
        1,196,1,196,1,196,1,196,1,196,1,196,1,196,3,196,3274,8,196,1,196,
        1,196,1,196,1,196,3,196,3280,8,196,1,197,1,197,1,197,1,197,3,197,
        3286,8,197,1,197,1,197,1,197,1,197,1,197,1,197,1,197,1,197,3,197,
        3296,8,197,1,197,1,197,1,197,1,197,3,197,3302,8,197,1,198,1,198,
        1,198,1,198,3,198,3308,8,198,1,198,1,198,1,198,1,198,1,198,1,198,
        1,198,1,198,3,198,3318,8,198,1,198,1,198,1,198,1,198,3,198,3324,
        8,198,1,199,1,199,1,199,1,199,3,199,3330,8,199,1,199,1,199,1,199,
        1,199,1,199,1,199,1,199,1,199,3,199,3340,8,199,1,199,1,199,1,199,
        1,199,3,199,3346,8,199,1,200,1,200,1,200,1,200,3,200,3352,8,200,
        1,200,1,200,1,200,1,200,1,200,1,200,1,200,1,200,3,200,3362,8,200,
        1,200,1,200,1,200,1,200,3,200,3368,8,200,1,201,1,201,1,201,1,201,
        3,201,3374,8,201,1,201,1,201,1,201,1,201,1,201,1,201,1,201,1,201,
        1,201,1,201,3,201,3386,8,201,1,201,1,201,1,201,1,201,1,201,1,201,
        3,201,3394,8,201,1,202,1,202,1,202,1,202,3,202,3400,8,202,1,202,
        1,202,1,202,1,202,1,202,1,202,1,202,1,202,1,202,1,202,3,202,3412,
        8,202,1,202,1,202,1,202,1,202,1,202,1,202,3,202,3420,8,202,1,203,
        1,203,1,203,1,203,3,203,3426,8,203,1,203,1,203,1,203,1,203,1,203,
        1,203,1,203,1,203,1,203,1,203,3,203,3438,8,203,1,203,1,203,1,203,
        1,203,1,203,1,203,3,203,3446,8,203,1,204,1,204,1,204,1,204,3,204,
        3452,8,204,1,204,1,204,1,204,1,204,1,204,1,204,3,204,3460,8,204,
        1,204,1,204,1,204,1,204,1,204,1,204,1,204,1,204,3,204,3470,8,204,
        1,204,1,204,1,204,1,204,3,204,3476,8,204,1,205,1,205,1,205,1,205,
        3,205,3482,8,205,1,205,1,205,1,205,1,205,1,205,1,205,3,205,3490,
        8,205,1,205,1,205,1,205,1,205,1,205,1,205,1,205,1,205,3,205,3500,
        8,205,1,205,1,205,1,205,1,205,3,205,3506,8,205,1,206,1,206,1,206,
        1,206,3,206,3512,8,206,1,206,1,206,1,206,1,206,1,207,1,207,1,207,
        1,207,3,207,3522,8,207,1,207,1,207,1,207,1,207,1,207,1,207,1,207,
        1,207,3,207,3532,8,207,1,207,1,207,1,207,1,207,3,207,3538,8,207,
        1,208,1,208,1,208,1,208,3,208,3544,8,208,1,208,1,208,1,208,1,208,
        1,208,1,208,1,208,1,208,3,208,3554,8,208,1,208,1,208,1,208,1,208,
        3,208,3560,8,208,1,209,1,209,1,209,1,209,3,209,3566,8,209,1,209,
        1,209,1,209,1,209,1,209,1,209,1,209,1,209,3,209,3576,8,209,1,209,
        1,209,1,209,1,209,3,209,3582,8,209,1,210,1,210,1,210,1,210,3,210,
        3588,8,210,1,210,1,210,1,210,1,210,1,210,1,210,1,210,1,210,3,210,
        3598,8,210,1,210,1,210,1,210,1,210,3,210,3604,8,210,1,211,1,211,
        1,211,1,211,3,211,3610,8,211,1,211,1,211,1,211,1,211,1,211,1,211,
        1,211,1,211,3,211,3620,8,211,1,211,1,211,1,211,1,211,3,211,3626,
        8,211,1,212,1,212,1,212,1,212,3,212,3632,8,212,1,212,1,212,1,212,
        1,212,1,212,1,212,1,212,1,212,3,212,3642,8,212,1,212,1,212,1,212,
        1,212,3,212,3648,8,212,1,213,1,213,1,213,1,213,3,213,3654,8,213,
        1,213,1,213,1,213,1,213,1,214,1,214,1,214,1,214,3,214,3664,8,214,
        1,214,1,214,1,214,1,214,1,215,1,215,1,215,1,215,1,216,1,216,1,216,
        1,216,1,217,1,217,1,217,1,217,1,218,1,218,1,218,1,218,1,219,1,219,
        1,219,1,219,1,219,1,219,1,219,1,219,3,219,3694,8,219,1,220,1,220,
        1,220,1,220,1,221,1,221,1,221,1,221,1,222,1,222,1,222,1,222,1,223,
        1,223,1,223,1,223,1,223,1,223,1,223,3,223,3715,8,223,1,224,1,224,
        1,224,3,224,3720,8,224,1,225,1,225,1,225,3,225,3725,8,225,1,226,
        1,226,1,226,3,226,3730,8,226,1,227,1,227,1,227,1,227,1,227,3,227,
        3737,8,227,1,228,1,228,1,228,1,228,1,228,1,228,1,228,1,228,1,228,
        3,228,3748,8,228,1,229,1,229,3,229,3752,8,229,1,230,1,230,1,230,
        3,230,3757,8,230,1,231,1,231,1,231,1,231,1,232,1,232,1,232,1,232,
        1,233,1,233,1,233,1,233,1,234,1,234,1,234,1,234,1,235,1,235,1,235,
        1,235,1,236,1,236,1,236,1,236,1,237,1,237,1,237,1,237,1,238,1,238,
        1,238,1,238,1,239,1,239,1,239,1,239,1,240,1,240,1,240,1,240,1,241,
        1,241,1,241,1,241,1,242,1,242,1,242,1,242,1,243,1,243,1,243,1,243,
        1,244,1,244,1,244,1,244,1,245,1,245,1,245,1,245,1,246,1,246,1,246,
        1,246,1,247,1,247,1,247,1,247,1,248,1,248,1,248,1,248,1,249,1,249,
        1,249,1,249,1,250,1,250,1,250,1,250,1,251,1,251,1,251,1,251,1,252,
        1,252,1,252,1,252,1,253,1,253,1,253,1,253,1,254,1,254,1,254,1,254,
        1,255,1,255,1,255,1,255,1,256,1,256,1,256,1,256,1,257,1,257,1,257,
        1,257,1,258,1,258,1,258,1,258,1,259,1,259,1,259,1,259,1,260,1,260,
        1,261,1,261,1,262,1,262,1,263,1,263,1,264,1,264,1,265,1,265,1,266,
        1,266,3,266,3889,8,266,1,267,1,267,3,267,3893,8,267,1,268,1,268,
        3,268,3897,8,268,1,269,1,269,1,269,5,269,3902,8,269,10,269,12,269,
        3905,9,269,1,270,1,270,3,270,3909,8,270,1,271,1,271,1,271,5,271,
        3914,8,271,10,271,12,271,3917,9,271,3,271,3919,8,271,1,272,1,272,
        3,272,3923,8,272,1,273,1,273,3,273,3927,8,273,1,274,1,274,1,274,
        5,274,3932,8,274,10,274,12,274,3935,9,274,3,274,3937,8,274,1,275,
        1,275,3,275,3941,8,275,1,276,1,276,3,276,3945,8,276,1,277,1,277,
        3,277,3949,8,277,1,278,3,278,3952,8,278,1,279,1,279,1,279,5,279,
        3957,8,279,10,279,12,279,3960,9,279,1,280,3,280,3963,8,280,1,281,
        1,281,1,281,5,281,3968,8,281,10,281,12,281,3971,9,281,1,282,3,282,
        3974,8,282,1,283,1,283,1,283,5,283,3979,8,283,10,283,12,283,3982,
        9,283,1,284,1,284,1,284,1,284,5,284,3988,8,284,10,284,12,284,3991,
        9,284,3,284,3993,8,284,1,284,1,284,1,285,3,285,3998,8,285,1,286,
        1,286,1,286,5,286,4003,8,286,10,286,12,286,4006,9,286,1,287,1,287,
        3,287,4010,8,287,1,288,1,288,1,288,1,288,1,288,1,288,1,288,1,288,
        1,288,1,288,3,288,4022,8,288,1,289,1,289,1,289,1,289,5,289,4028,
        8,289,10,289,12,289,4031,9,289,3,289,4033,8,289,1,289,1,289,1,290,
        1,290,1,290,5,290,4040,8,290,10,290,12,290,4043,9,290,3,290,4045,
        8,290,1,291,1,291,1,291,5,291,4050,8,291,10,291,12,291,4053,9,291,
        1,292,1,292,1,292,1,292,1,292,1,292,1,292,1,292,1,292,1,292,1,292,
        1,292,1,292,1,292,1,292,1,292,1,292,1,292,1,292,1,292,1,292,1,292,
        1,292,3,292,4078,8,292,1,293,1,293,1,293,1,293,1,293,1,293,1,293,
        5,293,4087,8,293,10,293,12,293,4090,9,293,1,293,1,293,3,293,4094,
        8,293,1,294,1,294,1,294,1,294,1,294,3,294,4101,8,294,1,294,1,294,
        1,294,1,294,1,294,3,294,4108,8,294,1,294,1,294,1,294,1,294,1,294,
        3,294,4115,8,294,1,294,1,294,1,294,1,294,1,294,3,294,4122,8,294,
        1,294,1,294,1,294,1,294,1,294,3,294,4129,8,294,1,294,1,294,1,294,
        1,294,1,294,3,294,4136,8,294,1,294,1,294,1,294,1,294,1,294,3,294,
        4143,8,294,1,294,1,294,3,294,4147,8,294,3,294,4149,8,294,1,295,1,
        295,1,295,1,295,1,296,1,296,1,297,1,297,3,297,4159,8,297,1,298,1,
        298,1,299,1,299,1,299,3,299,4166,8,299,1,300,1,300,3,300,4170,8,
        300,1,301,1,301,1,302,1,302,1,302,1,302,1,302,1,302,1,302,1,302,
        1,302,1,302,1,302,1,302,1,302,1,302,1,302,1,302,3,302,4190,8,302,
        1,303,1,303,1,304,1,304,1,305,1,305,1,306,1,306,1,306,1,306,1,306,
        1,306,1,306,1,306,3,306,4206,8,306,1,307,1,307,1,308,1,308,1,308,
        1,308,1,308,1,308,1,308,3,308,4217,8,308,1,308,1,308,1,309,1,309,
        1,309,1,309,1,309,1,310,1,310,1,310,1,310,1,310,1,310,1,310,1,310,
        1,310,1,310,1,310,1,310,1,310,1,310,3,310,4240,8,310,1,311,1,311,
        1,312,1,312,1,313,1,313,1,314,1,314,1,314,0,4,2,6,52,376,315,0,2,
        4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,
        50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,
        94,96,98,100,102,104,106,108,110,112,114,116,118,120,122,124,126,
        128,130,132,134,136,138,140,142,144,146,148,150,152,154,156,158,
        160,162,164,166,168,170,172,174,176,178,180,182,184,186,188,190,
        192,194,196,198,200,202,204,206,208,210,212,214,216,218,220,222,
        224,226,228,230,232,234,236,238,240,242,244,246,248,250,252,254,
        256,258,260,262,264,266,268,270,272,274,276,278,280,282,284,286,
        288,290,292,294,296,298,300,302,304,306,308,310,312,314,316,318,
        320,322,324,326,328,330,332,334,336,338,340,342,344,346,348,350,
        352,354,356,358,360,362,364,366,368,370,372,374,376,378,380,382,
        384,386,388,390,392,394,396,398,400,402,404,406,408,410,412,414,
        416,418,420,422,424,426,428,430,432,434,436,438,440,442,444,446,
        448,450,452,454,456,458,460,462,464,466,468,470,472,474,476,478,
        480,482,484,486,488,490,492,494,496,498,500,502,504,506,508,510,
        512,514,516,518,520,522,524,526,528,530,532,534,536,538,540,542,
        544,546,548,550,552,554,556,558,560,562,564,566,568,570,572,574,
        576,578,580,582,584,586,588,590,592,594,596,598,600,602,604,606,
        608,610,612,614,616,618,620,622,624,626,628,0,6,4,0,120,120,141,
        141,144,144,287,287,5,0,30,30,100,100,124,124,199,199,261,261,1,
        0,309,312,2,0,92,92,274,274,2,0,130,130,307,307,2,0,1,304,323,323,
        4651,0,630,1,0,0,0,2,657,1,0,0,0,4,669,1,0,0,0,6,676,1,0,0,0,8,707,
        1,0,0,0,10,719,1,0,0,0,12,728,1,0,0,0,14,730,1,0,0,0,16,735,1,0,
        0,0,18,751,1,0,0,0,20,769,1,0,0,0,22,771,1,0,0,0,24,780,1,0,0,0,
        26,801,1,0,0,0,28,814,1,0,0,0,30,826,1,0,0,0,32,848,1,0,0,0,34,860,
        1,0,0,0,36,872,1,0,0,0,38,874,1,0,0,0,40,879,1,0,0,0,42,894,1,0,
        0,0,44,906,1,0,0,0,46,939,1,0,0,0,48,941,1,0,0,0,50,958,1,0,0,0,
        52,960,1,0,0,0,54,975,1,0,0,0,56,977,1,0,0,0,58,1120,1,0,0,0,60,
        1132,1,0,0,0,62,1144,1,0,0,0,64,1156,1,0,0,0,66,1178,1,0,0,0,68,
        1180,1,0,0,0,70,1185,1,0,0,0,72,1190,1,0,0,0,74,1195,1,0,0,0,76,
        1200,1,0,0,0,78,1209,1,0,0,0,80,1213,1,0,0,0,82,1225,1,0,0,0,84,
        1235,1,0,0,0,86,1250,1,0,0,0,88,1252,1,0,0,0,90,1257,1,0,0,0,92,
        1262,1,0,0,0,94,1266,1,0,0,0,96,1325,1,0,0,0,98,1355,1,0,0,0,100,
        1357,1,0,0,0,102,1408,1,0,0,0,104,1410,1,0,0,0,106,1415,1,0,0,0,
        108,1420,1,0,0,0,110,1439,1,0,0,0,112,1441,1,0,0,0,114,1446,1,0,
        0,0,116,1450,1,0,0,0,118,1463,1,0,0,0,120,1465,1,0,0,0,122,1469,
        1,0,0,0,124,1486,1,0,0,0,126,1502,1,0,0,0,128,1504,1,0,0,0,130,1509,
        1,0,0,0,132,1513,1,0,0,0,134,1518,1,0,0,0,136,1522,1,0,0,0,138,1526,
        1,0,0,0,140,1544,1,0,0,0,142,1554,1,0,0,0,144,1566,1,0,0,0,146,1568,
        1,0,0,0,148,1583,1,0,0,0,150,1585,1,0,0,0,152,1600,1,0,0,0,154,1610,
        1,0,0,0,156,1620,1,0,0,0,158,1696,1,0,0,0,160,1712,1,0,0,0,162,1733,
        1,0,0,0,164,1754,1,0,0,0,166,1756,1,0,0,0,168,1780,1,0,0,0,170,1782,
        1,0,0,0,172,1786,1,0,0,0,174,1790,1,0,0,0,176,1795,1,0,0,0,178,1800,
        1,0,0,0,180,1805,1,0,0,0,182,1809,1,0,0,0,184,1813,1,0,0,0,186,1828,
        1,0,0,0,188,1830,1,0,0,0,190,1834,1,0,0,0,192,1838,1,0,0,0,194,1859,
        1,0,0,0,196,1861,1,0,0,0,198,1882,1,0,0,0,200,1892,1,0,0,0,202,1906,
        1,0,0,0,204,1908,1,0,0,0,206,1921,1,0,0,0,208,1931,1,0,0,0,210,1933,
        1,0,0,0,212,1955,1,0,0,0,214,1957,1,0,0,0,216,1970,1,0,0,0,218,1980,
        1,0,0,0,220,1982,1,0,0,0,222,2000,1,0,0,0,224,2015,1,0,0,0,226,2025,
        1,0,0,0,228,2027,1,0,0,0,230,2032,1,0,0,0,232,2079,1,0,0,0,234,2081,
        1,0,0,0,236,2086,1,0,0,0,238,2099,1,0,0,0,240,2101,1,0,0,0,242,2105,
        1,0,0,0,244,2110,1,0,0,0,246,2115,1,0,0,0,248,2127,1,0,0,0,250,2129,
        1,0,0,0,252,2133,1,0,0,0,254,2137,1,0,0,0,256,2150,1,0,0,0,258,2152,
        1,0,0,0,260,2161,1,0,0,0,262,2223,1,0,0,0,264,2225,1,0,0,0,266,2246,
        1,0,0,0,268,2248,1,0,0,0,270,2264,1,0,0,0,272,2282,1,0,0,0,274,2284,
        1,0,0,0,276,2296,1,0,0,0,278,2306,1,0,0,0,280,2320,1,0,0,0,282,2375,
        1,0,0,0,284,2377,1,0,0,0,286,2381,1,0,0,0,288,2386,1,0,0,0,290,2402,
        1,0,0,0,292,2416,1,0,0,0,294,2418,1,0,0,0,296,2451,1,0,0,0,298,2461,
        1,0,0,0,300,2483,1,0,0,0,302,2485,1,0,0,0,304,2490,1,0,0,0,306,2514,
        1,0,0,0,308,2516,1,0,0,0,310,2533,1,0,0,0,312,2543,1,0,0,0,314,2545,
        1,0,0,0,316,2558,1,0,0,0,318,2568,1,0,0,0,320,2570,1,0,0,0,322,2574,
        1,0,0,0,324,2589,1,0,0,0,326,2591,1,0,0,0,328,2609,1,0,0,0,330,2611,
        1,0,0,0,332,2633,1,0,0,0,334,2657,1,0,0,0,336,2659,1,0,0,0,338,2664,
        1,0,0,0,340,2683,1,0,0,0,342,2696,1,0,0,0,344,2702,1,0,0,0,346,2706,
        1,0,0,0,348,2708,1,0,0,0,350,2722,1,0,0,0,352,2740,1,0,0,0,354,2754,
        1,0,0,0,356,2758,1,0,0,0,358,2760,1,0,0,0,360,2777,1,0,0,0,362,2821,
        1,0,0,0,364,2831,1,0,0,0,366,2849,1,0,0,0,368,2895,1,0,0,0,370,2909,
        1,0,0,0,372,2927,1,0,0,0,374,3145,1,0,0,0,376,3169,1,0,0,0,378,3203,
        1,0,0,0,380,3205,1,0,0,0,382,3207,1,0,0,0,384,3211,1,0,0,0,386,3213,
        1,0,0,0,388,3235,1,0,0,0,390,3257,1,0,0,0,392,3279,1,0,0,0,394,3301,
        1,0,0,0,396,3323,1,0,0,0,398,3345,1,0,0,0,400,3367,1,0,0,0,402,3393,
        1,0,0,0,404,3419,1,0,0,0,406,3445,1,0,0,0,408,3475,1,0,0,0,410,3505,
        1,0,0,0,412,3511,1,0,0,0,414,3537,1,0,0,0,416,3559,1,0,0,0,418,3581,
        1,0,0,0,420,3603,1,0,0,0,422,3625,1,0,0,0,424,3647,1,0,0,0,426,3653,
        1,0,0,0,428,3663,1,0,0,0,430,3669,1,0,0,0,432,3673,1,0,0,0,434,3677,
        1,0,0,0,436,3681,1,0,0,0,438,3693,1,0,0,0,440,3695,1,0,0,0,442,3699,
        1,0,0,0,444,3703,1,0,0,0,446,3714,1,0,0,0,448,3719,1,0,0,0,450,3724,
        1,0,0,0,452,3729,1,0,0,0,454,3736,1,0,0,0,456,3747,1,0,0,0,458,3751,
        1,0,0,0,460,3756,1,0,0,0,462,3758,1,0,0,0,464,3762,1,0,0,0,466,3766,
        1,0,0,0,468,3770,1,0,0,0,470,3774,1,0,0,0,472,3778,1,0,0,0,474,3782,
        1,0,0,0,476,3786,1,0,0,0,478,3790,1,0,0,0,480,3794,1,0,0,0,482,3798,
        1,0,0,0,484,3802,1,0,0,0,486,3806,1,0,0,0,488,3810,1,0,0,0,490,3814,
        1,0,0,0,492,3818,1,0,0,0,494,3822,1,0,0,0,496,3826,1,0,0,0,498,3830,
        1,0,0,0,500,3834,1,0,0,0,502,3838,1,0,0,0,504,3842,1,0,0,0,506,3846,
        1,0,0,0,508,3850,1,0,0,0,510,3854,1,0,0,0,512,3858,1,0,0,0,514,3862,
        1,0,0,0,516,3866,1,0,0,0,518,3870,1,0,0,0,520,3874,1,0,0,0,522,3876,
        1,0,0,0,524,3878,1,0,0,0,526,3880,1,0,0,0,528,3882,1,0,0,0,530,3884,
        1,0,0,0,532,3888,1,0,0,0,534,3892,1,0,0,0,536,3896,1,0,0,0,538,3898,
        1,0,0,0,540,3908,1,0,0,0,542,3918,1,0,0,0,544,3922,1,0,0,0,546,3926,
        1,0,0,0,548,3936,1,0,0,0,550,3940,1,0,0,0,552,3944,1,0,0,0,554,3948,
        1,0,0,0,556,3951,1,0,0,0,558,3953,1,0,0,0,560,3962,1,0,0,0,562,3964,
        1,0,0,0,564,3973,1,0,0,0,566,3975,1,0,0,0,568,3983,1,0,0,0,570,3997,
        1,0,0,0,572,3999,1,0,0,0,574,4009,1,0,0,0,576,4021,1,0,0,0,578,4023,
        1,0,0,0,580,4044,1,0,0,0,582,4046,1,0,0,0,584,4077,1,0,0,0,586,4093,
        1,0,0,0,588,4148,1,0,0,0,590,4150,1,0,0,0,592,4154,1,0,0,0,594,4158,
        1,0,0,0,596,4160,1,0,0,0,598,4165,1,0,0,0,600,4169,1,0,0,0,602,4171,
        1,0,0,0,604,4189,1,0,0,0,606,4191,1,0,0,0,608,4193,1,0,0,0,610,4195,
        1,0,0,0,612,4205,1,0,0,0,614,4207,1,0,0,0,616,4209,1,0,0,0,618,4220,
        1,0,0,0,620,4239,1,0,0,0,622,4241,1,0,0,0,624,4243,1,0,0,0,626,4245,
        1,0,0,0,628,4247,1,0,0,0,630,637,3,2,1,0,631,633,5,319,0,0,632,631,
        1,0,0,0,632,633,1,0,0,0,633,634,1,0,0,0,634,636,3,2,1,0,635,632,
        1,0,0,0,636,639,1,0,0,0,637,635,1,0,0,0,637,638,1,0,0,0,638,641,
        1,0,0,0,639,637,1,0,0,0,640,642,5,319,0,0,641,640,1,0,0,0,641,642,
        1,0,0,0,642,643,1,0,0,0,643,644,5,0,0,1,644,1,1,0,0,0,645,646,6,
        1,-1,0,646,658,3,6,3,0,647,648,3,6,3,0,648,649,5,321,0,0,649,650,
        3,8,4,0,650,658,1,0,0,0,651,658,3,10,5,0,652,653,3,10,5,0,653,654,
        5,321,0,0,654,655,3,378,189,0,655,658,1,0,0,0,656,658,3,4,2,0,657,
        645,1,0,0,0,657,647,1,0,0,0,657,651,1,0,0,0,657,652,1,0,0,0,657,
        656,1,0,0,0,658,666,1,0,0,0,659,660,10,2,0,0,660,661,5,321,0,0,661,
        662,5,267,0,0,662,663,5,313,0,0,663,665,5,314,0,0,664,659,1,0,0,
        0,665,668,1,0,0,0,666,664,1,0,0,0,666,667,1,0,0,0,667,3,1,0,0,0,
        668,666,1,0,0,0,669,670,5,312,0,0,670,5,1,0,0,0,671,672,6,3,-1,0,
        672,677,5,323,0,0,673,674,5,323,0,0,674,675,5,321,0,0,675,677,3,
        12,6,0,676,671,1,0,0,0,676,673,1,0,0,0,677,683,1,0,0,0,678,679,10,
        1,0,0,679,680,5,321,0,0,680,682,3,12,6,0,681,678,1,0,0,0,682,685,
        1,0,0,0,683,681,1,0,0,0,683,684,1,0,0,0,684,7,1,0,0,0,685,683,1,
        0,0,0,686,687,5,277,0,0,687,688,5,313,0,0,688,689,5,314,0,0,689,
        690,5,321,0,0,690,691,5,18,0,0,691,692,5,313,0,0,692,708,5,314,0,
        0,693,694,5,277,0,0,694,695,5,313,0,0,695,696,5,314,0,0,696,697,
        5,321,0,0,697,698,5,47,0,0,698,699,5,313,0,0,699,708,5,314,0,0,700,
        701,5,277,0,0,701,702,5,313,0,0,702,703,5,314,0,0,703,704,5,321,
        0,0,704,705,5,229,0,0,705,706,5,313,0,0,706,708,5,314,0,0,707,686,
        1,0,0,0,707,693,1,0,0,0,707,700,1,0,0,0,708,9,1,0,0,0,709,710,3,
        6,3,0,710,711,5,321,0,0,711,712,3,28,14,0,712,720,1,0,0,0,713,714,
        3,6,3,0,714,715,5,321,0,0,715,716,3,28,14,0,716,717,5,321,0,0,717,
        718,3,52,26,0,718,720,1,0,0,0,719,709,1,0,0,0,719,713,1,0,0,0,720,
        11,1,0,0,0,721,729,3,14,7,0,722,729,3,16,8,0,723,729,3,18,9,0,724,
        729,3,20,10,0,725,729,3,22,11,0,726,729,3,24,12,0,727,729,3,26,13,
        0,728,721,1,0,0,0,728,722,1,0,0,0,728,723,1,0,0,0,728,724,1,0,0,
        0,728,725,1,0,0,0,728,726,1,0,0,0,728,727,1,0,0,0,729,13,1,0,0,0,
        730,731,5,294,0,0,731,732,5,313,0,0,732,733,3,602,301,0,733,734,
        5,314,0,0,734,15,1,0,0,0,735,736,5,299,0,0,736,737,5,313,0,0,737,
        738,5,314,0,0,738,17,1,0,0,0,739,740,5,300,0,0,740,741,5,313,0,0,
        741,742,3,584,292,0,742,743,5,314,0,0,743,752,1,0,0,0,744,745,5,
        300,0,0,745,746,5,313,0,0,746,747,3,584,292,0,747,748,5,320,0,0,
        748,749,3,386,193,0,749,750,5,314,0,0,750,752,1,0,0,0,751,739,1,
        0,0,0,751,744,1,0,0,0,752,19,1,0,0,0,753,754,5,301,0,0,754,755,5,
        313,0,0,755,756,3,592,296,0,756,757,5,320,0,0,757,758,3,584,292,
        0,758,759,5,314,0,0,759,770,1,0,0,0,760,761,5,301,0,0,761,762,5,
        313,0,0,762,763,3,592,296,0,763,764,5,320,0,0,764,765,3,584,292,
        0,765,766,5,320,0,0,766,767,3,386,193,0,767,768,5,314,0,0,768,770,
        1,0,0,0,769,753,1,0,0,0,769,760,1,0,0,0,770,21,1,0,0,0,771,772,5,
        302,0,0,772,773,5,313,0,0,773,776,3,338,169,0,774,775,5,320,0,0,
        775,777,3,556,278,0,776,774,1,0,0,0,776,777,1,0,0,0,777,778,1,0,
        0,0,778,779,5,314,0,0,779,23,1,0,0,0,780,781,5,298,0,0,781,782,5,
        313,0,0,782,785,3,624,312,0,783,784,5,320,0,0,784,786,3,560,280,
        0,785,783,1,0,0,0,785,786,1,0,0,0,786,787,1,0,0,0,787,788,5,314,
        0,0,788,25,1,0,0,0,789,790,5,293,0,0,790,791,5,313,0,0,791,792,3,
        592,296,0,792,793,5,314,0,0,793,802,1,0,0,0,794,795,5,293,0,0,795,
        796,5,313,0,0,796,797,3,592,296,0,797,798,5,320,0,0,798,799,3,584,
        292,0,799,800,5,314,0,0,800,802,1,0,0,0,801,789,1,0,0,0,801,794,
        1,0,0,0,802,27,1,0,0,0,803,815,3,30,15,0,804,815,3,32,16,0,805,815,
        3,34,17,0,806,815,3,36,18,0,807,815,3,44,22,0,808,815,3,42,21,0,
        809,815,3,38,19,0,810,815,3,40,20,0,811,815,3,46,23,0,812,815,3,
        48,24,0,813,815,3,50,25,0,814,803,1,0,0,0,814,804,1,0,0,0,814,805,
        1,0,0,0,814,806,1,0,0,0,814,807,1,0,0,0,814,808,1,0,0,0,814,809,
        1,0,0,0,814,810,1,0,0,0,814,811,1,0,0,0,814,812,1,0,0,0,814,813,
        1,0,0,0,815,29,1,0,0,0,816,817,5,2,0,0,817,818,5,313,0,0,818,819,
        3,536,268,0,819,820,5,314,0,0,820,827,1,0,0,0,821,822,5,2,0,0,822,
        823,5,313,0,0,823,824,3,54,27,0,824,825,5,314,0,0,825,827,1,0,0,
        0,826,816,1,0,0,0,826,821,1,0,0,0,827,31,1,0,0,0,828,829,5,4,0,0,
        829,830,5,313,0,0,830,849,5,314,0,0,831,832,5,4,0,0,832,833,5,313,
        0,0,833,834,3,538,269,0,834,835,5,314,0,0,835,849,1,0,0,0,836,837,
        5,4,0,0,837,838,5,313,0,0,838,843,3,54,27,0,839,840,5,320,0,0,840,
        842,3,54,27,0,841,839,1,0,0,0,842,845,1,0,0,0,843,841,1,0,0,0,843,
        844,1,0,0,0,844,846,1,0,0,0,845,843,1,0,0,0,846,847,5,314,0,0,847,
        849,1,0,0,0,848,828,1,0,0,0,848,831,1,0,0,0,848,836,1,0,0,0,849,
        33,1,0,0,0,850,851,5,81,0,0,851,852,5,313,0,0,852,853,3,548,274,
        0,853,854,5,314,0,0,854,861,1,0,0,0,855,856,5,81,0,0,856,857,5,313,
        0,0,857,858,3,54,27,0,858,859,5,314,0,0,859,861,1,0,0,0,860,850,
        1,0,0,0,860,855,1,0,0,0,861,35,1,0,0,0,862,863,5,284,0,0,863,864,
        5,313,0,0,864,865,3,548,274,0,865,866,5,314,0,0,866,873,1,0,0,0,
        867,868,5,284,0,0,868,869,5,313,0,0,869,870,3,54,27,0,870,871,5,
        314,0,0,871,873,1,0,0,0,872,862,1,0,0,0,872,867,1,0,0,0,873,37,1,
        0,0,0,874,875,5,131,0,0,875,876,5,313,0,0,876,877,3,570,285,0,877,
        878,5,314,0,0,878,39,1,0,0,0,879,880,5,138,0,0,880,881,5,313,0,0,
        881,882,3,592,296,0,882,883,5,314,0,0,883,41,1,0,0,0,884,885,5,167,
        0,0,885,886,5,313,0,0,886,887,3,552,276,0,887,888,5,314,0,0,888,
        895,1,0,0,0,889,890,5,167,0,0,890,891,5,313,0,0,891,892,3,54,27,
        0,892,893,5,314,0,0,893,895,1,0,0,0,894,884,1,0,0,0,894,889,1,0,
        0,0,895,43,1,0,0,0,896,897,5,166,0,0,897,898,5,313,0,0,898,899,3,
        552,276,0,899,900,5,314,0,0,900,907,1,0,0,0,901,902,5,166,0,0,902,
        903,5,313,0,0,903,904,3,54,27,0,904,905,5,314,0,0,905,907,1,0,0,
        0,906,896,1,0,0,0,906,901,1,0,0,0,907,45,1,0,0,0,908,909,5,37,0,
        0,909,910,5,313,0,0,910,940,5,314,0,0,911,912,5,37,0,0,912,913,5,
        313,0,0,913,914,3,592,296,0,914,915,5,314,0,0,915,940,1,0,0,0,916,
        917,5,37,0,0,917,918,5,313,0,0,918,919,3,592,296,0,919,920,5,320,
        0,0,920,921,3,550,275,0,921,922,5,314,0,0,922,940,1,0,0,0,923,924,
        5,37,0,0,924,925,5,313,0,0,925,926,3,592,296,0,926,927,5,320,0,0,
        927,928,3,54,27,0,928,929,5,314,0,0,929,940,1,0,0,0,930,931,5,37,
        0,0,931,932,5,313,0,0,932,933,3,592,296,0,933,934,5,320,0,0,934,
        935,3,550,275,0,935,936,5,320,0,0,936,937,3,54,27,0,937,938,5,314,
        0,0,938,940,1,0,0,0,939,908,1,0,0,0,939,911,1,0,0,0,939,916,1,0,
        0,0,939,923,1,0,0,0,939,930,1,0,0,0,940,47,1,0,0,0,941,942,5,279,
        0,0,942,943,5,313,0,0,943,944,3,564,282,0,944,945,5,314,0,0,945,
        49,1,0,0,0,946,947,5,159,0,0,947,948,5,313,0,0,948,949,3,592,296,
        0,949,950,5,314,0,0,950,959,1,0,0,0,951,952,5,159,0,0,952,953,5,
        313,0,0,953,954,3,592,296,0,954,955,5,320,0,0,955,956,3,586,293,
        0,956,957,5,314,0,0,957,959,1,0,0,0,958,946,1,0,0,0,958,951,1,0,
        0,0,959,51,1,0,0,0,960,961,6,26,-1,0,961,962,3,58,29,0,962,968,1,
        0,0,0,963,964,10,1,0,0,964,965,5,321,0,0,965,967,3,58,29,0,966,963,
        1,0,0,0,967,970,1,0,0,0,968,966,1,0,0,0,968,969,1,0,0,0,969,53,1,
        0,0,0,970,968,1,0,0,0,971,976,3,52,26,0,972,973,5,324,0,0,973,974,
        5,321,0,0,974,976,3,52,26,0,975,971,1,0,0,0,975,972,1,0,0,0,976,
        55,1,0,0,0,977,978,3,10,5,0,978,979,5,321,0,0,979,980,3,378,189,
        0,980,57,1,0,0,0,981,1121,3,60,30,0,982,1121,3,62,31,0,983,1121,
        3,64,32,0,984,1121,3,66,33,0,985,1121,3,224,112,0,986,1121,3,222,
        111,0,987,1121,3,68,34,0,988,1121,3,70,35,0,989,1121,3,72,36,0,990,
        1121,3,74,37,0,991,1121,3,76,38,0,992,1121,3,86,43,0,993,1121,3,
        88,44,0,994,1121,3,90,45,0,995,1121,3,92,46,0,996,1121,3,94,47,0,
        997,1121,3,96,48,0,998,1121,3,100,50,0,999,1121,3,102,51,0,1000,
        1121,3,104,52,0,1001,1121,3,106,53,0,1002,1121,3,112,56,0,1003,1121,
        3,114,57,0,1004,1121,3,116,58,0,1005,1121,3,118,59,0,1006,1121,3,
        120,60,0,1007,1121,3,126,63,0,1008,1121,3,128,64,0,1009,1121,3,130,
        65,0,1010,1121,3,132,66,0,1011,1121,3,134,67,0,1012,1121,3,138,69,
        0,1013,1121,3,140,70,0,1014,1121,3,144,72,0,1015,1121,3,146,73,0,
        1016,1121,3,148,74,0,1017,1121,3,152,76,0,1018,1121,3,154,77,0,1019,
        1121,3,156,78,0,1020,1121,3,158,79,0,1021,1121,3,160,80,0,1022,1121,
        3,162,81,0,1023,1121,3,164,82,0,1024,1121,3,166,83,0,1025,1121,3,
        168,84,0,1026,1121,3,170,85,0,1027,1121,3,172,86,0,1028,1121,3,174,
        87,0,1029,1121,3,176,88,0,1030,1121,3,178,89,0,1031,1121,3,180,90,
        0,1032,1121,3,182,91,0,1033,1121,3,184,92,0,1034,1121,3,186,93,0,
        1035,1121,3,188,94,0,1036,1121,3,190,95,0,1037,1121,3,202,101,0,
        1038,1121,3,204,102,0,1039,1121,3,206,103,0,1040,1121,3,210,105,
        0,1041,1121,3,212,106,0,1042,1121,3,214,107,0,1043,1121,3,216,108,
        0,1044,1121,3,218,109,0,1045,1121,3,226,113,0,1046,1121,3,228,114,
        0,1047,1121,3,230,115,0,1048,1121,3,232,116,0,1049,1121,3,234,117,
        0,1050,1121,3,236,118,0,1051,1121,3,238,119,0,1052,1121,3,240,120,
        0,1053,1121,3,242,121,0,1054,1121,3,244,122,0,1055,1121,3,246,123,
        0,1056,1121,3,248,124,0,1057,1121,3,250,125,0,1058,1121,3,252,126,
        0,1059,1121,3,256,128,0,1060,1121,3,258,129,0,1061,1121,3,260,130,
        0,1062,1121,3,262,131,0,1063,1121,3,264,132,0,1064,1121,3,266,133,
        0,1065,1121,3,268,134,0,1066,1121,3,270,135,0,1067,1121,3,278,139,
        0,1068,1121,3,280,140,0,1069,1121,3,282,141,0,1070,1121,3,108,54,
        0,1071,1121,3,254,127,0,1072,1121,3,220,110,0,1073,1121,3,284,142,
        0,1074,1121,3,286,143,0,1075,1121,3,288,144,0,1076,1121,3,290,145,
        0,1077,1121,3,294,147,0,1078,1121,3,298,149,0,1079,1121,3,300,150,
        0,1080,1121,3,142,71,0,1081,1121,3,302,151,0,1082,1121,3,304,152,
        0,1083,1121,3,306,153,0,1084,1121,3,308,154,0,1085,1121,3,314,157,
        0,1086,1121,3,316,158,0,1087,1121,3,320,160,0,1088,1121,3,322,161,
        0,1089,1121,3,324,162,0,1090,1121,3,326,163,0,1091,1121,3,328,164,
        0,1092,1121,3,330,165,0,1093,1121,3,332,166,0,1094,1121,3,334,167,
        0,1095,1121,3,336,168,0,1096,1121,3,136,68,0,1097,1121,3,98,49,0,
        1098,1121,3,110,55,0,1099,1121,3,84,42,0,1100,1121,3,150,75,0,1101,
        1121,3,312,156,0,1102,1121,3,310,155,0,1103,1121,3,200,100,0,1104,
        1121,3,318,159,0,1105,1121,3,208,104,0,1106,1121,3,276,138,0,1107,
        1121,3,274,137,0,1108,1121,3,272,136,0,1109,1121,3,292,146,0,1110,
        1121,3,296,148,0,1111,1121,3,78,39,0,1112,1121,3,80,40,0,1113,1121,
        3,122,61,0,1114,1121,3,124,62,0,1115,1121,3,82,41,0,1116,1121,3,
        192,96,0,1117,1121,3,194,97,0,1118,1121,3,196,98,0,1119,1121,3,198,
        99,0,1120,981,1,0,0,0,1120,982,1,0,0,0,1120,983,1,0,0,0,1120,984,
        1,0,0,0,1120,985,1,0,0,0,1120,986,1,0,0,0,1120,987,1,0,0,0,1120,
        988,1,0,0,0,1120,989,1,0,0,0,1120,990,1,0,0,0,1120,991,1,0,0,0,1120,
        992,1,0,0,0,1120,993,1,0,0,0,1120,994,1,0,0,0,1120,995,1,0,0,0,1120,
        996,1,0,0,0,1120,997,1,0,0,0,1120,998,1,0,0,0,1120,999,1,0,0,0,1120,
        1000,1,0,0,0,1120,1001,1,0,0,0,1120,1002,1,0,0,0,1120,1003,1,0,0,
        0,1120,1004,1,0,0,0,1120,1005,1,0,0,0,1120,1006,1,0,0,0,1120,1007,
        1,0,0,0,1120,1008,1,0,0,0,1120,1009,1,0,0,0,1120,1010,1,0,0,0,1120,
        1011,1,0,0,0,1120,1012,1,0,0,0,1120,1013,1,0,0,0,1120,1014,1,0,0,
        0,1120,1015,1,0,0,0,1120,1016,1,0,0,0,1120,1017,1,0,0,0,1120,1018,
        1,0,0,0,1120,1019,1,0,0,0,1120,1020,1,0,0,0,1120,1021,1,0,0,0,1120,
        1022,1,0,0,0,1120,1023,1,0,0,0,1120,1024,1,0,0,0,1120,1025,1,0,0,
        0,1120,1026,1,0,0,0,1120,1027,1,0,0,0,1120,1028,1,0,0,0,1120,1029,
        1,0,0,0,1120,1030,1,0,0,0,1120,1031,1,0,0,0,1120,1032,1,0,0,0,1120,
        1033,1,0,0,0,1120,1034,1,0,0,0,1120,1035,1,0,0,0,1120,1036,1,0,0,
        0,1120,1037,1,0,0,0,1120,1038,1,0,0,0,1120,1039,1,0,0,0,1120,1040,
        1,0,0,0,1120,1041,1,0,0,0,1120,1042,1,0,0,0,1120,1043,1,0,0,0,1120,
        1044,1,0,0,0,1120,1045,1,0,0,0,1120,1046,1,0,0,0,1120,1047,1,0,0,
        0,1120,1048,1,0,0,0,1120,1049,1,0,0,0,1120,1050,1,0,0,0,1120,1051,
        1,0,0,0,1120,1052,1,0,0,0,1120,1053,1,0,0,0,1120,1054,1,0,0,0,1120,
        1055,1,0,0,0,1120,1056,1,0,0,0,1120,1057,1,0,0,0,1120,1058,1,0,0,
        0,1120,1059,1,0,0,0,1120,1060,1,0,0,0,1120,1061,1,0,0,0,1120,1062,
        1,0,0,0,1120,1063,1,0,0,0,1120,1064,1,0,0,0,1120,1065,1,0,0,0,1120,
        1066,1,0,0,0,1120,1067,1,0,0,0,1120,1068,1,0,0,0,1120,1069,1,0,0,
        0,1120,1070,1,0,0,0,1120,1071,1,0,0,0,1120,1072,1,0,0,0,1120,1073,
        1,0,0,0,1120,1074,1,0,0,0,1120,1075,1,0,0,0,1120,1076,1,0,0,0,1120,
        1077,1,0,0,0,1120,1078,1,0,0,0,1120,1079,1,0,0,0,1120,1080,1,0,0,
        0,1120,1081,1,0,0,0,1120,1082,1,0,0,0,1120,1083,1,0,0,0,1120,1084,
        1,0,0,0,1120,1085,1,0,0,0,1120,1086,1,0,0,0,1120,1087,1,0,0,0,1120,
        1088,1,0,0,0,1120,1089,1,0,0,0,1120,1090,1,0,0,0,1120,1091,1,0,0,
        0,1120,1092,1,0,0,0,1120,1093,1,0,0,0,1120,1094,1,0,0,0,1120,1095,
        1,0,0,0,1120,1096,1,0,0,0,1120,1097,1,0,0,0,1120,1098,1,0,0,0,1120,
        1099,1,0,0,0,1120,1100,1,0,0,0,1120,1101,1,0,0,0,1120,1102,1,0,0,
        0,1120,1103,1,0,0,0,1120,1104,1,0,0,0,1120,1105,1,0,0,0,1120,1106,
        1,0,0,0,1120,1107,1,0,0,0,1120,1108,1,0,0,0,1120,1109,1,0,0,0,1120,
        1110,1,0,0,0,1120,1111,1,0,0,0,1120,1112,1,0,0,0,1120,1113,1,0,0,
        0,1120,1114,1,0,0,0,1120,1115,1,0,0,0,1120,1116,1,0,0,0,1120,1117,
        1,0,0,0,1120,1118,1,0,0,0,1120,1119,1,0,0,0,1121,59,1,0,0,0,1122,
        1123,5,284,0,0,1123,1124,5,313,0,0,1124,1125,3,548,274,0,1125,1126,
        5,314,0,0,1126,1133,1,0,0,0,1127,1128,5,284,0,0,1128,1129,5,313,
        0,0,1129,1130,3,54,27,0,1130,1131,5,314,0,0,1131,1133,1,0,0,0,1132,
        1122,1,0,0,0,1132,1127,1,0,0,0,1133,61,1,0,0,0,1134,1135,5,81,0,
        0,1135,1136,5,313,0,0,1136,1137,3,548,274,0,1137,1138,5,314,0,0,
        1138,1145,1,0,0,0,1139,1140,5,81,0,0,1140,1141,5,313,0,0,1141,1142,
        3,54,27,0,1142,1143,5,314,0,0,1143,1145,1,0,0,0,1144,1134,1,0,0,
        0,1144,1139,1,0,0,0,1145,63,1,0,0,0,1146,1147,5,2,0,0,1147,1148,
        5,313,0,0,1148,1149,3,536,268,0,1149,1150,5,314,0,0,1150,1157,1,
        0,0,0,1151,1152,5,2,0,0,1152,1153,5,313,0,0,1153,1154,3,54,27,0,
        1154,1155,5,314,0,0,1155,1157,1,0,0,0,1156,1146,1,0,0,0,1156,1151,
        1,0,0,0,1157,65,1,0,0,0,1158,1159,5,4,0,0,1159,1160,5,313,0,0,1160,
        1179,5,314,0,0,1161,1162,5,4,0,0,1162,1163,5,313,0,0,1163,1164,3,
        538,269,0,1164,1165,5,314,0,0,1165,1179,1,0,0,0,1166,1167,5,4,0,
        0,1167,1168,5,313,0,0,1168,1173,3,54,27,0,1169,1170,5,320,0,0,1170,
        1172,3,54,27,0,1171,1169,1,0,0,0,1172,1175,1,0,0,0,1173,1171,1,0,
        0,0,1173,1174,1,0,0,0,1174,1176,1,0,0,0,1175,1173,1,0,0,0,1176,1177,
        5,314,0,0,1177,1179,1,0,0,0,1178,1158,1,0,0,0,1178,1161,1,0,0,0,
        1178,1166,1,0,0,0,1179,67,1,0,0,0,1180,1181,5,5,0,0,1181,1182,5,
        313,0,0,1182,1183,3,592,296,0,1183,1184,5,314,0,0,1184,69,1,0,0,
        0,1185,1186,5,6,0,0,1186,1187,5,313,0,0,1187,1188,3,376,188,0,1188,
        1189,5,314,0,0,1189,71,1,0,0,0,1190,1191,5,7,0,0,1191,1192,5,313,
        0,0,1192,1193,3,564,282,0,1193,1194,5,314,0,0,1194,73,1,0,0,0,1195,
        1196,5,8,0,0,1196,1197,5,313,0,0,1197,1198,3,376,188,0,1198,1199,
        5,314,0,0,1199,75,1,0,0,0,1200,1201,5,9,0,0,1201,1202,5,313,0,0,
        1202,1205,3,592,296,0,1203,1204,5,320,0,0,1204,1206,3,580,290,0,
        1205,1203,1,0,0,0,1205,1206,1,0,0,0,1206,1207,1,0,0,0,1207,1208,
        5,314,0,0,1208,77,1,0,0,0,1209,1210,5,10,0,0,1210,1211,5,313,0,0,
        1211,1212,5,314,0,0,1212,79,1,0,0,0,1213,1214,5,12,0,0,1214,1215,
        5,313,0,0,1215,1216,5,314,0,0,1216,81,1,0,0,0,1217,1218,5,13,0,0,
        1218,1219,5,313,0,0,1219,1226,5,314,0,0,1220,1221,5,13,0,0,1221,
        1222,5,313,0,0,1222,1223,3,374,187,0,1223,1224,5,314,0,0,1224,1226,
        1,0,0,0,1225,1217,1,0,0,0,1225,1220,1,0,0,0,1226,83,1,0,0,0,1227,
        1228,5,14,0,0,1228,1229,5,313,0,0,1229,1236,5,314,0,0,1230,1231,
        5,14,0,0,1231,1232,5,313,0,0,1232,1233,3,342,171,0,1233,1234,5,314,
        0,0,1234,1236,1,0,0,0,1235,1227,1,0,0,0,1235,1230,1,0,0,0,1236,85,
        1,0,0,0,1237,1238,5,16,0,0,1238,1239,5,313,0,0,1239,1240,3,380,190,
        0,1240,1241,5,314,0,0,1241,1251,1,0,0,0,1242,1243,5,16,0,0,1243,
        1244,5,313,0,0,1244,1251,5,314,0,0,1245,1246,5,16,0,0,1246,1247,
        5,313,0,0,1247,1248,3,596,298,0,1248,1249,5,314,0,0,1249,1251,1,
        0,0,0,1250,1237,1,0,0,0,1250,1242,1,0,0,0,1250,1245,1,0,0,0,1251,
        87,1,0,0,0,1252,1253,5,29,0,0,1253,1254,5,313,0,0,1254,1255,3,542,
        271,0,1255,1256,5,314,0,0,1256,89,1,0,0,0,1257,1258,5,31,0,0,1258,
        1259,5,313,0,0,1259,1260,3,542,271,0,1260,1261,5,314,0,0,1261,91,
        1,0,0,0,1262,1263,5,32,0,0,1263,1264,5,313,0,0,1264,1265,5,314,0,
        0,1265,93,1,0,0,0,1266,1267,5,33,0,0,1267,1268,5,313,0,0,1268,1269,
        3,54,27,0,1269,1270,5,314,0,0,1270,95,1,0,0,0,1271,1272,5,34,0,0,
        1272,1273,5,313,0,0,1273,1274,3,382,191,0,1274,1275,5,314,0,0,1275,
        1326,1,0,0,0,1276,1277,5,34,0,0,1277,1278,5,313,0,0,1278,1326,5,
        314,0,0,1279,1280,5,34,0,0,1280,1281,5,313,0,0,1281,1282,3,384,192,
        0,1282,1283,5,314,0,0,1283,1326,1,0,0,0,1284,1285,5,34,0,0,1285,
        1286,5,313,0,0,1286,1287,3,384,192,0,1287,1288,5,320,0,0,1288,1289,
        3,382,191,0,1289,1290,5,314,0,0,1290,1326,1,0,0,0,1291,1292,5,34,
        0,0,1292,1293,5,313,0,0,1293,1294,3,354,177,0,1294,1295,5,314,0,
        0,1295,1326,1,0,0,0,1296,1297,5,34,0,0,1297,1298,5,313,0,0,1298,
        1299,3,592,296,0,1299,1300,5,314,0,0,1300,1326,1,0,0,0,1301,1302,
        5,34,0,0,1302,1303,5,313,0,0,1303,1304,3,592,296,0,1304,1305,5,320,
        0,0,1305,1306,3,382,191,0,1306,1307,5,314,0,0,1307,1326,1,0,0,0,
        1308,1309,5,34,0,0,1309,1310,5,313,0,0,1310,1311,3,346,173,0,1311,
        1312,5,314,0,0,1312,1326,1,0,0,0,1313,1314,5,34,0,0,1314,1315,5,
        313,0,0,1315,1316,3,54,27,0,1316,1317,5,314,0,0,1317,1326,1,0,0,
        0,1318,1319,5,34,0,0,1319,1320,5,313,0,0,1320,1321,3,54,27,0,1321,
        1322,5,320,0,0,1322,1323,3,382,191,0,1323,1324,5,314,0,0,1324,1326,
        1,0,0,0,1325,1271,1,0,0,0,1325,1276,1,0,0,0,1325,1279,1,0,0,0,1325,
        1284,1,0,0,0,1325,1291,1,0,0,0,1325,1296,1,0,0,0,1325,1301,1,0,0,
        0,1325,1308,1,0,0,0,1325,1313,1,0,0,0,1325,1318,1,0,0,0,1326,97,
        1,0,0,0,1327,1328,5,37,0,0,1328,1329,5,313,0,0,1329,1330,3,592,296,
        0,1330,1331,5,314,0,0,1331,1356,1,0,0,0,1332,1333,5,37,0,0,1333,
        1334,5,313,0,0,1334,1335,3,592,296,0,1335,1336,5,320,0,0,1336,1337,
        3,550,275,0,1337,1338,5,314,0,0,1338,1356,1,0,0,0,1339,1340,5,37,
        0,0,1340,1341,5,313,0,0,1341,1342,3,592,296,0,1342,1343,5,320,0,
        0,1343,1344,3,54,27,0,1344,1345,5,314,0,0,1345,1356,1,0,0,0,1346,
        1347,5,37,0,0,1347,1348,5,313,0,0,1348,1349,3,592,296,0,1349,1350,
        5,320,0,0,1350,1351,3,550,275,0,1351,1352,5,320,0,0,1352,1353,3,
        54,27,0,1353,1354,5,314,0,0,1354,1356,1,0,0,0,1355,1327,1,0,0,0,
        1355,1332,1,0,0,0,1355,1339,1,0,0,0,1355,1346,1,0,0,0,1356,99,1,
        0,0,0,1357,1358,5,38,0,0,1358,1359,5,313,0,0,1359,1362,3,592,296,
        0,1360,1361,5,320,0,0,1361,1363,3,580,290,0,1362,1360,1,0,0,0,1362,
        1363,1,0,0,0,1363,1364,1,0,0,0,1364,1365,5,314,0,0,1365,101,1,0,
        0,0,1366,1367,5,42,0,0,1367,1368,5,313,0,0,1368,1369,3,384,192,0,
        1369,1370,5,314,0,0,1370,1409,1,0,0,0,1371,1372,5,42,0,0,1372,1373,
        5,313,0,0,1373,1374,3,376,188,0,1374,1375,5,320,0,0,1375,1376,3,
        54,27,0,1376,1377,5,314,0,0,1377,1409,1,0,0,0,1378,1379,5,42,0,0,
        1379,1380,5,313,0,0,1380,1381,3,376,188,0,1381,1382,5,320,0,0,1382,
        1383,3,54,27,0,1383,1384,5,320,0,0,1384,1385,3,54,27,0,1385,1386,
        5,314,0,0,1386,1409,1,0,0,0,1387,1388,5,42,0,0,1388,1389,5,313,0,
        0,1389,1390,3,54,27,0,1390,1391,5,314,0,0,1391,1409,1,0,0,0,1392,
        1393,5,42,0,0,1393,1394,5,313,0,0,1394,1395,3,54,27,0,1395,1396,
        5,320,0,0,1396,1397,3,54,27,0,1397,1398,5,314,0,0,1398,1409,1,0,
        0,0,1399,1400,5,42,0,0,1400,1401,5,313,0,0,1401,1402,3,54,27,0,1402,
        1403,5,320,0,0,1403,1404,3,54,27,0,1404,1405,5,320,0,0,1405,1406,
        3,54,27,0,1406,1407,5,314,0,0,1407,1409,1,0,0,0,1408,1366,1,0,0,
        0,1408,1371,1,0,0,0,1408,1378,1,0,0,0,1408,1387,1,0,0,0,1408,1392,
        1,0,0,0,1408,1399,1,0,0,0,1409,103,1,0,0,0,1410,1411,5,43,0,0,1411,
        1412,5,313,0,0,1412,1413,3,564,282,0,1413,1414,5,314,0,0,1414,105,
        1,0,0,0,1415,1416,5,44,0,0,1416,1417,5,313,0,0,1417,1418,3,600,300,
        0,1418,1419,5,314,0,0,1419,107,1,0,0,0,1420,1421,5,46,0,0,1421,1422,
        5,313,0,0,1422,1423,3,584,292,0,1423,1424,5,314,0,0,1424,109,1,0,
        0,0,1425,1426,5,49,0,0,1426,1427,5,313,0,0,1427,1430,3,54,27,0,1428,
        1429,5,320,0,0,1429,1431,3,564,282,0,1430,1428,1,0,0,0,1430,1431,
        1,0,0,0,1431,1432,1,0,0,0,1432,1433,5,314,0,0,1433,1440,1,0,0,0,
        1434,1435,5,49,0,0,1435,1436,5,313,0,0,1436,1437,3,580,290,0,1437,
        1438,5,314,0,0,1438,1440,1,0,0,0,1439,1425,1,0,0,0,1439,1434,1,0,
        0,0,1440,111,1,0,0,0,1441,1442,5,50,0,0,1442,1443,5,313,0,0,1443,
        1444,3,592,296,0,1444,1445,5,314,0,0,1445,113,1,0,0,0,1446,1447,
        5,51,0,0,1447,1448,5,313,0,0,1448,1449,5,314,0,0,1449,115,1,0,0,
        0,1450,1451,5,53,0,0,1451,1452,5,313,0,0,1452,1453,3,584,292,0,1453,
        1454,5,314,0,0,1454,117,1,0,0,0,1455,1456,5,55,0,0,1456,1457,5,313,
        0,0,1457,1464,5,314,0,0,1458,1459,5,55,0,0,1459,1460,5,313,0,0,1460,
        1461,3,342,171,0,1461,1462,5,314,0,0,1462,1464,1,0,0,0,1463,1455,
        1,0,0,0,1463,1458,1,0,0,0,1464,119,1,0,0,0,1465,1466,5,56,0,0,1466,
        1467,5,313,0,0,1467,1468,5,314,0,0,1468,121,1,0,0,0,1469,1470,5,
        58,0,0,1470,1471,5,313,0,0,1471,1472,3,372,186,0,1472,1473,5,320,
        0,0,1473,1474,3,596,298,0,1474,1475,5,314,0,0,1475,123,1,0,0,0,1476,
        1477,5,59,0,0,1477,1478,5,313,0,0,1478,1479,3,54,27,0,1479,1480,
        5,314,0,0,1480,1487,1,0,0,0,1481,1482,5,59,0,0,1482,1483,5,313,0,
        0,1483,1484,3,604,302,0,1484,1485,5,314,0,0,1485,1487,1,0,0,0,1486,
        1476,1,0,0,0,1486,1481,1,0,0,0,1487,125,1,0,0,0,1488,1489,5,64,0,
        0,1489,1490,5,313,0,0,1490,1493,3,342,171,0,1491,1492,5,320,0,0,
        1492,1494,3,580,290,0,1493,1491,1,0,0,0,1493,1494,1,0,0,0,1494,1495,
        1,0,0,0,1495,1496,5,314,0,0,1496,1503,1,0,0,0,1497,1498,5,64,0,0,
        1498,1499,5,313,0,0,1499,1500,3,580,290,0,1500,1501,5,314,0,0,1501,
        1503,1,0,0,0,1502,1488,1,0,0,0,1502,1497,1,0,0,0,1503,127,1,0,0,
        0,1504,1505,5,66,0,0,1505,1506,5,313,0,0,1506,1507,3,584,292,0,1507,
        1508,5,314,0,0,1508,129,1,0,0,0,1509,1510,5,67,0,0,1510,1511,5,313,
        0,0,1511,1512,5,314,0,0,1512,131,1,0,0,0,1513,1514,5,69,0,0,1514,
        1515,5,313,0,0,1515,1516,3,584,292,0,1516,1517,5,314,0,0,1517,133,
        1,0,0,0,1518,1519,5,74,0,0,1519,1520,5,313,0,0,1520,1521,5,314,0,
        0,1521,135,1,0,0,0,1522,1523,5,86,0,0,1523,1524,5,313,0,0,1524,1525,
        5,314,0,0,1525,137,1,0,0,0,1526,1527,5,85,0,0,1527,1528,5,313,0,
        0,1528,1529,3,580,290,0,1529,1530,5,314,0,0,1530,139,1,0,0,0,1531,
        1532,5,87,0,0,1532,1533,5,313,0,0,1533,1545,5,314,0,0,1534,1535,
        5,87,0,0,1535,1536,5,313,0,0,1536,1537,3,376,188,0,1537,1538,5,314,
        0,0,1538,1545,1,0,0,0,1539,1540,5,87,0,0,1540,1541,5,313,0,0,1541,
        1542,3,54,27,0,1542,1543,5,314,0,0,1543,1545,1,0,0,0,1544,1531,1,
        0,0,0,1544,1534,1,0,0,0,1544,1539,1,0,0,0,1545,141,1,0,0,0,1546,
        1547,5,91,0,0,1547,1548,5,313,0,0,1548,1555,5,314,0,0,1549,1550,
        5,91,0,0,1550,1551,5,313,0,0,1551,1552,3,592,296,0,1552,1553,5,314,
        0,0,1553,1555,1,0,0,0,1554,1546,1,0,0,0,1554,1549,1,0,0,0,1555,143,
        1,0,0,0,1556,1557,5,93,0,0,1557,1558,5,313,0,0,1558,1559,3,376,188,
        0,1559,1560,5,314,0,0,1560,1567,1,0,0,0,1561,1562,5,93,0,0,1562,
        1563,5,313,0,0,1563,1564,3,54,27,0,1564,1565,5,314,0,0,1565,1567,
        1,0,0,0,1566,1556,1,0,0,0,1566,1561,1,0,0,0,1567,145,1,0,0,0,1568,
        1569,5,95,0,0,1569,1570,5,313,0,0,1570,1571,3,54,27,0,1571,1572,
        5,314,0,0,1572,147,1,0,0,0,1573,1574,5,98,0,0,1574,1575,5,313,0,
        0,1575,1584,5,314,0,0,1576,1577,5,98,0,0,1577,1578,5,313,0,0,1578,
        1579,3,584,292,0,1579,1580,5,320,0,0,1580,1581,3,386,193,0,1581,
        1582,5,314,0,0,1582,1584,1,0,0,0,1583,1573,1,0,0,0,1583,1576,1,0,
        0,0,1584,149,1,0,0,0,1585,1586,5,99,0,0,1586,1587,5,313,0,0,1587,
        1588,3,592,296,0,1588,1589,5,314,0,0,1589,151,1,0,0,0,1590,1591,
        5,100,0,0,1591,1592,5,313,0,0,1592,1593,3,592,296,0,1593,1594,5,
        314,0,0,1594,1601,1,0,0,0,1595,1596,5,100,0,0,1596,1597,5,313,0,
        0,1597,1598,3,54,27,0,1598,1599,5,314,0,0,1599,1601,1,0,0,0,1600,
        1590,1,0,0,0,1600,1595,1,0,0,0,1601,153,1,0,0,0,1602,1603,5,108,
        0,0,1603,1604,5,313,0,0,1604,1611,5,314,0,0,1605,1606,5,108,0,0,
        1606,1607,5,313,0,0,1607,1608,3,592,296,0,1608,1609,5,314,0,0,1609,
        1611,1,0,0,0,1610,1602,1,0,0,0,1610,1605,1,0,0,0,1611,155,1,0,0,
        0,1612,1613,5,107,0,0,1613,1614,5,313,0,0,1614,1621,5,314,0,0,1615,
        1616,5,107,0,0,1616,1617,5,313,0,0,1617,1618,3,592,296,0,1618,1619,
        5,314,0,0,1619,1621,1,0,0,0,1620,1612,1,0,0,0,1620,1615,1,0,0,0,
        1621,157,1,0,0,0,1622,1623,5,112,0,0,1623,1624,5,313,0,0,1624,1625,
        3,594,297,0,1625,1626,5,314,0,0,1626,1697,1,0,0,0,1627,1628,5,112,
        0,0,1628,1629,5,313,0,0,1629,1630,3,594,297,0,1630,1631,5,320,0,
        0,1631,1632,3,546,273,0,1632,1633,5,314,0,0,1633,1697,1,0,0,0,1634,
        1635,5,112,0,0,1635,1636,5,313,0,0,1636,1637,3,594,297,0,1637,1638,
        5,320,0,0,1638,1639,3,376,188,0,1639,1640,5,314,0,0,1640,1697,1,
        0,0,0,1641,1642,5,112,0,0,1642,1643,5,313,0,0,1643,1644,3,594,297,
        0,1644,1645,5,320,0,0,1645,1646,3,54,27,0,1646,1647,5,314,0,0,1647,
        1697,1,0,0,0,1648,1649,5,112,0,0,1649,1650,5,313,0,0,1650,1651,3,
        540,270,0,1651,1652,5,320,0,0,1652,1653,3,594,297,0,1653,1654,5,
        320,0,0,1654,1655,3,546,273,0,1655,1656,5,314,0,0,1656,1697,1,0,
        0,0,1657,1658,5,112,0,0,1658,1659,5,313,0,0,1659,1660,3,540,270,
        0,1660,1661,5,320,0,0,1661,1662,3,594,297,0,1662,1663,5,320,0,0,
        1663,1664,3,376,188,0,1664,1665,5,314,0,0,1665,1697,1,0,0,0,1666,
        1667,5,112,0,0,1667,1668,5,313,0,0,1668,1669,3,540,270,0,1669,1670,
        5,320,0,0,1670,1671,3,594,297,0,1671,1672,5,320,0,0,1672,1673,3,
        54,27,0,1673,1674,5,314,0,0,1674,1697,1,0,0,0,1675,1676,5,112,0,
        0,1676,1677,5,313,0,0,1677,1678,3,346,173,0,1678,1679,5,320,0,0,
        1679,1680,3,546,273,0,1680,1681,5,314,0,0,1681,1697,1,0,0,0,1682,
        1683,5,112,0,0,1683,1684,5,313,0,0,1684,1685,3,346,173,0,1685,1686,
        5,320,0,0,1686,1687,3,376,188,0,1687,1688,5,314,0,0,1688,1697,1,
        0,0,0,1689,1690,5,112,0,0,1690,1691,5,313,0,0,1691,1692,3,346,173,
        0,1692,1693,5,320,0,0,1693,1694,3,54,27,0,1694,1695,5,314,0,0,1695,
        1697,1,0,0,0,1696,1622,1,0,0,0,1696,1627,1,0,0,0,1696,1634,1,0,0,
        0,1696,1641,1,0,0,0,1696,1648,1,0,0,0,1696,1657,1,0,0,0,1696,1666,
        1,0,0,0,1696,1675,1,0,0,0,1696,1682,1,0,0,0,1696,1689,1,0,0,0,1697,
        159,1,0,0,0,1698,1699,5,113,0,0,1699,1700,5,313,0,0,1700,1703,3,
        546,273,0,1701,1702,5,320,0,0,1702,1704,3,548,274,0,1703,1701,1,
        0,0,0,1703,1704,1,0,0,0,1704,1705,1,0,0,0,1705,1706,5,314,0,0,1706,
        1713,1,0,0,0,1707,1708,5,113,0,0,1708,1709,5,313,0,0,1709,1710,3,
        376,188,0,1710,1711,5,314,0,0,1711,1713,1,0,0,0,1712,1698,1,0,0,
        0,1712,1707,1,0,0,0,1713,161,1,0,0,0,1714,1715,5,114,0,0,1715,1716,
        5,313,0,0,1716,1717,3,376,188,0,1717,1718,5,314,0,0,1718,1734,1,
        0,0,0,1719,1720,5,114,0,0,1720,1721,5,313,0,0,1721,1724,3,594,297,
        0,1722,1723,5,320,0,0,1723,1725,3,580,290,0,1724,1722,1,0,0,0,1724,
        1725,1,0,0,0,1725,1726,1,0,0,0,1726,1727,5,314,0,0,1727,1734,1,0,
        0,0,1728,1729,5,114,0,0,1729,1730,5,313,0,0,1730,1731,3,54,27,0,
        1731,1732,5,314,0,0,1732,1734,1,0,0,0,1733,1714,1,0,0,0,1733,1719,
        1,0,0,0,1733,1728,1,0,0,0,1734,163,1,0,0,0,1735,1736,5,115,0,0,1736,
        1737,5,313,0,0,1737,1738,3,376,188,0,1738,1739,5,314,0,0,1739,1755,
        1,0,0,0,1740,1741,5,115,0,0,1741,1742,5,313,0,0,1742,1745,3,540,
        270,0,1743,1744,5,320,0,0,1744,1746,3,542,271,0,1745,1743,1,0,0,
        0,1745,1746,1,0,0,0,1746,1747,1,0,0,0,1747,1748,5,314,0,0,1748,1755,
        1,0,0,0,1749,1750,5,115,0,0,1750,1751,5,313,0,0,1751,1752,3,54,27,
        0,1752,1753,5,314,0,0,1753,1755,1,0,0,0,1754,1735,1,0,0,0,1754,1740,
        1,0,0,0,1754,1749,1,0,0,0,1755,165,1,0,0,0,1756,1757,5,117,0,0,1757,
        1758,5,313,0,0,1758,1759,3,594,297,0,1759,1760,5,314,0,0,1760,167,
        1,0,0,0,1761,1762,5,118,0,0,1762,1763,5,313,0,0,1763,1766,3,546,
        273,0,1764,1765,5,320,0,0,1765,1767,3,548,274,0,1766,1764,1,0,0,
        0,1766,1767,1,0,0,0,1767,1768,1,0,0,0,1768,1769,5,314,0,0,1769,1781,
        1,0,0,0,1770,1771,5,118,0,0,1771,1772,5,313,0,0,1772,1773,3,376,
        188,0,1773,1774,5,314,0,0,1774,1781,1,0,0,0,1775,1776,5,118,0,0,
        1776,1777,5,313,0,0,1777,1778,3,54,27,0,1778,1779,5,314,0,0,1779,
        1781,1,0,0,0,1780,1761,1,0,0,0,1780,1770,1,0,0,0,1780,1775,1,0,0,
        0,1781,169,1,0,0,0,1782,1783,5,120,0,0,1783,1784,5,313,0,0,1784,
        1785,5,314,0,0,1785,171,1,0,0,0,1786,1787,5,121,0,0,1787,1788,5,
        313,0,0,1788,1789,5,314,0,0,1789,173,1,0,0,0,1790,1791,5,123,0,0,
        1791,1792,5,313,0,0,1792,1793,3,542,271,0,1793,1794,5,314,0,0,1794,
        175,1,0,0,0,1795,1796,5,125,0,0,1796,1797,5,313,0,0,1797,1798,3,
        542,271,0,1798,1799,5,314,0,0,1799,177,1,0,0,0,1800,1801,5,135,0,
        0,1801,1802,5,313,0,0,1802,1803,3,584,292,0,1803,1804,5,314,0,0,
        1804,179,1,0,0,0,1805,1806,5,136,0,0,1806,1807,5,313,0,0,1807,1808,
        5,314,0,0,1808,181,1,0,0,0,1809,1810,5,129,0,0,1810,1811,5,313,0,
        0,1811,1812,5,314,0,0,1812,183,1,0,0,0,1813,1814,5,131,0,0,1814,
        1815,5,313,0,0,1815,1816,3,570,285,0,1816,1817,5,314,0,0,1817,185,
        1,0,0,0,1818,1819,5,139,0,0,1819,1820,5,313,0,0,1820,1821,3,546,
        273,0,1821,1822,5,314,0,0,1822,1829,1,0,0,0,1823,1824,5,139,0,0,
        1824,1825,5,313,0,0,1825,1826,3,376,188,0,1826,1827,5,314,0,0,1827,
        1829,1,0,0,0,1828,1818,1,0,0,0,1828,1823,1,0,0,0,1829,187,1,0,0,
        0,1830,1831,5,141,0,0,1831,1832,5,313,0,0,1832,1833,5,314,0,0,1833,
        189,1,0,0,0,1834,1835,5,144,0,0,1835,1836,5,313,0,0,1836,1837,5,
        314,0,0,1837,191,1,0,0,0,1838,1839,5,143,0,0,1839,1840,5,313,0,0,
        1840,1841,5,314,0,0,1841,193,1,0,0,0,1842,1843,5,3,0,0,1843,1844,
        5,313,0,0,1844,1845,3,582,291,0,1845,1846,5,314,0,0,1846,1860,1,
        0,0,0,1847,1848,5,3,0,0,1848,1849,5,313,0,0,1849,1854,3,54,27,0,
        1850,1851,5,320,0,0,1851,1853,3,54,27,0,1852,1850,1,0,0,0,1853,1856,
        1,0,0,0,1854,1852,1,0,0,0,1854,1855,1,0,0,0,1855,1857,1,0,0,0,1856,
        1854,1,0,0,0,1857,1858,5,314,0,0,1858,1860,1,0,0,0,1859,1842,1,0,
        0,0,1859,1847,1,0,0,0,1860,195,1,0,0,0,1861,1862,5,76,0,0,1862,1863,
        5,313,0,0,1863,1864,5,314,0,0,1864,197,1,0,0,0,1865,1866,5,75,0,
        0,1866,1867,5,313,0,0,1867,1868,3,582,291,0,1868,1869,5,314,0,0,
        1869,1883,1,0,0,0,1870,1871,5,75,0,0,1871,1872,5,313,0,0,1872,1877,
        3,54,27,0,1873,1874,5,320,0,0,1874,1876,3,54,27,0,1875,1873,1,0,
        0,0,1876,1879,1,0,0,0,1877,1875,1,0,0,0,1877,1878,1,0,0,0,1878,1880,
        1,0,0,0,1879,1877,1,0,0,0,1880,1881,5,314,0,0,1881,1883,1,0,0,0,
        1882,1865,1,0,0,0,1882,1870,1,0,0,0,1883,199,1,0,0,0,1884,1885,5,
        146,0,0,1885,1886,5,313,0,0,1886,1893,5,314,0,0,1887,1888,5,146,
        0,0,1888,1889,5,313,0,0,1889,1890,3,342,171,0,1890,1891,5,314,0,
        0,1891,1893,1,0,0,0,1892,1884,1,0,0,0,1892,1887,1,0,0,0,1893,201,
        1,0,0,0,1894,1895,5,147,0,0,1895,1896,5,313,0,0,1896,1897,3,342,
        171,0,1897,1898,5,320,0,0,1898,1899,3,534,267,0,1899,1900,5,314,
        0,0,1900,1907,1,0,0,0,1901,1902,5,147,0,0,1902,1903,5,313,0,0,1903,
        1904,3,534,267,0,1904,1905,5,314,0,0,1905,1907,1,0,0,0,1906,1894,
        1,0,0,0,1906,1901,1,0,0,0,1907,203,1,0,0,0,1908,1909,5,150,0,0,1909,
        1910,5,313,0,0,1910,1911,3,54,27,0,1911,1912,5,314,0,0,1912,205,
        1,0,0,0,1913,1914,5,153,0,0,1914,1915,5,313,0,0,1915,1922,5,314,
        0,0,1916,1917,5,153,0,0,1917,1918,5,313,0,0,1918,1919,3,592,296,
        0,1919,1920,5,314,0,0,1920,1922,1,0,0,0,1921,1913,1,0,0,0,1921,1916,
        1,0,0,0,1922,207,1,0,0,0,1923,1924,5,156,0,0,1924,1925,5,313,0,0,
        1925,1932,5,314,0,0,1926,1927,5,156,0,0,1927,1928,5,313,0,0,1928,
        1929,3,342,171,0,1929,1930,5,314,0,0,1930,1932,1,0,0,0,1931,1923,
        1,0,0,0,1931,1926,1,0,0,0,1932,209,1,0,0,0,1933,1934,5,157,0,0,1934,
        1935,5,313,0,0,1935,1936,3,54,27,0,1936,1937,5,314,0,0,1937,211,
        1,0,0,0,1938,1939,5,159,0,0,1939,1940,5,313,0,0,1940,1941,3,564,
        282,0,1941,1942,5,314,0,0,1942,1956,1,0,0,0,1943,1944,5,159,0,0,
        1944,1945,5,313,0,0,1945,1946,3,592,296,0,1946,1947,5,314,0,0,1947,
        1956,1,0,0,0,1948,1949,5,159,0,0,1949,1950,5,313,0,0,1950,1951,3,
        592,296,0,1951,1952,5,320,0,0,1952,1953,3,586,293,0,1953,1954,5,
        314,0,0,1954,1956,1,0,0,0,1955,1938,1,0,0,0,1955,1943,1,0,0,0,1955,
        1948,1,0,0,0,1956,213,1,0,0,0,1957,1958,5,160,0,0,1958,1959,5,313,
        0,0,1959,1960,3,592,296,0,1960,1961,5,314,0,0,1961,215,1,0,0,0,1962,
        1963,5,161,0,0,1963,1964,5,313,0,0,1964,1971,5,314,0,0,1965,1966,
        5,161,0,0,1966,1967,5,313,0,0,1967,1968,3,342,171,0,1968,1969,5,
        314,0,0,1969,1971,1,0,0,0,1970,1962,1,0,0,0,1970,1965,1,0,0,0,1971,
        217,1,0,0,0,1972,1973,5,163,0,0,1973,1974,5,313,0,0,1974,1981,5,
        314,0,0,1975,1976,5,163,0,0,1976,1977,5,313,0,0,1977,1978,3,342,
        171,0,1978,1979,5,314,0,0,1979,1981,1,0,0,0,1980,1972,1,0,0,0,1980,
        1975,1,0,0,0,1981,219,1,0,0,0,1982,1983,5,165,0,0,1983,1984,5,313,
        0,0,1984,1985,3,584,292,0,1985,1986,5,314,0,0,1986,221,1,0,0,0,1987,
        1988,5,167,0,0,1988,1989,5,313,0,0,1989,2001,5,314,0,0,1990,1991,
        5,167,0,0,1991,1992,5,313,0,0,1992,1993,3,552,276,0,1993,1994,5,
        314,0,0,1994,2001,1,0,0,0,1995,1996,5,167,0,0,1996,1997,5,313,0,
        0,1997,1998,3,54,27,0,1998,1999,5,314,0,0,1999,2001,1,0,0,0,2000,
        1987,1,0,0,0,2000,1990,1,0,0,0,2000,1995,1,0,0,0,2001,223,1,0,0,
        0,2002,2003,5,166,0,0,2003,2004,5,313,0,0,2004,2016,5,314,0,0,2005,
        2006,5,166,0,0,2006,2007,5,313,0,0,2007,2008,3,552,276,0,2008,2009,
        5,314,0,0,2009,2016,1,0,0,0,2010,2011,5,166,0,0,2011,2012,5,313,
        0,0,2012,2013,3,54,27,0,2013,2014,5,314,0,0,2014,2016,1,0,0,0,2015,
        2002,1,0,0,0,2015,2005,1,0,0,0,2015,2010,1,0,0,0,2016,225,1,0,0,
        0,2017,2018,5,168,0,0,2018,2019,5,313,0,0,2019,2026,5,314,0,0,2020,
        2021,5,168,0,0,2021,2022,5,313,0,0,2022,2023,3,342,171,0,2023,2024,
        5,314,0,0,2024,2026,1,0,0,0,2025,2017,1,0,0,0,2025,2020,1,0,0,0,
        2026,227,1,0,0,0,2027,2028,5,177,0,0,2028,2029,5,313,0,0,2029,2030,
        3,376,188,0,2030,2031,5,314,0,0,2031,229,1,0,0,0,2032,2033,5,182,
        0,0,2033,2034,5,313,0,0,2034,2035,3,54,27,0,2035,2036,5,314,0,0,
        2036,231,1,0,0,0,2037,2038,5,193,0,0,2038,2039,5,313,0,0,2039,2040,
        3,376,188,0,2040,2041,5,320,0,0,2041,2042,3,54,27,0,2042,2043,5,
        314,0,0,2043,2080,1,0,0,0,2044,2045,5,193,0,0,2045,2046,5,313,0,
        0,2046,2047,3,352,176,0,2047,2048,5,320,0,0,2048,2049,3,552,276,
        0,2049,2050,5,314,0,0,2050,2080,1,0,0,0,2051,2052,5,193,0,0,2052,
        2053,5,313,0,0,2053,2054,3,352,176,0,2054,2055,5,320,0,0,2055,2056,
        3,552,276,0,2056,2057,5,320,0,0,2057,2058,3,362,181,0,2058,2059,
        5,314,0,0,2059,2080,1,0,0,0,2060,2061,5,193,0,0,2061,2062,5,313,
        0,0,2062,2063,3,352,176,0,2063,2064,5,320,0,0,2064,2065,3,54,27,
        0,2065,2066,5,314,0,0,2066,2080,1,0,0,0,2067,2068,5,193,0,0,2068,
        2069,5,313,0,0,2069,2070,3,546,273,0,2070,2071,5,320,0,0,2071,2072,
        3,54,27,0,2072,2073,5,314,0,0,2073,2080,1,0,0,0,2074,2075,5,193,
        0,0,2075,2076,5,313,0,0,2076,2077,3,54,27,0,2077,2078,5,314,0,0,
        2078,2080,1,0,0,0,2079,2037,1,0,0,0,2079,2044,1,0,0,0,2079,2051,
        1,0,0,0,2079,2060,1,0,0,0,2079,2067,1,0,0,0,2079,2074,1,0,0,0,2080,
        233,1,0,0,0,2081,2082,5,194,0,0,2082,2083,5,313,0,0,2083,2084,3,
        54,27,0,2084,2085,5,314,0,0,2085,235,1,0,0,0,2086,2087,5,197,0,0,
        2087,2088,5,313,0,0,2088,2089,3,564,282,0,2089,2090,5,314,0,0,2090,
        237,1,0,0,0,2091,2092,5,196,0,0,2092,2093,5,313,0,0,2093,2100,5,
        314,0,0,2094,2095,5,196,0,0,2095,2096,5,313,0,0,2096,2097,3,342,
        171,0,2097,2098,5,314,0,0,2098,2100,1,0,0,0,2099,2091,1,0,0,0,2099,
        2094,1,0,0,0,2100,239,1,0,0,0,2101,2102,5,198,0,0,2102,2103,5,313,
        0,0,2103,2104,5,314,0,0,2104,241,1,0,0,0,2105,2106,5,200,0,0,2106,
        2107,5,313,0,0,2107,2108,3,542,271,0,2108,2109,5,314,0,0,2109,243,
        1,0,0,0,2110,2111,5,201,0,0,2111,2112,5,313,0,0,2112,2113,3,542,
        271,0,2113,2114,5,314,0,0,2114,245,1,0,0,0,2115,2116,5,203,0,0,2116,
        2117,5,313,0,0,2117,2118,5,314,0,0,2118,247,1,0,0,0,2119,2120,5,
        206,0,0,2120,2121,5,313,0,0,2121,2128,5,314,0,0,2122,2123,5,206,
        0,0,2123,2124,5,313,0,0,2124,2125,3,600,300,0,2125,2126,5,314,0,
        0,2126,2128,1,0,0,0,2127,2119,1,0,0,0,2127,2122,1,0,0,0,2128,249,
        1,0,0,0,2129,2130,5,207,0,0,2130,2131,5,313,0,0,2131,2132,5,314,
        0,0,2132,251,1,0,0,0,2133,2134,5,211,0,0,2134,2135,5,313,0,0,2135,
        2136,5,314,0,0,2136,253,1,0,0,0,2137,2138,5,221,0,0,2138,2139,5,
        313,0,0,2139,2140,3,584,292,0,2140,2141,5,314,0,0,2141,255,1,0,0,
        0,2142,2143,5,214,0,0,2143,2144,5,313,0,0,2144,2151,5,314,0,0,2145,
        2146,5,214,0,0,2146,2147,5,313,0,0,2147,2148,3,592,296,0,2148,2149,
        5,314,0,0,2149,2151,1,0,0,0,2150,2142,1,0,0,0,2150,2145,1,0,0,0,
        2151,257,1,0,0,0,2152,2153,5,215,0,0,2153,2154,5,313,0,0,2154,2157,
        3,592,296,0,2155,2156,5,320,0,0,2156,2158,3,580,290,0,2157,2155,
        1,0,0,0,2157,2158,1,0,0,0,2158,2159,1,0,0,0,2159,2160,5,314,0,0,
        2160,259,1,0,0,0,2161,2162,5,216,0,0,2162,2163,5,313,0,0,2163,2164,
        3,580,290,0,2164,2165,5,314,0,0,2165,261,1,0,0,0,2166,2167,5,219,
        0,0,2167,2168,5,313,0,0,2168,2169,3,362,181,0,2169,2170,5,320,0,
        0,2170,2171,3,584,292,0,2171,2172,5,320,0,0,2172,2175,3,546,273,
        0,2173,2174,5,320,0,0,2174,2176,3,548,274,0,2175,2173,1,0,0,0,2175,
        2176,1,0,0,0,2176,2177,1,0,0,0,2177,2178,5,314,0,0,2178,2224,1,0,
        0,0,2179,2180,5,219,0,0,2180,2181,5,313,0,0,2181,2182,3,362,181,
        0,2182,2183,5,320,0,0,2183,2184,3,584,292,0,2184,2185,5,320,0,0,
        2185,2186,3,54,27,0,2186,2187,5,314,0,0,2187,2224,1,0,0,0,2188,2189,
        5,219,0,0,2189,2190,5,313,0,0,2190,2191,3,362,181,0,2191,2192,5,
        320,0,0,2192,2193,3,552,276,0,2193,2194,5,314,0,0,2194,2224,1,0,
        0,0,2195,2196,5,219,0,0,2196,2197,5,313,0,0,2197,2198,3,584,292,
        0,2198,2199,5,320,0,0,2199,2202,3,546,273,0,2200,2201,5,320,0,0,
        2201,2203,3,548,274,0,2202,2200,1,0,0,0,2202,2203,1,0,0,0,2203,2204,
        1,0,0,0,2204,2205,5,314,0,0,2205,2224,1,0,0,0,2206,2207,5,219,0,
        0,2207,2208,5,313,0,0,2208,2209,3,584,292,0,2209,2210,5,320,0,0,
        2210,2211,3,54,27,0,2211,2212,5,314,0,0,2212,2224,1,0,0,0,2213,2214,
        5,219,0,0,2214,2215,5,313,0,0,2215,2216,3,552,276,0,2216,2217,5,
        314,0,0,2217,2224,1,0,0,0,2218,2219,5,219,0,0,2219,2220,5,313,0,
        0,2220,2221,3,54,27,0,2221,2222,5,314,0,0,2222,2224,1,0,0,0,2223,
        2166,1,0,0,0,2223,2179,1,0,0,0,2223,2188,1,0,0,0,2223,2195,1,0,0,
        0,2223,2206,1,0,0,0,2223,2213,1,0,0,0,2223,2218,1,0,0,0,2224,263,
        1,0,0,0,2225,2226,5,217,0,0,2226,2227,5,313,0,0,2227,2228,3,580,
        290,0,2228,2229,5,314,0,0,2229,265,1,0,0,0,2230,2231,5,222,0,0,2231,
        2232,5,313,0,0,2232,2233,3,342,171,0,2233,2234,5,320,0,0,2234,2235,
        3,534,267,0,2235,2236,5,320,0,0,2236,2237,3,534,267,0,2237,2238,
        5,314,0,0,2238,2247,1,0,0,0,2239,2240,5,222,0,0,2240,2241,5,313,
        0,0,2241,2242,3,534,267,0,2242,2243,5,320,0,0,2243,2244,3,534,267,
        0,2244,2245,5,314,0,0,2245,2247,1,0,0,0,2246,2230,1,0,0,0,2246,2239,
        1,0,0,0,2247,267,1,0,0,0,2248,2249,5,223,0,0,2249,2250,5,313,0,0,
        2250,2251,5,314,0,0,2251,269,1,0,0,0,2252,2253,5,227,0,0,2253,2254,
        5,313,0,0,2254,2255,3,592,296,0,2255,2256,5,320,0,0,2256,2257,3,
        54,27,0,2257,2258,5,314,0,0,2258,2265,1,0,0,0,2259,2260,5,227,0,
        0,2260,2261,5,313,0,0,2261,2262,3,54,27,0,2262,2263,5,314,0,0,2263,
        2265,1,0,0,0,2264,2252,1,0,0,0,2264,2259,1,0,0,0,2265,271,1,0,0,
        0,2266,2267,5,226,0,0,2267,2268,5,313,0,0,2268,2269,3,594,297,0,
        2269,2270,5,320,0,0,2270,2271,3,594,297,0,2271,2272,5,314,0,0,2272,
        2283,1,0,0,0,2273,2274,5,226,0,0,2274,2275,5,313,0,0,2275,2276,3,
        342,171,0,2276,2277,5,320,0,0,2277,2278,3,594,297,0,2278,2279,5,
        320,0,0,2279,2280,3,594,297,0,2280,2281,5,314,0,0,2281,2283,1,0,
        0,0,2282,2266,1,0,0,0,2282,2273,1,0,0,0,2283,273,1,0,0,0,2284,2285,
        5,228,0,0,2285,2286,5,313,0,0,2286,2287,5,314,0,0,2287,275,1,0,0,
        0,2288,2289,5,230,0,0,2289,2290,5,313,0,0,2290,2297,5,314,0,0,2291,
        2292,5,230,0,0,2292,2293,5,313,0,0,2293,2294,3,342,171,0,2294,2295,
        5,314,0,0,2295,2297,1,0,0,0,2296,2288,1,0,0,0,2296,2291,1,0,0,0,
        2297,277,1,0,0,0,2298,2299,5,231,0,0,2299,2300,5,313,0,0,2300,2301,
        3,386,193,0,2301,2302,5,314,0,0,2302,2307,1,0,0,0,2303,2304,5,231,
        0,0,2304,2305,5,313,0,0,2305,2307,5,314,0,0,2306,2298,1,0,0,0,2306,
        2303,1,0,0,0,2307,279,1,0,0,0,2308,2309,5,232,0,0,2309,2310,5,313,
        0,0,2310,2311,3,342,171,0,2311,2312,5,320,0,0,2312,2313,3,596,298,
        0,2313,2314,5,314,0,0,2314,2321,1,0,0,0,2315,2316,5,232,0,0,2316,
        2317,5,313,0,0,2317,2318,3,596,298,0,2318,2319,5,314,0,0,2319,2321,
        1,0,0,0,2320,2308,1,0,0,0,2320,2315,1,0,0,0,2321,281,1,0,0,0,2322,
        2323,5,235,0,0,2323,2324,5,313,0,0,2324,2325,3,364,182,0,2325,2326,
        5,314,0,0,2326,2376,1,0,0,0,2327,2328,5,235,0,0,2328,2329,5,313,
        0,0,2329,2330,3,366,183,0,2330,2331,5,320,0,0,2331,2332,3,592,296,
        0,2332,2333,5,314,0,0,2333,2376,1,0,0,0,2334,2335,5,235,0,0,2335,
        2336,5,313,0,0,2336,2337,3,366,183,0,2337,2338,5,320,0,0,2338,2339,
        3,592,296,0,2339,2340,5,320,0,0,2340,2343,3,592,296,0,2341,2342,
        5,320,0,0,2342,2344,3,580,290,0,2343,2341,1,0,0,0,2343,2344,1,0,
        0,0,2344,2345,1,0,0,0,2345,2346,5,314,0,0,2346,2376,1,0,0,0,2347,
        2348,5,235,0,0,2348,2349,5,313,0,0,2349,2350,3,366,183,0,2350,2351,
        5,320,0,0,2351,2352,3,54,27,0,2352,2353,5,314,0,0,2353,2376,1,0,
        0,0,2354,2355,5,235,0,0,2355,2356,5,313,0,0,2356,2357,3,592,296,
        0,2357,2358,5,314,0,0,2358,2376,1,0,0,0,2359,2360,5,235,0,0,2360,
        2361,5,313,0,0,2361,2362,3,592,296,0,2362,2363,5,320,0,0,2363,2366,
        3,592,296,0,2364,2365,5,320,0,0,2365,2367,3,580,290,0,2366,2364,
        1,0,0,0,2366,2367,1,0,0,0,2367,2368,1,0,0,0,2368,2369,5,314,0,0,
        2369,2376,1,0,0,0,2370,2371,5,235,0,0,2371,2372,5,313,0,0,2372,2373,
        3,54,27,0,2373,2374,5,314,0,0,2374,2376,1,0,0,0,2375,2322,1,0,0,
        0,2375,2327,1,0,0,0,2375,2334,1,0,0,0,2375,2347,1,0,0,0,2375,2354,
        1,0,0,0,2375,2359,1,0,0,0,2375,2370,1,0,0,0,2376,283,1,0,0,0,2377,
        2378,5,239,0,0,2378,2379,5,313,0,0,2379,2380,5,314,0,0,2380,285,
        1,0,0,0,2381,2382,5,243,0,0,2382,2383,5,313,0,0,2383,2384,3,54,27,
        0,2384,2385,5,314,0,0,2385,287,1,0,0,0,2386,2387,5,244,0,0,2387,
        2388,5,313,0,0,2388,2389,5,314,0,0,2389,289,1,0,0,0,2390,2391,5,
        246,0,0,2391,2392,5,313,0,0,2392,2393,3,342,171,0,2393,2394,5,320,
        0,0,2394,2395,3,534,267,0,2395,2396,5,314,0,0,2396,2403,1,0,0,0,
        2397,2398,5,246,0,0,2398,2399,5,313,0,0,2399,2400,3,534,267,0,2400,
        2401,5,314,0,0,2401,2403,1,0,0,0,2402,2390,1,0,0,0,2402,2397,1,0,
        0,0,2403,291,1,0,0,0,2404,2405,5,247,0,0,2405,2406,5,313,0,0,2406,
        2407,3,594,297,0,2407,2408,5,314,0,0,2408,2417,1,0,0,0,2409,2410,
        5,247,0,0,2410,2411,5,313,0,0,2411,2412,3,342,171,0,2412,2413,5,
        320,0,0,2413,2414,3,594,297,0,2414,2415,5,314,0,0,2415,2417,1,0,
        0,0,2416,2404,1,0,0,0,2416,2409,1,0,0,0,2417,293,1,0,0,0,2418,2419,
        5,251,0,0,2419,2420,5,313,0,0,2420,2421,3,592,296,0,2421,2422,5,
        314,0,0,2422,295,1,0,0,0,2423,2424,5,252,0,0,2424,2425,5,313,0,0,
        2425,2426,3,596,298,0,2426,2427,5,314,0,0,2427,2452,1,0,0,0,2428,
        2429,5,252,0,0,2429,2430,5,313,0,0,2430,2431,3,342,171,0,2431,2432,
        5,320,0,0,2432,2433,3,596,298,0,2433,2434,5,314,0,0,2434,2452,1,
        0,0,0,2435,2436,5,252,0,0,2436,2437,5,313,0,0,2437,2438,3,596,298,
        0,2438,2439,5,320,0,0,2439,2440,3,596,298,0,2440,2441,5,314,0,0,
        2441,2452,1,0,0,0,2442,2443,5,252,0,0,2443,2444,5,313,0,0,2444,2445,
        3,342,171,0,2445,2446,5,320,0,0,2446,2447,3,596,298,0,2447,2448,
        5,320,0,0,2448,2449,3,596,298,0,2449,2450,5,314,0,0,2450,2452,1,
        0,0,0,2451,2423,1,0,0,0,2451,2428,1,0,0,0,2451,2435,1,0,0,0,2451,
        2442,1,0,0,0,2452,297,1,0,0,0,2453,2454,5,253,0,0,2454,2455,5,313,
        0,0,2455,2462,5,314,0,0,2456,2457,5,253,0,0,2457,2458,5,313,0,0,
        2458,2459,3,342,171,0,2459,2460,5,314,0,0,2460,2462,1,0,0,0,2461,
        2453,1,0,0,0,2461,2456,1,0,0,0,2462,299,1,0,0,0,2463,2464,5,256,
        0,0,2464,2465,5,313,0,0,2465,2484,5,314,0,0,2466,2467,5,256,0,0,
        2467,2468,5,313,0,0,2468,2469,3,342,171,0,2469,2470,5,314,0,0,2470,
        2484,1,0,0,0,2471,2472,5,256,0,0,2472,2473,5,313,0,0,2473,2474,3,
        342,171,0,2474,2475,5,320,0,0,2475,2476,3,534,267,0,2476,2477,5,
        314,0,0,2477,2484,1,0,0,0,2478,2479,5,256,0,0,2479,2480,5,313,0,
        0,2480,2481,3,534,267,0,2481,2482,5,314,0,0,2482,2484,1,0,0,0,2483,
        2463,1,0,0,0,2483,2466,1,0,0,0,2483,2471,1,0,0,0,2483,2478,1,0,0,
        0,2484,301,1,0,0,0,2485,2486,5,259,0,0,2486,2487,5,313,0,0,2487,
        2488,3,596,298,0,2488,2489,5,314,0,0,2489,303,1,0,0,0,2490,2491,
        5,260,0,0,2491,2492,5,313,0,0,2492,2493,3,596,298,0,2493,2494,5,
        314,0,0,2494,305,1,0,0,0,2495,2496,5,261,0,0,2496,2497,5,313,0,0,
        2497,2500,3,356,178,0,2498,2499,5,320,0,0,2499,2501,3,542,271,0,
        2500,2498,1,0,0,0,2500,2501,1,0,0,0,2501,2502,1,0,0,0,2502,2503,
        5,314,0,0,2503,2515,1,0,0,0,2504,2505,5,261,0,0,2505,2506,5,313,
        0,0,2506,2507,3,592,296,0,2507,2508,5,314,0,0,2508,2515,1,0,0,0,
        2509,2510,5,261,0,0,2510,2511,5,313,0,0,2511,2512,3,54,27,0,2512,
        2513,5,314,0,0,2513,2515,1,0,0,0,2514,2495,1,0,0,0,2514,2504,1,0,
        0,0,2514,2509,1,0,0,0,2515,307,1,0,0,0,2516,2517,5,269,0,0,2517,
        2518,5,313,0,0,2518,2521,3,356,178,0,2519,2520,5,320,0,0,2520,2522,
        3,542,271,0,2521,2519,1,0,0,0,2521,2522,1,0,0,0,2522,2523,1,0,0,
        0,2523,2524,5,314,0,0,2524,309,1,0,0,0,2525,2526,5,265,0,0,2526,
        2527,5,313,0,0,2527,2534,5,314,0,0,2528,2529,5,265,0,0,2529,2530,
        5,313,0,0,2530,2531,3,342,171,0,2531,2532,5,314,0,0,2532,2534,1,
        0,0,0,2533,2525,1,0,0,0,2533,2528,1,0,0,0,2534,311,1,0,0,0,2535,
        2536,5,268,0,0,2536,2537,5,313,0,0,2537,2544,5,314,0,0,2538,2539,
        5,268,0,0,2539,2540,5,313,0,0,2540,2541,3,342,171,0,2541,2542,5,
        314,0,0,2542,2544,1,0,0,0,2543,2535,1,0,0,0,2543,2538,1,0,0,0,2544,
        313,1,0,0,0,2545,2546,5,270,0,0,2546,2547,5,313,0,0,2547,2548,3,
        356,178,0,2548,2549,5,314,0,0,2549,315,1,0,0,0,2550,2551,5,271,0,
        0,2551,2552,5,313,0,0,2552,2559,5,314,0,0,2553,2554,5,271,0,0,2554,
        2555,5,313,0,0,2555,2556,3,592,296,0,2556,2557,5,314,0,0,2557,2559,
        1,0,0,0,2558,2550,1,0,0,0,2558,2553,1,0,0,0,2559,317,1,0,0,0,2560,
        2561,5,273,0,0,2561,2562,5,313,0,0,2562,2569,5,314,0,0,2563,2564,
        5,273,0,0,2564,2565,5,313,0,0,2565,2566,3,342,171,0,2566,2567,5,
        314,0,0,2567,2569,1,0,0,0,2568,2560,1,0,0,0,2568,2563,1,0,0,0,2569,
        319,1,0,0,0,2570,2571,5,278,0,0,2571,2572,5,313,0,0,2572,2573,5,
        314,0,0,2573,321,1,0,0,0,2574,2575,5,279,0,0,2575,2576,5,313,0,0,
        2576,2577,3,564,282,0,2577,2578,5,314,0,0,2578,323,1,0,0,0,2579,
        2580,5,281,0,0,2580,2581,5,313,0,0,2581,2582,3,376,188,0,2582,2583,
        5,314,0,0,2583,2590,1,0,0,0,2584,2585,5,281,0,0,2585,2586,5,313,
        0,0,2586,2587,3,54,27,0,2587,2588,5,314,0,0,2588,2590,1,0,0,0,2589,
        2579,1,0,0,0,2589,2584,1,0,0,0,2590,325,1,0,0,0,2591,2592,5,287,
        0,0,2592,2593,5,313,0,0,2593,2594,5,314,0,0,2594,327,1,0,0,0,2595,
        2596,5,285,0,0,2596,2597,5,313,0,0,2597,2598,3,580,290,0,2598,2599,
        5,314,0,0,2599,2610,1,0,0,0,2600,2601,5,285,0,0,2601,2602,5,313,
        0,0,2602,2605,3,602,301,0,2603,2604,5,320,0,0,2604,2606,3,580,290,
        0,2605,2603,1,0,0,0,2605,2606,1,0,0,0,2606,2607,1,0,0,0,2607,2608,
        5,314,0,0,2608,2610,1,0,0,0,2609,2595,1,0,0,0,2609,2600,1,0,0,0,
        2610,329,1,0,0,0,2611,2612,5,286,0,0,2612,2613,5,313,0,0,2613,2614,
        3,580,290,0,2614,2615,5,314,0,0,2615,331,1,0,0,0,2616,2617,5,292,
        0,0,2617,2618,5,313,0,0,2618,2619,3,376,188,0,2619,2620,5,314,0,
        0,2620,2634,1,0,0,0,2621,2622,5,292,0,0,2622,2623,5,313,0,0,2623,
        2624,3,592,296,0,2624,2625,5,320,0,0,2625,2626,3,376,188,0,2626,
        2627,5,314,0,0,2627,2634,1,0,0,0,2628,2629,5,292,0,0,2629,2630,5,
        313,0,0,2630,2631,3,54,27,0,2631,2632,5,314,0,0,2632,2634,1,0,0,
        0,2633,2616,1,0,0,0,2633,2621,1,0,0,0,2633,2628,1,0,0,0,2634,333,
        1,0,0,0,2635,2636,5,293,0,0,2636,2639,5,313,0,0,2637,2640,3,446,
        223,0,2638,2640,3,592,296,0,2639,2637,1,0,0,0,2639,2638,1,0,0,0,
        2640,2641,1,0,0,0,2641,2642,5,314,0,0,2642,2658,1,0,0,0,2643,2644,
        5,293,0,0,2644,2647,5,313,0,0,2645,2648,3,446,223,0,2646,2648,3,
        592,296,0,2647,2645,1,0,0,0,2647,2646,1,0,0,0,2648,2649,1,0,0,0,
        2649,2653,5,320,0,0,2650,2654,3,456,228,0,2651,2654,3,460,230,0,
        2652,2654,3,584,292,0,2653,2650,1,0,0,0,2653,2651,1,0,0,0,2653,2652,
        1,0,0,0,2654,2655,1,0,0,0,2655,2656,5,314,0,0,2656,2658,1,0,0,0,
        2657,2635,1,0,0,0,2657,2643,1,0,0,0,2658,335,1,0,0,0,2659,2660,5,
        303,0,0,2660,2661,5,313,0,0,2661,2662,5,314,0,0,2662,337,1,0,0,0,
        2663,2665,5,184,0,0,2664,2663,1,0,0,0,2664,2665,1,0,0,0,2665,2666,
        1,0,0,0,2666,2679,3,624,312,0,2667,2676,5,313,0,0,2668,2673,3,340,
        170,0,2669,2670,5,320,0,0,2670,2672,3,340,170,0,2671,2669,1,0,0,
        0,2672,2675,1,0,0,0,2673,2671,1,0,0,0,2673,2674,1,0,0,0,2674,2677,
        1,0,0,0,2675,2673,1,0,0,0,2676,2668,1,0,0,0,2676,2677,1,0,0,0,2677,
        2678,1,0,0,0,2678,2680,5,314,0,0,2679,2667,1,0,0,0,2679,2680,1,0,
        0,0,2680,339,1,0,0,0,2681,2684,3,628,314,0,2682,2684,3,622,311,0,
        2683,2681,1,0,0,0,2683,2682,1,0,0,0,2684,2685,1,0,0,0,2685,2686,
        5,322,0,0,2686,2687,3,546,273,0,2687,341,1,0,0,0,2688,2697,5,150,
        0,0,2689,2690,5,233,0,0,2690,2691,5,321,0,0,2691,2697,5,150,0,0,
        2692,2697,5,101,0,0,2693,2694,5,233,0,0,2694,2695,5,321,0,0,2695,
        2697,5,101,0,0,2696,2688,1,0,0,0,2696,2689,1,0,0,0,2696,2692,1,0,
        0,0,2696,2693,1,0,0,0,2697,343,1,0,0,0,2698,2703,5,185,0,0,2699,
        2700,5,17,0,0,2700,2701,5,321,0,0,2701,2703,5,185,0,0,2702,2698,
        1,0,0,0,2702,2699,1,0,0,0,2703,345,1,0,0,0,2704,2707,3,348,174,0,
        2705,2707,3,350,175,0,2706,2704,1,0,0,0,2706,2705,1,0,0,0,2707,347,
        1,0,0,0,2708,2709,7,0,0,0,2709,349,1,0,0,0,2710,2711,5,255,0,0,2711,
        2712,5,321,0,0,2712,2723,5,120,0,0,2713,2714,5,255,0,0,2714,2715,
        5,321,0,0,2715,2723,5,144,0,0,2716,2717,5,255,0,0,2717,2718,5,321,
        0,0,2718,2723,5,141,0,0,2719,2720,5,255,0,0,2720,2721,5,321,0,0,
        2721,2723,5,287,0,0,2722,2710,1,0,0,0,2722,2713,1,0,0,0,2722,2716,
        1,0,0,0,2722,2719,1,0,0,0,2723,351,1,0,0,0,2724,2741,5,190,0,0,2725,
        2726,5,164,0,0,2726,2727,5,321,0,0,2727,2741,5,190,0,0,2728,2741,
        5,191,0,0,2729,2730,5,164,0,0,2730,2731,5,321,0,0,2731,2741,5,191,
        0,0,2732,2741,5,203,0,0,2733,2734,5,164,0,0,2734,2735,5,321,0,0,
        2735,2741,5,203,0,0,2736,2741,5,136,0,0,2737,2738,5,164,0,0,2738,
        2739,5,321,0,0,2739,2741,5,136,0,0,2740,2724,1,0,0,0,2740,2725,1,
        0,0,0,2740,2728,1,0,0,0,2740,2729,1,0,0,0,2740,2732,1,0,0,0,2740,
        2733,1,0,0,0,2740,2736,1,0,0,0,2740,2737,1,0,0,0,2741,353,1,0,0,
        0,2742,2755,5,11,0,0,2743,2744,5,195,0,0,2744,2745,5,321,0,0,2745,
        2755,5,11,0,0,2746,2755,5,65,0,0,2747,2748,5,195,0,0,2748,2749,5,
        321,0,0,2749,2755,5,65,0,0,2750,2755,5,240,0,0,2751,2752,5,195,0,
        0,2752,2753,5,321,0,0,2753,2755,5,240,0,0,2754,2742,1,0,0,0,2754,
        2743,1,0,0,0,2754,2746,1,0,0,0,2754,2747,1,0,0,0,2754,2750,1,0,0,
        0,2754,2751,1,0,0,0,2755,355,1,0,0,0,2756,2759,3,358,179,0,2757,
        2759,3,360,180,0,2758,2756,1,0,0,0,2758,2757,1,0,0,0,2759,357,1,
        0,0,0,2760,2761,7,1,0,0,2761,359,1,0,0,0,2762,2763,5,68,0,0,2763,
        2764,5,321,0,0,2764,2778,5,124,0,0,2765,2766,5,68,0,0,2766,2767,
        5,321,0,0,2767,2778,5,100,0,0,2768,2769,5,68,0,0,2769,2770,5,321,
        0,0,2770,2778,5,199,0,0,2771,2772,5,68,0,0,2772,2773,5,321,0,0,2773,
        2778,5,261,0,0,2774,2775,5,68,0,0,2775,2776,5,321,0,0,2776,2778,
        5,30,0,0,2777,2762,1,0,0,0,2777,2765,1,0,0,0,2777,2768,1,0,0,0,2777,
        2771,1,0,0,0,2777,2774,1,0,0,0,2778,361,1,0,0,0,2779,2780,5,39,0,
        0,2780,2781,5,321,0,0,2781,2784,5,245,0,0,2782,2784,5,245,0,0,2783,
        2779,1,0,0,0,2783,2782,1,0,0,0,2784,2785,1,0,0,0,2785,2786,5,313,
        0,0,2786,2787,3,584,292,0,2787,2788,5,314,0,0,2788,2822,1,0,0,0,
        2789,2790,5,39,0,0,2790,2791,5,321,0,0,2791,2794,5,236,0,0,2792,
        2794,5,236,0,0,2793,2789,1,0,0,0,2793,2792,1,0,0,0,2794,2795,1,0,
        0,0,2795,2796,5,313,0,0,2796,2797,3,584,292,0,2797,2798,5,314,0,
        0,2798,2822,1,0,0,0,2799,2800,5,39,0,0,2800,2801,5,321,0,0,2801,
        2804,5,148,0,0,2802,2804,5,148,0,0,2803,2799,1,0,0,0,2803,2802,1,
        0,0,0,2804,2805,1,0,0,0,2805,2806,5,313,0,0,2806,2807,3,584,292,
        0,2807,2808,5,314,0,0,2808,2822,1,0,0,0,2809,2822,5,245,0,0,2810,
        2811,5,39,0,0,2811,2812,5,321,0,0,2812,2822,5,245,0,0,2813,2822,
        5,236,0,0,2814,2815,5,39,0,0,2815,2816,5,321,0,0,2816,2822,5,236,
        0,0,2817,2822,5,148,0,0,2818,2819,5,39,0,0,2819,2820,5,321,0,0,2820,
        2822,5,148,0,0,2821,2783,1,0,0,0,2821,2793,1,0,0,0,2821,2803,1,0,
        0,0,2821,2809,1,0,0,0,2821,2810,1,0,0,0,2821,2813,1,0,0,0,2821,2814,
        1,0,0,0,2821,2817,1,0,0,0,2821,2818,1,0,0,0,2822,363,1,0,0,0,2823,
        2832,5,142,0,0,2824,2825,5,45,0,0,2825,2826,5,321,0,0,2826,2832,
        5,142,0,0,2827,2832,5,286,0,0,2828,2829,5,45,0,0,2829,2830,5,321,
        0,0,2830,2832,5,286,0,0,2831,2823,1,0,0,0,2831,2824,1,0,0,0,2831,
        2827,1,0,0,0,2831,2828,1,0,0,0,2832,365,1,0,0,0,2833,2850,5,94,0,
        0,2834,2835,5,213,0,0,2835,2836,5,321,0,0,2836,2850,5,94,0,0,2837,
        2850,5,145,0,0,2838,2839,5,213,0,0,2839,2840,5,321,0,0,2840,2850,
        5,145,0,0,2841,2850,5,6,0,0,2842,2843,5,213,0,0,2843,2844,5,321,
        0,0,2844,2850,5,6,0,0,2845,2850,5,171,0,0,2846,2847,5,213,0,0,2847,
        2848,5,321,0,0,2848,2850,5,171,0,0,2849,2833,1,0,0,0,2849,2834,1,
        0,0,0,2849,2837,1,0,0,0,2849,2838,1,0,0,0,2849,2841,1,0,0,0,2849,
        2842,1,0,0,0,2849,2845,1,0,0,0,2849,2846,1,0,0,0,2850,367,1,0,0,
        0,2851,2896,5,1,0,0,2852,2853,5,192,0,0,2853,2854,5,321,0,0,2854,
        2896,5,1,0,0,2855,2896,5,7,0,0,2856,2857,5,192,0,0,2857,2858,5,321,
        0,0,2858,2896,5,7,0,0,2859,2896,5,15,0,0,2860,2861,5,192,0,0,2861,
        2862,5,321,0,0,2862,2896,5,15,0,0,2863,2896,5,71,0,0,2864,2865,5,
        192,0,0,2865,2866,5,321,0,0,2866,2896,5,71,0,0,2867,2896,5,161,0,
        0,2868,2869,5,192,0,0,2869,2870,5,321,0,0,2870,2896,5,161,0,0,2871,
        2896,5,168,0,0,2872,2873,5,192,0,0,2873,2874,5,321,0,0,2874,2896,
        5,168,0,0,2875,2896,5,170,0,0,2876,2877,5,192,0,0,2877,2878,5,321,
        0,0,2878,2896,5,170,0,0,2879,2896,5,172,0,0,2880,2881,5,192,0,0,
        2881,2882,5,321,0,0,2882,2896,5,172,0,0,2883,2896,5,197,0,0,2884,
        2885,5,192,0,0,2885,2886,5,321,0,0,2886,2896,5,197,0,0,2887,2896,
        5,253,0,0,2888,2889,5,192,0,0,2889,2890,5,321,0,0,2890,2896,5,253,
        0,0,2891,2896,5,254,0,0,2892,2893,5,192,0,0,2893,2894,5,321,0,0,
        2894,2896,5,254,0,0,2895,2851,1,0,0,0,2895,2852,1,0,0,0,2895,2855,
        1,0,0,0,2895,2856,1,0,0,0,2895,2859,1,0,0,0,2895,2860,1,0,0,0,2895,
        2863,1,0,0,0,2895,2864,1,0,0,0,2895,2867,1,0,0,0,2895,2868,1,0,0,
        0,2895,2871,1,0,0,0,2895,2872,1,0,0,0,2895,2875,1,0,0,0,2895,2876,
        1,0,0,0,2895,2879,1,0,0,0,2895,2880,1,0,0,0,2895,2883,1,0,0,0,2895,
        2884,1,0,0,0,2895,2887,1,0,0,0,2895,2888,1,0,0,0,2895,2891,1,0,0,
        0,2895,2892,1,0,0,0,2896,369,1,0,0,0,2897,2910,5,8,0,0,2898,2899,
        5,212,0,0,2899,2900,5,321,0,0,2900,2910,5,8,0,0,2901,2910,5,177,
        0,0,2902,2903,5,212,0,0,2903,2904,5,321,0,0,2904,2910,5,177,0,0,
        2905,2910,5,280,0,0,2906,2907,5,212,0,0,2907,2908,5,321,0,0,2908,
        2910,5,280,0,0,2909,2897,1,0,0,0,2909,2898,1,0,0,0,2909,2901,1,0,
        0,0,2909,2902,1,0,0,0,2909,2905,1,0,0,0,2909,2906,1,0,0,0,2910,371,
        1,0,0,0,2911,2928,5,234,0,0,2912,2913,5,77,0,0,2913,2914,5,321,0,
        0,2914,2928,5,234,0,0,2915,2928,5,169,0,0,2916,2917,5,77,0,0,2917,
        2918,5,321,0,0,2918,2928,5,169,0,0,2919,2928,5,119,0,0,2920,2921,
        5,77,0,0,2921,2922,5,321,0,0,2922,2928,5,119,0,0,2923,2928,5,57,
        0,0,2924,2925,5,77,0,0,2925,2926,5,321,0,0,2926,2928,5,57,0,0,2927,
        2911,1,0,0,0,2927,2912,1,0,0,0,2927,2915,1,0,0,0,2927,2916,1,0,0,
        0,2927,2919,1,0,0,0,2927,2920,1,0,0,0,2927,2923,1,0,0,0,2927,2924,
        1,0,0,0,2928,373,1,0,0,0,2929,3146,5,20,0,0,2930,2931,5,104,0,0,
        2931,2932,5,321,0,0,2932,3146,5,20,0,0,2933,3146,5,21,0,0,2934,2935,
        5,104,0,0,2935,2936,5,321,0,0,2936,3146,5,21,0,0,2937,3146,5,22,
        0,0,2938,2939,5,104,0,0,2939,2940,5,321,0,0,2940,3146,5,22,0,0,2941,
        3146,5,23,0,0,2942,2943,5,104,0,0,2943,2944,5,321,0,0,2944,3146,
        5,23,0,0,2945,3146,5,24,0,0,2946,2947,5,104,0,0,2947,2948,5,321,
        0,0,2948,3146,5,24,0,0,2949,3146,5,26,0,0,2950,2951,5,104,0,0,2951,
        2952,5,321,0,0,2952,3146,5,26,0,0,2953,3146,5,27,0,0,2954,2955,5,
        104,0,0,2955,2956,5,321,0,0,2956,3146,5,27,0,0,2957,3146,5,28,0,
        0,2958,2959,5,104,0,0,2959,2960,5,321,0,0,2960,3146,5,28,0,0,2961,
        3146,5,35,0,0,2962,2963,5,104,0,0,2963,2964,5,321,0,0,2964,3146,
        5,35,0,0,2965,3146,5,36,0,0,2966,2967,5,104,0,0,2967,2968,5,321,
        0,0,2968,3146,5,36,0,0,2969,3146,5,40,0,0,2970,2971,5,104,0,0,2971,
        2972,5,321,0,0,2972,3146,5,40,0,0,2973,3146,5,41,0,0,2974,2975,5,
        104,0,0,2975,2976,5,321,0,0,2976,3146,5,41,0,0,2977,3146,5,60,0,
        0,2978,2979,5,104,0,0,2979,2980,5,321,0,0,2980,3146,5,60,0,0,2981,
        3146,5,62,0,0,2982,2983,5,104,0,0,2983,2984,5,321,0,0,2984,3146,
        5,62,0,0,2985,3146,5,72,0,0,2986,2987,5,104,0,0,2987,2988,5,321,
        0,0,2988,3146,5,72,0,0,2989,3146,5,73,0,0,2990,2991,5,104,0,0,2991,
        2992,5,321,0,0,2992,3146,5,73,0,0,2993,3146,5,78,0,0,2994,2995,5,
        104,0,0,2995,2996,5,321,0,0,2996,3146,5,78,0,0,2997,3146,5,80,0,
        0,2998,2999,5,104,0,0,2999,3000,5,321,0,0,3000,3146,5,80,0,0,3001,
        3146,5,82,0,0,3002,3003,5,104,0,0,3003,3004,5,321,0,0,3004,3146,
        5,82,0,0,3005,3146,5,83,0,0,3006,3007,5,104,0,0,3007,3008,5,321,
        0,0,3008,3146,5,83,0,0,3009,3146,5,96,0,0,3010,3011,5,104,0,0,3011,
        3012,5,321,0,0,3012,3146,5,96,0,0,3013,3146,5,97,0,0,3014,3015,5,
        104,0,0,3015,3016,5,321,0,0,3016,3146,5,97,0,0,3017,3146,5,110,0,
        0,3018,3019,5,104,0,0,3019,3020,5,321,0,0,3020,3146,5,110,0,0,3021,
        3146,5,111,0,0,3022,3023,5,104,0,0,3023,3024,5,321,0,0,3024,3146,
        5,111,0,0,3025,3146,5,133,0,0,3026,3027,5,104,0,0,3027,3028,5,321,
        0,0,3028,3146,5,133,0,0,3029,3146,5,134,0,0,3030,3031,5,104,0,0,
        3031,3032,5,321,0,0,3032,3146,5,134,0,0,3033,3146,5,148,0,0,3034,
        3035,5,104,0,0,3035,3036,5,321,0,0,3036,3146,5,148,0,0,3037,3146,
        5,149,0,0,3038,3039,5,104,0,0,3039,3040,5,321,0,0,3040,3146,5,149,
        0,0,3041,3146,5,151,0,0,3042,3043,5,104,0,0,3043,3044,5,321,0,0,
        3044,3146,5,151,0,0,3045,3146,5,152,0,0,3046,3047,5,104,0,0,3047,
        3048,5,321,0,0,3048,3146,5,152,0,0,3049,3146,5,157,0,0,3050,3051,
        5,104,0,0,3051,3052,5,321,0,0,3052,3146,5,157,0,0,3053,3146,5,158,
        0,0,3054,3055,5,104,0,0,3055,3056,5,321,0,0,3056,3146,5,158,0,0,
        3057,3146,5,186,0,0,3058,3059,5,104,0,0,3059,3060,5,321,0,0,3060,
        3146,5,186,0,0,3061,3146,5,187,0,0,3062,3063,5,104,0,0,3063,3064,
        5,321,0,0,3064,3146,5,187,0,0,3065,3146,5,188,0,0,3066,3067,5,104,
        0,0,3067,3068,5,321,0,0,3068,3146,5,188,0,0,3069,3146,5,189,0,0,
        3070,3071,5,104,0,0,3071,3072,5,321,0,0,3072,3146,5,189,0,0,3073,
        3146,5,207,0,0,3074,3075,5,104,0,0,3075,3076,5,321,0,0,3076,3146,
        5,207,0,0,3077,3146,5,208,0,0,3078,3079,5,104,0,0,3079,3080,5,321,
        0,0,3080,3146,5,208,0,0,3081,3146,5,219,0,0,3082,3083,5,104,0,0,
        3083,3084,5,321,0,0,3084,3146,5,219,0,0,3085,3146,5,220,0,0,3086,
        3087,5,104,0,0,3087,3088,5,321,0,0,3088,3146,5,220,0,0,3089,3146,
        5,236,0,0,3090,3091,5,104,0,0,3091,3092,5,321,0,0,3092,3146,5,236,
        0,0,3093,3146,5,237,0,0,3094,3095,5,104,0,0,3095,3096,5,321,0,0,
        3096,3146,5,237,0,0,3097,3146,5,241,0,0,3098,3099,5,104,0,0,3099,
        3100,5,321,0,0,3100,3146,5,241,0,0,3101,3146,5,242,0,0,3102,3103,
        5,104,0,0,3103,3104,5,321,0,0,3104,3146,5,242,0,0,3105,3146,5,249,
        0,0,3106,3107,5,104,0,0,3107,3108,5,321,0,0,3108,3146,5,249,0,0,
        3109,3146,5,250,0,0,3110,3111,5,104,0,0,3111,3112,5,321,0,0,3112,
        3146,5,250,0,0,3113,3146,5,271,0,0,3114,3115,5,104,0,0,3115,3116,
        5,321,0,0,3116,3146,5,271,0,0,3117,3146,5,272,0,0,3118,3119,5,104,
        0,0,3119,3120,5,321,0,0,3120,3146,5,272,0,0,3121,3146,5,282,0,0,
        3122,3123,5,104,0,0,3123,3124,5,321,0,0,3124,3146,5,282,0,0,3125,
        3146,5,283,0,0,3126,3127,5,104,0,0,3127,3128,5,321,0,0,3128,3146,
        5,283,0,0,3129,3146,5,288,0,0,3130,3131,5,104,0,0,3131,3132,5,321,
        0,0,3132,3146,5,288,0,0,3133,3146,5,289,0,0,3134,3135,5,104,0,0,
        3135,3136,5,321,0,0,3136,3146,5,289,0,0,3137,3146,5,290,0,0,3138,
        3139,5,104,0,0,3139,3140,5,321,0,0,3140,3146,5,290,0,0,3141,3146,
        5,291,0,0,3142,3143,5,104,0,0,3143,3144,5,321,0,0,3144,3146,5,291,
        0,0,3145,2929,1,0,0,0,3145,2930,1,0,0,0,3145,2933,1,0,0,0,3145,2934,
        1,0,0,0,3145,2937,1,0,0,0,3145,2938,1,0,0,0,3145,2941,1,0,0,0,3145,
        2942,1,0,0,0,3145,2945,1,0,0,0,3145,2946,1,0,0,0,3145,2949,1,0,0,
        0,3145,2950,1,0,0,0,3145,2953,1,0,0,0,3145,2954,1,0,0,0,3145,2957,
        1,0,0,0,3145,2958,1,0,0,0,3145,2961,1,0,0,0,3145,2962,1,0,0,0,3145,
        2965,1,0,0,0,3145,2966,1,0,0,0,3145,2969,1,0,0,0,3145,2970,1,0,0,
        0,3145,2973,1,0,0,0,3145,2974,1,0,0,0,3145,2977,1,0,0,0,3145,2978,
        1,0,0,0,3145,2981,1,0,0,0,3145,2982,1,0,0,0,3145,2985,1,0,0,0,3145,
        2986,1,0,0,0,3145,2989,1,0,0,0,3145,2990,1,0,0,0,3145,2993,1,0,0,
        0,3145,2994,1,0,0,0,3145,2997,1,0,0,0,3145,2998,1,0,0,0,3145,3001,
        1,0,0,0,3145,3002,1,0,0,0,3145,3005,1,0,0,0,3145,3006,1,0,0,0,3145,
        3009,1,0,0,0,3145,3010,1,0,0,0,3145,3013,1,0,0,0,3145,3014,1,0,0,
        0,3145,3017,1,0,0,0,3145,3018,1,0,0,0,3145,3021,1,0,0,0,3145,3022,
        1,0,0,0,3145,3025,1,0,0,0,3145,3026,1,0,0,0,3145,3029,1,0,0,0,3145,
        3030,1,0,0,0,3145,3033,1,0,0,0,3145,3034,1,0,0,0,3145,3037,1,0,0,
        0,3145,3038,1,0,0,0,3145,3041,1,0,0,0,3145,3042,1,0,0,0,3145,3045,
        1,0,0,0,3145,3046,1,0,0,0,3145,3049,1,0,0,0,3145,3050,1,0,0,0,3145,
        3053,1,0,0,0,3145,3054,1,0,0,0,3145,3057,1,0,0,0,3145,3058,1,0,0,
        0,3145,3061,1,0,0,0,3145,3062,1,0,0,0,3145,3065,1,0,0,0,3145,3066,
        1,0,0,0,3145,3069,1,0,0,0,3145,3070,1,0,0,0,3145,3073,1,0,0,0,3145,
        3074,1,0,0,0,3145,3077,1,0,0,0,3145,3078,1,0,0,0,3145,3081,1,0,0,
        0,3145,3082,1,0,0,0,3145,3085,1,0,0,0,3145,3086,1,0,0,0,3145,3089,
        1,0,0,0,3145,3090,1,0,0,0,3145,3093,1,0,0,0,3145,3094,1,0,0,0,3145,
        3097,1,0,0,0,3145,3098,1,0,0,0,3145,3101,1,0,0,0,3145,3102,1,0,0,
        0,3145,3105,1,0,0,0,3145,3106,1,0,0,0,3145,3109,1,0,0,0,3145,3110,
        1,0,0,0,3145,3113,1,0,0,0,3145,3114,1,0,0,0,3145,3117,1,0,0,0,3145,
        3118,1,0,0,0,3145,3121,1,0,0,0,3145,3122,1,0,0,0,3145,3125,1,0,0,
        0,3145,3126,1,0,0,0,3145,3129,1,0,0,0,3145,3130,1,0,0,0,3145,3133,
        1,0,0,0,3145,3134,1,0,0,0,3145,3137,1,0,0,0,3145,3138,1,0,0,0,3145,
        3141,1,0,0,0,3145,3142,1,0,0,0,3146,375,1,0,0,0,3147,3148,6,188,
        -1,0,3148,3170,3,388,194,0,3149,3170,3,390,195,0,3150,3170,3,394,
        197,0,3151,3170,3,396,198,0,3152,3170,3,398,199,0,3153,3170,3,400,
        200,0,3154,3170,3,402,201,0,3155,3170,3,404,202,0,3156,3170,3,406,
        203,0,3157,3170,3,392,196,0,3158,3170,3,408,204,0,3159,3170,3,410,
        205,0,3160,3170,3,412,206,0,3161,3170,3,418,209,0,3162,3170,3,420,
        210,0,3163,3170,3,422,211,0,3164,3170,3,424,212,0,3165,3170,3,414,
        207,0,3166,3170,3,416,208,0,3167,3170,3,426,213,0,3168,3170,3,428,
        214,0,3169,3147,1,0,0,0,3169,3149,1,0,0,0,3169,3150,1,0,0,0,3169,
        3151,1,0,0,0,3169,3152,1,0,0,0,3169,3153,1,0,0,0,3169,3154,1,0,0,
        0,3169,3155,1,0,0,0,3169,3156,1,0,0,0,3169,3157,1,0,0,0,3169,3158,
        1,0,0,0,3169,3159,1,0,0,0,3169,3160,1,0,0,0,3169,3161,1,0,0,0,3169,
        3162,1,0,0,0,3169,3163,1,0,0,0,3169,3164,1,0,0,0,3169,3165,1,0,0,
        0,3169,3166,1,0,0,0,3169,3167,1,0,0,0,3169,3168,1,0,0,0,3170,3192,
        1,0,0,0,3171,3172,10,3,0,0,3172,3173,5,321,0,0,3173,3174,5,7,0,0,
        3174,3175,5,313,0,0,3175,3176,3,376,188,0,3176,3177,5,314,0,0,3177,
        3191,1,0,0,0,3178,3179,10,2,0,0,3179,3180,5,321,0,0,3180,3181,5,
        197,0,0,3181,3182,5,313,0,0,3182,3183,3,376,188,0,3183,3184,5,314,
        0,0,3184,3191,1,0,0,0,3185,3186,10,1,0,0,3186,3187,5,321,0,0,3187,
        3188,5,175,0,0,3188,3189,5,313,0,0,3189,3191,5,314,0,0,3190,3171,
        1,0,0,0,3190,3178,1,0,0,0,3190,3185,1,0,0,0,3191,3194,1,0,0,0,3192,
        3190,1,0,0,0,3192,3193,1,0,0,0,3193,377,1,0,0,0,3194,3192,1,0,0,
        0,3195,3204,3,430,215,0,3196,3204,3,434,217,0,3197,3204,3,432,216,
        0,3198,3204,3,436,218,0,3199,3204,3,438,219,0,3200,3204,3,440,220,
        0,3201,3204,3,442,221,0,3202,3204,3,444,222,0,3203,3195,1,0,0,0,
        3203,3196,1,0,0,0,3203,3197,1,0,0,0,3203,3198,1,0,0,0,3203,3199,
        1,0,0,0,3203,3200,1,0,0,0,3203,3201,1,0,0,0,3203,3202,1,0,0,0,3204,
        379,1,0,0,0,3205,3206,3,344,172,0,3206,381,1,0,0,0,3207,3208,3,354,
        177,0,3208,383,1,0,0,0,3209,3212,3,346,173,0,3210,3212,3,364,182,
        0,3211,3209,1,0,0,0,3211,3210,1,0,0,0,3212,385,1,0,0,0,3213,3214,
        3,368,184,0,3214,387,1,0,0,0,3215,3216,5,204,0,0,3216,3217,5,321,
        0,0,3217,3220,5,89,0,0,3218,3220,5,89,0,0,3219,3215,1,0,0,0,3219,
        3218,1,0,0,0,3220,3221,1,0,0,0,3221,3222,5,313,0,0,3222,3223,3,546,
        273,0,3223,3224,5,314,0,0,3224,3236,1,0,0,0,3225,3226,5,204,0,0,
        3226,3227,5,321,0,0,3227,3230,5,89,0,0,3228,3230,5,89,0,0,3229,3225,
        1,0,0,0,3229,3228,1,0,0,0,3230,3231,1,0,0,0,3231,3232,5,313,0,0,
        3232,3233,3,54,27,0,3233,3234,5,314,0,0,3234,3236,1,0,0,0,3235,3219,
        1,0,0,0,3235,3229,1,0,0,0,3236,389,1,0,0,0,3237,3238,5,204,0,0,3238,
        3239,5,321,0,0,3239,3242,5,183,0,0,3240,3242,5,183,0,0,3241,3237,
        1,0,0,0,3241,3240,1,0,0,0,3242,3243,1,0,0,0,3243,3244,5,313,0,0,
        3244,3245,3,546,273,0,3245,3246,5,314,0,0,3246,3258,1,0,0,0,3247,
        3248,5,204,0,0,3248,3249,5,321,0,0,3249,3252,5,183,0,0,3250,3252,
        5,183,0,0,3251,3247,1,0,0,0,3251,3250,1,0,0,0,3252,3253,1,0,0,0,
        3253,3254,5,313,0,0,3254,3255,3,54,27,0,3255,3256,5,314,0,0,3256,
        3258,1,0,0,0,3257,3241,1,0,0,0,3257,3251,1,0,0,0,3258,391,1,0,0,
        0,3259,3260,5,204,0,0,3260,3261,5,321,0,0,3261,3264,5,276,0,0,3262,
        3264,5,276,0,0,3263,3259,1,0,0,0,3263,3262,1,0,0,0,3264,3265,1,0,
        0,0,3265,3266,5,313,0,0,3266,3267,3,374,187,0,3267,3268,5,314,0,
        0,3268,3280,1,0,0,0,3269,3270,5,204,0,0,3270,3271,5,321,0,0,3271,
        3274,5,276,0,0,3272,3274,5,276,0,0,3273,3269,1,0,0,0,3273,3272,1,
        0,0,0,3274,3275,1,0,0,0,3275,3276,5,313,0,0,3276,3277,3,592,296,
        0,3277,3278,5,314,0,0,3278,3280,1,0,0,0,3279,3263,1,0,0,0,3279,3273,
        1,0,0,0,3280,393,1,0,0,0,3281,3282,5,204,0,0,3282,3283,5,321,0,0,
        3283,3286,5,154,0,0,3284,3286,5,154,0,0,3285,3281,1,0,0,0,3285,3284,
        1,0,0,0,3286,3287,1,0,0,0,3287,3288,5,313,0,0,3288,3289,3,546,273,
        0,3289,3290,5,314,0,0,3290,3302,1,0,0,0,3291,3292,5,204,0,0,3292,
        3293,5,321,0,0,3293,3296,5,154,0,0,3294,3296,5,154,0,0,3295,3291,
        1,0,0,0,3295,3294,1,0,0,0,3296,3297,1,0,0,0,3297,3298,5,313,0,0,
        3298,3299,3,54,27,0,3299,3300,5,314,0,0,3300,3302,1,0,0,0,3301,3285,
        1,0,0,0,3301,3295,1,0,0,0,3302,395,1,0,0,0,3303,3304,5,204,0,0,3304,
        3305,5,321,0,0,3305,3308,5,155,0,0,3306,3308,5,155,0,0,3307,3303,
        1,0,0,0,3307,3306,1,0,0,0,3308,3309,1,0,0,0,3309,3310,5,313,0,0,
        3310,3311,3,546,273,0,3311,3312,5,314,0,0,3312,3324,1,0,0,0,3313,
        3314,5,204,0,0,3314,3315,5,321,0,0,3315,3318,5,155,0,0,3316,3318,
        5,155,0,0,3317,3313,1,0,0,0,3317,3316,1,0,0,0,3318,3319,1,0,0,0,
        3319,3320,5,313,0,0,3320,3321,3,54,27,0,3321,3322,5,314,0,0,3322,
        3324,1,0,0,0,3323,3307,1,0,0,0,3323,3317,1,0,0,0,3324,397,1,0,0,
        0,3325,3326,5,204,0,0,3326,3327,5,321,0,0,3327,3330,5,102,0,0,3328,
        3330,5,102,0,0,3329,3325,1,0,0,0,3329,3328,1,0,0,0,3330,3331,1,0,
        0,0,3331,3332,5,313,0,0,3332,3333,3,546,273,0,3333,3334,5,314,0,
        0,3334,3346,1,0,0,0,3335,3336,5,204,0,0,3336,3337,5,321,0,0,3337,
        3340,5,102,0,0,3338,3340,5,102,0,0,3339,3335,1,0,0,0,3339,3338,1,
        0,0,0,3340,3341,1,0,0,0,3341,3342,5,313,0,0,3342,3343,3,54,27,0,
        3343,3344,5,314,0,0,3344,3346,1,0,0,0,3345,3329,1,0,0,0,3345,3339,
        1,0,0,0,3346,399,1,0,0,0,3347,3348,5,204,0,0,3348,3349,5,321,0,0,
        3349,3352,5,103,0,0,3350,3352,5,103,0,0,3351,3347,1,0,0,0,3351,3350,
        1,0,0,0,3352,3353,1,0,0,0,3353,3354,5,313,0,0,3354,3355,3,546,273,
        0,3355,3356,5,314,0,0,3356,3368,1,0,0,0,3357,3358,5,204,0,0,3358,
        3359,5,321,0,0,3359,3362,5,103,0,0,3360,3362,5,103,0,0,3361,3357,
        1,0,0,0,3361,3360,1,0,0,0,3362,3363,1,0,0,0,3363,3364,5,313,0,0,
        3364,3365,3,54,27,0,3365,3366,5,314,0,0,3366,3368,1,0,0,0,3367,3351,
        1,0,0,0,3367,3361,1,0,0,0,3368,401,1,0,0,0,3369,3370,5,204,0,0,3370,
        3371,5,321,0,0,3371,3374,5,132,0,0,3372,3374,5,132,0,0,3373,3369,
        1,0,0,0,3373,3372,1,0,0,0,3374,3375,1,0,0,0,3375,3376,5,313,0,0,
        3376,3377,3,546,273,0,3377,3378,5,320,0,0,3378,3379,3,546,273,0,
        3379,3380,5,314,0,0,3380,3394,1,0,0,0,3381,3382,5,204,0,0,3382,3383,
        5,321,0,0,3383,3386,5,132,0,0,3384,3386,5,132,0,0,3385,3381,1,0,
        0,0,3385,3384,1,0,0,0,3386,3387,1,0,0,0,3387,3388,5,313,0,0,3388,
        3389,3,54,27,0,3389,3390,5,320,0,0,3390,3391,3,54,27,0,3391,3392,
        5,314,0,0,3392,3394,1,0,0,0,3393,3373,1,0,0,0,3393,3385,1,0,0,0,
        3394,403,1,0,0,0,3395,3396,5,204,0,0,3396,3397,5,321,0,0,3397,3400,
        5,202,0,0,3398,3400,5,202,0,0,3399,3395,1,0,0,0,3399,3398,1,0,0,
        0,3400,3401,1,0,0,0,3401,3402,5,313,0,0,3402,3403,3,546,273,0,3403,
        3404,5,320,0,0,3404,3405,3,546,273,0,3405,3406,5,314,0,0,3406,3420,
        1,0,0,0,3407,3408,5,204,0,0,3408,3409,5,321,0,0,3409,3412,5,202,
        0,0,3410,3412,5,202,0,0,3411,3407,1,0,0,0,3411,3410,1,0,0,0,3412,
        3413,1,0,0,0,3413,3414,5,313,0,0,3414,3415,3,54,27,0,3415,3416,5,
        320,0,0,3416,3417,3,54,27,0,3417,3418,5,314,0,0,3418,3420,1,0,0,
        0,3419,3399,1,0,0,0,3419,3411,1,0,0,0,3420,405,1,0,0,0,3421,3422,
        5,204,0,0,3422,3423,5,321,0,0,3423,3426,5,19,0,0,3424,3426,5,19,
        0,0,3425,3421,1,0,0,0,3425,3424,1,0,0,0,3426,3427,1,0,0,0,3427,3428,
        5,313,0,0,3428,3429,3,546,273,0,3429,3430,5,320,0,0,3430,3431,3,
        546,273,0,3431,3432,5,314,0,0,3432,3446,1,0,0,0,3433,3434,5,204,
        0,0,3434,3435,5,321,0,0,3435,3438,5,19,0,0,3436,3438,5,19,0,0,3437,
        3433,1,0,0,0,3437,3436,1,0,0,0,3438,3439,1,0,0,0,3439,3440,5,313,
        0,0,3440,3441,3,54,27,0,3441,3442,5,320,0,0,3442,3443,3,54,27,0,
        3443,3444,5,314,0,0,3444,3446,1,0,0,0,3445,3425,1,0,0,0,3445,3437,
        1,0,0,0,3446,407,1,0,0,0,3447,3448,5,204,0,0,3448,3449,5,321,0,0,
        3449,3452,5,295,0,0,3450,3452,5,295,0,0,3451,3447,1,0,0,0,3451,3450,
        1,0,0,0,3452,3453,1,0,0,0,3453,3454,5,313,0,0,3454,3476,5,314,0,
        0,3455,3456,5,204,0,0,3456,3457,5,321,0,0,3457,3460,5,295,0,0,3458,
        3460,5,295,0,0,3459,3455,1,0,0,0,3459,3458,1,0,0,0,3460,3461,1,0,
        0,0,3461,3462,5,313,0,0,3462,3463,3,548,274,0,3463,3464,5,314,0,
        0,3464,3476,1,0,0,0,3465,3466,5,204,0,0,3466,3467,5,321,0,0,3467,
        3470,5,295,0,0,3468,3470,5,295,0,0,3469,3465,1,0,0,0,3469,3468,1,
        0,0,0,3470,3471,1,0,0,0,3471,3472,5,313,0,0,3472,3473,3,54,27,0,
        3473,3474,5,314,0,0,3474,3476,1,0,0,0,3475,3451,1,0,0,0,3475,3459,
        1,0,0,0,3475,3469,1,0,0,0,3476,409,1,0,0,0,3477,3478,5,204,0,0,3478,
        3479,5,321,0,0,3479,3482,5,297,0,0,3480,3482,5,297,0,0,3481,3477,
        1,0,0,0,3481,3480,1,0,0,0,3482,3483,1,0,0,0,3483,3484,5,313,0,0,
        3484,3506,5,314,0,0,3485,3486,5,204,0,0,3486,3487,5,321,0,0,3487,
        3490,5,297,0,0,3488,3490,5,297,0,0,3489,3485,1,0,0,0,3489,3488,1,
        0,0,0,3490,3491,1,0,0,0,3491,3492,5,313,0,0,3492,3493,3,548,274,
        0,3493,3494,5,314,0,0,3494,3506,1,0,0,0,3495,3496,5,204,0,0,3496,
        3497,5,321,0,0,3497,3500,5,297,0,0,3498,3500,5,297,0,0,3499,3495,
        1,0,0,0,3499,3498,1,0,0,0,3500,3501,1,0,0,0,3501,3502,5,313,0,0,
        3502,3503,3,54,27,0,3503,3504,5,314,0,0,3504,3506,1,0,0,0,3505,3481,
        1,0,0,0,3505,3489,1,0,0,0,3505,3499,1,0,0,0,3506,411,1,0,0,0,3507,
        3508,5,204,0,0,3508,3509,5,321,0,0,3509,3512,5,182,0,0,3510,3512,
        5,182,0,0,3511,3507,1,0,0,0,3511,3510,1,0,0,0,3512,3513,1,0,0,0,
        3513,3514,5,313,0,0,3514,3515,3,376,188,0,3515,3516,5,314,0,0,3516,
        413,1,0,0,0,3517,3518,5,258,0,0,3518,3519,5,321,0,0,3519,3522,5,
        54,0,0,3520,3522,5,54,0,0,3521,3517,1,0,0,0,3521,3520,1,0,0,0,3522,
        3523,1,0,0,0,3523,3524,5,313,0,0,3524,3525,3,536,268,0,3525,3526,
        5,314,0,0,3526,3538,1,0,0,0,3527,3528,5,258,0,0,3528,3529,5,321,
        0,0,3529,3532,5,54,0,0,3530,3532,5,54,0,0,3531,3527,1,0,0,0,3531,
        3530,1,0,0,0,3532,3533,1,0,0,0,3533,3534,5,313,0,0,3534,3535,3,54,
        27,0,3535,3536,5,314,0,0,3536,3538,1,0,0,0,3537,3521,1,0,0,0,3537,
        3531,1,0,0,0,3538,415,1,0,0,0,3539,3540,5,258,0,0,3540,3541,5,321,
        0,0,3541,3544,5,179,0,0,3542,3544,5,179,0,0,3543,3539,1,0,0,0,3543,
        3542,1,0,0,0,3544,3545,1,0,0,0,3545,3546,5,313,0,0,3546,3547,3,536,
        268,0,3547,3548,5,314,0,0,3548,3560,1,0,0,0,3549,3550,5,258,0,0,
        3550,3551,5,321,0,0,3551,3554,5,179,0,0,3552,3554,5,179,0,0,3553,
        3549,1,0,0,0,3553,3552,1,0,0,0,3554,3555,1,0,0,0,3555,3556,5,313,
        0,0,3556,3557,3,54,27,0,3557,3558,5,314,0,0,3558,3560,1,0,0,0,3559,
        3543,1,0,0,0,3559,3553,1,0,0,0,3560,417,1,0,0,0,3561,3562,5,258,
        0,0,3562,3563,5,321,0,0,3563,3566,5,248,0,0,3564,3566,5,248,0,0,
        3565,3561,1,0,0,0,3565,3564,1,0,0,0,3566,3567,1,0,0,0,3567,3568,
        5,313,0,0,3568,3569,3,536,268,0,3569,3570,5,314,0,0,3570,3582,1,
        0,0,0,3571,3572,5,258,0,0,3572,3573,5,321,0,0,3573,3576,5,248,0,
        0,3574,3576,5,248,0,0,3575,3571,1,0,0,0,3575,3574,1,0,0,0,3576,3577,
        1,0,0,0,3577,3578,5,313,0,0,3578,3579,3,54,27,0,3579,3580,5,314,
        0,0,3580,3582,1,0,0,0,3581,3565,1,0,0,0,3581,3575,1,0,0,0,3582,419,
        1,0,0,0,3583,3584,5,258,0,0,3584,3585,5,321,0,0,3585,3588,5,181,
        0,0,3586,3588,5,181,0,0,3587,3583,1,0,0,0,3587,3586,1,0,0,0,3588,
        3589,1,0,0,0,3589,3590,5,313,0,0,3590,3591,3,536,268,0,3591,3592,
        5,314,0,0,3592,3604,1,0,0,0,3593,3594,5,258,0,0,3594,3595,5,321,
        0,0,3595,3598,5,181,0,0,3596,3598,5,181,0,0,3597,3593,1,0,0,0,3597,
        3596,1,0,0,0,3598,3599,1,0,0,0,3599,3600,5,313,0,0,3600,3601,3,54,
        27,0,3601,3602,5,314,0,0,3602,3604,1,0,0,0,3603,3587,1,0,0,0,3603,
        3597,1,0,0,0,3604,421,1,0,0,0,3605,3606,5,258,0,0,3606,3607,5,321,
        0,0,3607,3610,5,88,0,0,3608,3610,5,88,0,0,3609,3605,1,0,0,0,3609,
        3608,1,0,0,0,3610,3611,1,0,0,0,3611,3612,5,313,0,0,3612,3613,3,536,
        268,0,3613,3614,5,314,0,0,3614,3626,1,0,0,0,3615,3616,5,258,0,0,
        3616,3617,5,321,0,0,3617,3620,5,88,0,0,3618,3620,5,88,0,0,3619,3615,
        1,0,0,0,3619,3618,1,0,0,0,3620,3621,1,0,0,0,3621,3622,5,313,0,0,
        3622,3623,3,54,27,0,3623,3624,5,314,0,0,3624,3626,1,0,0,0,3625,3609,
        1,0,0,0,3625,3619,1,0,0,0,3626,423,1,0,0,0,3627,3628,5,258,0,0,3628,
        3629,5,321,0,0,3629,3632,5,180,0,0,3630,3632,5,180,0,0,3631,3627,
        1,0,0,0,3631,3630,1,0,0,0,3632,3633,1,0,0,0,3633,3634,5,313,0,0,
        3634,3635,3,536,268,0,3635,3636,5,314,0,0,3636,3648,1,0,0,0,3637,
        3638,5,258,0,0,3638,3639,5,321,0,0,3639,3642,5,180,0,0,3640,3642,
        5,180,0,0,3641,3637,1,0,0,0,3641,3640,1,0,0,0,3642,3643,1,0,0,0,
        3643,3644,5,313,0,0,3644,3645,3,54,27,0,3645,3646,5,314,0,0,3646,
        3648,1,0,0,0,3647,3631,1,0,0,0,3647,3641,1,0,0,0,3648,425,1,0,0,
        0,3649,3650,5,258,0,0,3650,3651,5,321,0,0,3651,3654,5,225,0,0,3652,
        3654,5,225,0,0,3653,3649,1,0,0,0,3653,3652,1,0,0,0,3654,3655,1,0,
        0,0,3655,3656,5,313,0,0,3656,3657,3,536,268,0,3657,3658,5,314,0,
        0,3658,427,1,0,0,0,3659,3660,5,258,0,0,3660,3661,5,321,0,0,3661,
        3664,5,178,0,0,3662,3664,5,178,0,0,3663,3659,1,0,0,0,3663,3662,1,
        0,0,0,3664,3665,1,0,0,0,3665,3666,5,313,0,0,3666,3667,3,536,268,
        0,3667,3668,5,314,0,0,3668,429,1,0,0,0,3669,3670,5,90,0,0,3670,3671,
        5,313,0,0,3671,3672,5,314,0,0,3672,431,1,0,0,0,3673,3674,5,116,0,
        0,3674,3675,5,313,0,0,3675,3676,5,314,0,0,3676,433,1,0,0,0,3677,
        3678,5,140,0,0,3678,3679,5,313,0,0,3679,3680,5,314,0,0,3680,435,
        1,0,0,0,3681,3682,5,275,0,0,3682,3683,5,313,0,0,3683,3684,5,314,
        0,0,3684,437,1,0,0,0,3685,3686,5,176,0,0,3686,3687,5,313,0,0,3687,
        3694,5,314,0,0,3688,3689,5,176,0,0,3689,3690,5,313,0,0,3690,3691,
        3,596,298,0,3691,3692,5,314,0,0,3692,3694,1,0,0,0,3693,3685,1,0,
        0,0,3693,3688,1,0,0,0,3694,439,1,0,0,0,3695,3696,5,264,0,0,3696,
        3697,5,313,0,0,3697,3698,5,314,0,0,3698,441,1,0,0,0,3699,3700,5,
        266,0,0,3700,3701,5,313,0,0,3701,3702,5,314,0,0,3702,443,1,0,0,0,
        3703,3704,5,262,0,0,3704,3705,5,313,0,0,3705,3706,5,314,0,0,3706,
        445,1,0,0,0,3707,3715,3,454,227,0,3708,3715,3,448,224,0,3709,3715,
        3,450,225,0,3710,3715,3,452,226,0,3711,3715,3,458,229,0,3712,3715,
        3,490,245,0,3713,3715,3,504,252,0,3714,3707,1,0,0,0,3714,3708,1,
        0,0,0,3714,3709,1,0,0,0,3714,3710,1,0,0,0,3714,3711,1,0,0,0,3714,
        3712,1,0,0,0,3714,3713,1,0,0,0,3715,447,1,0,0,0,3716,3720,3,462,
        231,0,3717,3720,3,464,232,0,3718,3720,3,466,233,0,3719,3716,1,0,
        0,0,3719,3717,1,0,0,0,3719,3718,1,0,0,0,3720,449,1,0,0,0,3721,3725,
        3,468,234,0,3722,3725,3,470,235,0,3723,3725,3,472,236,0,3724,3721,
        1,0,0,0,3724,3722,1,0,0,0,3724,3723,1,0,0,0,3725,451,1,0,0,0,3726,
        3730,3,474,237,0,3727,3730,3,476,238,0,3728,3730,3,478,239,0,3729,
        3726,1,0,0,0,3729,3727,1,0,0,0,3729,3728,1,0,0,0,3730,453,1,0,0,
        0,3731,3737,3,480,240,0,3732,3737,3,482,241,0,3733,3737,3,484,242,
        0,3734,3737,3,486,243,0,3735,3737,3,488,244,0,3736,3731,1,0,0,0,
        3736,3732,1,0,0,0,3736,3733,1,0,0,0,3736,3734,1,0,0,0,3736,3735,
        1,0,0,0,3737,455,1,0,0,0,3738,3748,3,490,245,0,3739,3748,3,492,246,
        0,3740,3748,3,494,247,0,3741,3748,3,496,248,0,3742,3748,3,498,249,
        0,3743,3748,3,500,250,0,3744,3748,3,502,251,0,3745,3748,3,506,253,
        0,3746,3748,3,508,254,0,3747,3738,1,0,0,0,3747,3739,1,0,0,0,3747,
        3740,1,0,0,0,3747,3741,1,0,0,0,3747,3742,1,0,0,0,3747,3743,1,0,0,
        0,3747,3744,1,0,0,0,3747,3745,1,0,0,0,3747,3746,1,0,0,0,3748,457,
        1,0,0,0,3749,3752,3,510,255,0,3750,3752,3,512,256,0,3751,3749,1,
        0,0,0,3751,3750,1,0,0,0,3752,459,1,0,0,0,3753,3757,3,514,257,0,3754,
        3757,3,516,258,0,3755,3757,3,518,259,0,3756,3753,1,0,0,0,3756,3754,
        1,0,0,0,3756,3755,1,0,0,0,3757,461,1,0,0,0,3758,3759,3,520,260,0,
        3759,3760,5,321,0,0,3760,3761,5,48,0,0,3761,463,1,0,0,0,3762,3763,
        3,520,260,0,3763,3764,5,321,0,0,3764,3765,5,84,0,0,3765,465,1,0,
        0,0,3766,3767,3,520,260,0,3767,3768,5,321,0,0,3768,3769,5,218,0,
        0,3769,467,1,0,0,0,3770,3771,3,522,261,0,3771,3772,5,321,0,0,3772,
        3773,5,84,0,0,3773,469,1,0,0,0,3774,3775,3,522,261,0,3775,3776,5,
        321,0,0,3776,3777,5,260,0,0,3777,471,1,0,0,0,3778,3779,3,522,261,
        0,3779,3780,5,321,0,0,3780,3781,5,218,0,0,3781,473,1,0,0,0,3782,
        3783,3,524,262,0,3783,3784,5,321,0,0,3784,3785,5,84,0,0,3785,475,
        1,0,0,0,3786,3787,3,524,262,0,3787,3788,5,321,0,0,3788,3789,5,260,
        0,0,3789,477,1,0,0,0,3790,3791,3,524,262,0,3791,3792,5,321,0,0,3792,
        3793,5,218,0,0,3793,479,1,0,0,0,3794,3795,3,526,263,0,3795,3796,
        5,321,0,0,3796,3797,5,257,0,0,3797,481,1,0,0,0,3798,3799,3,526,263,
        0,3799,3800,5,321,0,0,3800,3801,5,84,0,0,3801,483,1,0,0,0,3802,3803,
        3,526,263,0,3803,3804,5,321,0,0,3804,3805,5,70,0,0,3805,485,1,0,
        0,0,3806,3807,3,526,263,0,3807,3808,5,321,0,0,3808,3809,5,162,0,
        0,3809,487,1,0,0,0,3810,3811,3,526,263,0,3811,3812,5,321,0,0,3812,
        3813,5,126,0,0,3813,489,1,0,0,0,3814,3815,3,528,264,0,3815,3816,
        5,321,0,0,3816,3817,5,263,0,0,3817,491,1,0,0,0,3818,3819,3,528,264,
        0,3819,3820,5,321,0,0,3820,3821,5,177,0,0,3821,493,1,0,0,0,3822,
        3823,3,528,264,0,3823,3824,5,321,0,0,3824,3825,5,122,0,0,3825,495,
        1,0,0,0,3826,3827,3,528,264,0,3827,3828,5,321,0,0,3828,3829,5,143,
        0,0,3829,497,1,0,0,0,3830,3831,3,528,264,0,3831,3832,5,321,0,0,3832,
        3833,5,142,0,0,3833,499,1,0,0,0,3834,3835,3,528,264,0,3835,3836,
        5,321,0,0,3836,3837,5,286,0,0,3837,501,1,0,0,0,3838,3839,3,528,264,
        0,3839,3840,5,321,0,0,3840,3841,5,6,0,0,3841,503,1,0,0,0,3842,3843,
        3,528,264,0,3843,3844,5,321,0,0,3844,3845,5,128,0,0,3845,505,1,0,
        0,0,3846,3847,3,528,264,0,3847,3848,5,321,0,0,3848,3849,5,148,0,
        0,3849,507,1,0,0,0,3850,3851,3,528,264,0,3851,3852,5,321,0,0,3852,
        3853,5,157,0,0,3853,509,1,0,0,0,3854,3855,3,530,265,0,3855,3856,
        5,321,0,0,3856,3857,5,224,0,0,3857,511,1,0,0,0,3858,3859,3,530,265,
        0,3859,3860,5,321,0,0,3860,3861,5,304,0,0,3861,513,1,0,0,0,3862,
        3863,3,530,265,0,3863,3864,5,321,0,0,3864,3865,5,109,0,0,3865,515,
        1,0,0,0,3866,3867,3,530,265,0,3867,3868,5,321,0,0,3868,3869,5,106,
        0,0,3869,517,1,0,0,0,3870,3871,3,530,265,0,3871,3872,5,321,0,0,3872,
        3873,5,105,0,0,3873,519,1,0,0,0,3874,3875,5,52,0,0,3875,521,1,0,
        0,0,3876,3877,5,205,0,0,3877,523,1,0,0,0,3878,3879,5,210,0,0,3879,
        525,1,0,0,0,3880,3881,5,238,0,0,3881,527,1,0,0,0,3882,3883,5,296,
        0,0,3883,529,1,0,0,0,3884,3885,5,137,0,0,3885,531,1,0,0,0,3886,3889,
        3,602,301,0,3887,3889,3,626,313,0,3888,3886,1,0,0,0,3888,3887,1,
        0,0,0,3889,533,1,0,0,0,3890,3893,3,596,298,0,3891,3893,3,626,313,
        0,3892,3890,1,0,0,0,3892,3891,1,0,0,0,3893,535,1,0,0,0,3894,3897,
        3,592,296,0,3895,3897,3,626,313,0,3896,3894,1,0,0,0,3896,3895,1,
        0,0,0,3897,537,1,0,0,0,3898,3903,3,536,268,0,3899,3900,5,320,0,0,
        3900,3902,3,536,268,0,3901,3899,1,0,0,0,3902,3905,1,0,0,0,3903,3901,
        1,0,0,0,3903,3904,1,0,0,0,3904,539,1,0,0,0,3905,3903,1,0,0,0,3906,
        3909,3,594,297,0,3907,3909,3,626,313,0,3908,3906,1,0,0,0,3908,3907,
        1,0,0,0,3909,541,1,0,0,0,3910,3915,3,540,270,0,3911,3912,5,320,0,
        0,3912,3914,3,540,270,0,3913,3911,1,0,0,0,3914,3917,1,0,0,0,3915,
        3913,1,0,0,0,3915,3916,1,0,0,0,3916,3919,1,0,0,0,3917,3915,1,0,0,
        0,3918,3910,1,0,0,0,3918,3919,1,0,0,0,3919,543,1,0,0,0,3920,3923,
        3,604,302,0,3921,3923,3,626,313,0,3922,3920,1,0,0,0,3922,3921,1,
        0,0,0,3923,545,1,0,0,0,3924,3927,3,584,292,0,3925,3927,3,626,313,
        0,3926,3924,1,0,0,0,3926,3925,1,0,0,0,3927,547,1,0,0,0,3928,3933,
        3,546,273,0,3929,3930,5,320,0,0,3930,3932,3,546,273,0,3931,3929,
        1,0,0,0,3932,3935,1,0,0,0,3933,3931,1,0,0,0,3933,3934,1,0,0,0,3934,
        3937,1,0,0,0,3935,3933,1,0,0,0,3936,3928,1,0,0,0,3936,3937,1,0,0,
        0,3937,549,1,0,0,0,3938,3941,3,586,293,0,3939,3941,3,626,313,0,3940,
        3938,1,0,0,0,3940,3939,1,0,0,0,3941,551,1,0,0,0,3942,3945,3,574,
        287,0,3943,3945,3,626,313,0,3944,3942,1,0,0,0,3944,3943,1,0,0,0,
        3945,553,1,0,0,0,3946,3949,3,586,293,0,3947,3949,3,606,303,0,3948,
        3946,1,0,0,0,3948,3947,1,0,0,0,3949,555,1,0,0,0,3950,3952,3,558,
        279,0,3951,3950,1,0,0,0,3951,3952,1,0,0,0,3952,557,1,0,0,0,3953,
        3958,3,338,169,0,3954,3955,5,320,0,0,3955,3957,3,338,169,0,3956,
        3954,1,0,0,0,3957,3960,1,0,0,0,3958,3956,1,0,0,0,3958,3959,1,0,0,
        0,3959,559,1,0,0,0,3960,3958,1,0,0,0,3961,3963,3,562,281,0,3962,
        3961,1,0,0,0,3962,3963,1,0,0,0,3963,561,1,0,0,0,3964,3969,3,624,
        312,0,3965,3966,5,320,0,0,3966,3968,3,624,312,0,3967,3965,1,0,0,
        0,3968,3971,1,0,0,0,3969,3967,1,0,0,0,3969,3970,1,0,0,0,3970,563,
        1,0,0,0,3971,3969,1,0,0,0,3972,3974,3,566,283,0,3973,3972,1,0,0,
        0,3973,3974,1,0,0,0,3974,565,1,0,0,0,3975,3980,3,54,27,0,3976,3977,
        5,320,0,0,3977,3979,3,54,27,0,3978,3976,1,0,0,0,3979,3982,1,0,0,
        0,3980,3978,1,0,0,0,3980,3981,1,0,0,0,3981,567,1,0,0,0,3982,3980,
        1,0,0,0,3983,3992,5,317,0,0,3984,3989,3,584,292,0,3985,3986,5,320,
        0,0,3986,3988,3,584,292,0,3987,3985,1,0,0,0,3988,3991,1,0,0,0,3989,
        3987,1,0,0,0,3989,3990,1,0,0,0,3990,3993,1,0,0,0,3991,3989,1,0,0,
        0,3992,3984,1,0,0,0,3992,3993,1,0,0,0,3993,3994,1,0,0,0,3994,3995,
        5,318,0,0,3995,569,1,0,0,0,3996,3998,3,572,286,0,3997,3996,1,0,0,
        0,3997,3998,1,0,0,0,3998,571,1,0,0,0,3999,4004,3,584,292,0,4000,
        4001,5,320,0,0,4001,4003,3,584,292,0,4002,4000,1,0,0,0,4003,4006,
        1,0,0,0,4004,4002,1,0,0,0,4004,4005,1,0,0,0,4005,573,1,0,0,0,4006,
        4004,1,0,0,0,4007,4010,3,586,293,0,4008,4010,3,606,303,0,4009,4007,
        1,0,0,0,4009,4008,1,0,0,0,4010,575,1,0,0,0,4011,4012,3,596,298,0,
        4012,4013,5,321,0,0,4013,4014,5,321,0,0,4014,4015,3,596,298,0,4015,
        4022,1,0,0,0,4016,4017,3,592,296,0,4017,4018,5,321,0,0,4018,4019,
        5,321,0,0,4019,4020,3,592,296,0,4020,4022,1,0,0,0,4021,4011,1,0,
        0,0,4021,4016,1,0,0,0,4022,577,1,0,0,0,4023,4032,5,315,0,0,4024,
        4029,3,584,292,0,4025,4026,5,320,0,0,4026,4028,3,584,292,0,4027,
        4025,1,0,0,0,4028,4031,1,0,0,0,4029,4027,1,0,0,0,4029,4030,1,0,0,
        0,4030,4033,1,0,0,0,4031,4029,1,0,0,0,4032,4024,1,0,0,0,4032,4033,
        1,0,0,0,4033,4034,1,0,0,0,4034,4035,5,316,0,0,4035,579,1,0,0,0,4036,
        4041,3,594,297,0,4037,4038,5,320,0,0,4038,4040,3,594,297,0,4039,
        4037,1,0,0,0,4040,4043,1,0,0,0,4041,4039,1,0,0,0,4041,4042,1,0,0,
        0,4042,4045,1,0,0,0,4043,4041,1,0,0,0,4044,4036,1,0,0,0,4044,4045,
        1,0,0,0,4045,581,1,0,0,0,4046,4051,3,592,296,0,4047,4048,5,320,0,
        0,4048,4050,3,592,296,0,4049,4047,1,0,0,0,4050,4053,1,0,0,0,4051,
        4049,1,0,0,0,4051,4052,1,0,0,0,4052,583,1,0,0,0,4053,4051,1,0,0,
        0,4054,4078,3,600,300,0,4055,4078,3,602,301,0,4056,4078,3,592,296,
        0,4057,4078,3,604,302,0,4058,4078,3,606,303,0,4059,4078,3,346,173,
        0,4060,4078,3,362,181,0,4061,4078,3,356,178,0,4062,4078,3,352,176,
        0,4063,4078,3,370,185,0,4064,4078,3,372,186,0,4065,4078,3,374,187,
        0,4066,4078,3,578,289,0,4067,4078,3,568,284,0,4068,4078,3,576,288,
        0,4069,4078,3,54,27,0,4070,4078,3,56,28,0,4071,4078,3,612,306,0,
        4072,4078,3,614,307,0,4073,4078,3,616,308,0,4074,4078,3,618,309,
        0,4075,4078,3,620,310,0,4076,4078,3,586,293,0,4077,4054,1,0,0,0,
        4077,4055,1,0,0,0,4077,4056,1,0,0,0,4077,4057,1,0,0,0,4077,4058,
        1,0,0,0,4077,4059,1,0,0,0,4077,4060,1,0,0,0,4077,4061,1,0,0,0,4077,
        4062,1,0,0,0,4077,4063,1,0,0,0,4077,4064,1,0,0,0,4077,4065,1,0,0,
        0,4077,4066,1,0,0,0,4077,4067,1,0,0,0,4077,4068,1,0,0,0,4077,4069,
        1,0,0,0,4077,4070,1,0,0,0,4077,4071,1,0,0,0,4077,4072,1,0,0,0,4077,
        4073,1,0,0,0,4077,4074,1,0,0,0,4077,4075,1,0,0,0,4077,4076,1,0,0,
        0,4078,585,1,0,0,0,4079,4080,5,317,0,0,4080,4081,5,322,0,0,4081,
        4094,5,318,0,0,4082,4083,5,317,0,0,4083,4088,3,590,295,0,4084,4085,
        5,320,0,0,4085,4087,3,590,295,0,4086,4084,1,0,0,0,4087,4090,1,0,
        0,0,4088,4086,1,0,0,0,4088,4089,1,0,0,0,4089,4091,1,0,0,0,4090,4088,
        1,0,0,0,4091,4092,5,318,0,0,4092,4094,1,0,0,0,4093,4079,1,0,0,0,
        4093,4082,1,0,0,0,4094,587,1,0,0,0,4095,4096,5,313,0,0,4096,4097,
        3,346,173,0,4097,4098,5,314,0,0,4098,4101,1,0,0,0,4099,4101,3,350,
        175,0,4100,4095,1,0,0,0,4100,4099,1,0,0,0,4101,4149,1,0,0,0,4102,
        4103,5,313,0,0,4103,4104,3,356,178,0,4104,4105,5,314,0,0,4105,4108,
        1,0,0,0,4106,4108,3,360,180,0,4107,4102,1,0,0,0,4107,4106,1,0,0,
        0,4108,4149,1,0,0,0,4109,4110,5,313,0,0,4110,4111,3,578,289,0,4111,
        4112,5,314,0,0,4112,4115,1,0,0,0,4113,4115,3,578,289,0,4114,4109,
        1,0,0,0,4114,4113,1,0,0,0,4115,4149,1,0,0,0,4116,4117,5,313,0,0,
        4117,4118,3,568,284,0,4118,4119,5,314,0,0,4119,4122,1,0,0,0,4120,
        4122,3,568,284,0,4121,4116,1,0,0,0,4121,4120,1,0,0,0,4122,4149,1,
        0,0,0,4123,4124,5,313,0,0,4124,4125,3,586,293,0,4125,4126,5,314,
        0,0,4126,4129,1,0,0,0,4127,4129,3,586,293,0,4128,4123,1,0,0,0,4128,
        4127,1,0,0,0,4129,4149,1,0,0,0,4130,4131,5,313,0,0,4131,4132,3,592,
        296,0,4132,4133,5,314,0,0,4133,4136,1,0,0,0,4134,4136,3,592,296,
        0,4135,4130,1,0,0,0,4135,4134,1,0,0,0,4136,4149,1,0,0,0,4137,4138,
        5,313,0,0,4138,4139,3,600,300,0,4139,4140,5,314,0,0,4140,4143,1,
        0,0,0,4141,4143,3,600,300,0,4142,4137,1,0,0,0,4142,4141,1,0,0,0,
        4143,4149,1,0,0,0,4144,4147,3,628,314,0,4145,4147,3,622,311,0,4146,
        4144,1,0,0,0,4146,4145,1,0,0,0,4147,4149,1,0,0,0,4148,4100,1,0,0,
        0,4148,4107,1,0,0,0,4148,4114,1,0,0,0,4148,4121,1,0,0,0,4148,4128,
        1,0,0,0,4148,4135,1,0,0,0,4148,4142,1,0,0,0,4148,4146,1,0,0,0,4149,
        589,1,0,0,0,4150,4151,3,588,294,0,4151,4152,5,322,0,0,4152,4153,
        3,584,292,0,4153,591,1,0,0,0,4154,4155,7,2,0,0,4155,593,1,0,0,0,
        4156,4159,3,592,296,0,4157,4159,5,186,0,0,4158,4156,1,0,0,0,4158,
        4157,1,0,0,0,4159,595,1,0,0,0,4160,4161,5,305,0,0,4161,597,1,0,0,
        0,4162,4166,5,306,0,0,4163,4166,3,610,305,0,4164,4166,3,608,304,
        0,4165,4162,1,0,0,0,4165,4163,1,0,0,0,4165,4164,1,0,0,0,4166,599,
        1,0,0,0,4167,4170,3,596,298,0,4168,4170,3,598,299,0,4169,4167,1,
        0,0,0,4169,4168,1,0,0,0,4170,601,1,0,0,0,4171,4172,7,3,0,0,4172,
        603,1,0,0,0,4173,4174,5,60,0,0,4174,4175,5,313,0,0,4175,4176,3,592,
        296,0,4176,4177,5,314,0,0,4177,4190,1,0,0,0,4178,4179,5,60,0,0,4179,
        4180,5,313,0,0,4180,4190,5,314,0,0,4181,4182,5,61,0,0,4182,4183,
        5,313,0,0,4183,4184,3,592,296,0,4184,4185,5,314,0,0,4185,4190,1,
        0,0,0,4186,4187,5,61,0,0,4187,4188,5,313,0,0,4188,4190,5,314,0,0,
        4189,4173,1,0,0,0,4189,4178,1,0,0,0,4189,4181,1,0,0,0,4189,4186,
        1,0,0,0,4190,605,1,0,0,0,4191,4192,5,186,0,0,4192,607,1,0,0,0,4193,
        4194,5,174,0,0,4194,609,1,0,0,0,4195,4196,7,4,0,0,4196,611,1,0,0,
        0,4197,4198,5,282,0,0,4198,4199,5,313,0,0,4199,4206,5,314,0,0,4200,
        4201,5,282,0,0,4201,4202,5,313,0,0,4202,4203,3,592,296,0,4203,4204,
        5,314,0,0,4204,4206,1,0,0,0,4205,4197,1,0,0,0,4205,4200,1,0,0,0,
        4206,613,1,0,0,0,4207,4208,5,308,0,0,4208,615,1,0,0,0,4209,4210,
        5,79,0,0,4210,4211,5,313,0,0,4211,4212,3,596,298,0,4212,4213,5,320,
        0,0,4213,4216,3,596,298,0,4214,4215,5,320,0,0,4215,4217,3,602,301,
        0,4216,4214,1,0,0,0,4216,4217,1,0,0,0,4217,4218,1,0,0,0,4218,4219,
        5,314,0,0,4219,617,1,0,0,0,4220,4221,5,25,0,0,4221,4222,5,313,0,
        0,4222,4223,3,592,296,0,4223,4224,5,314,0,0,4224,619,1,0,0,0,4225,
        4226,5,209,0,0,4226,4227,5,313,0,0,4227,4228,3,592,296,0,4228,4229,
        5,320,0,0,4229,4230,3,586,293,0,4230,4231,5,314,0,0,4231,4240,1,
        0,0,0,4232,4233,5,209,0,0,4233,4234,5,313,0,0,4234,4235,3,592,296,
        0,4235,4236,5,320,0,0,4236,4237,3,592,296,0,4237,4238,5,314,0,0,
        4238,4240,1,0,0,0,4239,4225,1,0,0,0,4239,4232,1,0,0,0,4240,621,1,
        0,0,0,4241,4242,5,327,0,0,4242,623,1,0,0,0,4243,4244,5,327,0,0,4244,
        625,1,0,0,0,4245,4246,5,327,0,0,4246,627,1,0,0,0,4247,4248,7,5,0,
        0,4248,629,1,0,0,0,261,632,637,641,657,666,676,683,707,719,728,751,
        769,776,785,801,814,826,843,848,860,872,894,906,939,958,968,975,
        1120,1132,1144,1156,1173,1178,1205,1225,1235,1250,1325,1355,1362,
        1408,1430,1439,1463,1486,1493,1502,1544,1554,1566,1583,1600,1610,
        1620,1696,1703,1712,1724,1733,1745,1754,1766,1780,1828,1854,1859,
        1877,1882,1892,1906,1921,1931,1955,1970,1980,2000,2015,2025,2079,
        2099,2127,2150,2157,2175,2202,2223,2246,2264,2282,2296,2306,2320,
        2343,2366,2375,2402,2416,2451,2461,2483,2500,2514,2521,2533,2543,
        2558,2568,2589,2605,2609,2633,2639,2647,2653,2657,2664,2673,2676,
        2679,2683,2696,2702,2706,2722,2740,2754,2758,2777,2783,2793,2803,
        2821,2831,2849,2895,2909,2927,3145,3169,3190,3192,3203,3211,3219,
        3229,3235,3241,3251,3257,3263,3273,3279,3285,3295,3301,3307,3317,
        3323,3329,3339,3345,3351,3361,3367,3373,3385,3393,3399,3411,3419,
        3425,3437,3445,3451,3459,3469,3475,3481,3489,3499,3505,3511,3521,
        3531,3537,3543,3553,3559,3565,3575,3581,3587,3597,3603,3609,3619,
        3625,3631,3641,3647,3653,3663,3693,3714,3719,3724,3729,3736,3747,
        3751,3756,3888,3892,3896,3903,3908,3915,3918,3922,3926,3933,3936,
        3940,3944,3948,3951,3958,3962,3969,3973,3980,3989,3992,3997,4004,
        4009,4021,4029,4032,4041,4044,4051,4077,4088,4093,4100,4107,4114,
        4121,4128,4135,4142,4146,4148,4158,4165,4169,4189,4205,4216,4239
    ];

    private static __ATN: antlr.ATN;
    public static get _ATN(): antlr.ATN {
        if (!GremlinParser.__ATN) {
            GremlinParser.__ATN = new antlr.ATNDeserializer().deserialize(GremlinParser._serializedATN);
        }

        return GremlinParser.__ATN;
    }


    private static readonly vocabulary = new antlr.Vocabulary(GremlinParser.literalNames, GremlinParser.symbolicNames, []);

    public override get vocabulary(): antlr.Vocabulary {
        return GremlinParser.vocabulary;
    }

    private static readonly decisionsToDFA = GremlinParser._ATN.decisionToState.map( (ds: antlr.DecisionState, index: number) => new antlr.DFA(ds, index) );
}

export class QueryListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public query(): QueryContext[];
    public query(i: number): QueryContext | null;
    public query(i?: number): QueryContext[] | QueryContext | null {
        if (i === undefined) {
            return this.getRuleContexts(QueryContext);
        }

        return this.getRuleContext(i, QueryContext);
    }
    public EOF(): antlr.TerminalNode {
        return this.getToken(GremlinParser.EOF, 0)!;
    }
    public SEMI(): antlr.TerminalNode[];
    public SEMI(i: number): antlr.TerminalNode | null;
    public SEMI(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.SEMI);
    	} else {
    		return this.getToken(GremlinParser.SEMI, i);
    	}
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_queryList;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterQueryList) {
             listener.enterQueryList(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitQueryList) {
             listener.exitQueryList(this);
        }
    }
}


export class QueryContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalSource(): TraversalSourceContext | null {
        return this.getRuleContext(0, TraversalSourceContext);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public transactionPart(): TransactionPartContext | null {
        return this.getRuleContext(0, TransactionPartContext);
    }
    public rootTraversal(): RootTraversalContext | null {
        return this.getRuleContext(0, RootTraversalContext);
    }
    public traversalTerminalMethod(): TraversalTerminalMethodContext | null {
        return this.getRuleContext(0, TraversalTerminalMethodContext);
    }
    public emptyQuery(): EmptyQueryContext | null {
        return this.getRuleContext(0, EmptyQueryContext);
    }
    public query(): QueryContext | null {
        return this.getRuleContext(0, QueryContext);
    }
    public K_TOSTRING(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TOSTRING, 0);
    }
    public LPAREN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.LPAREN, 0);
    }
    public RPAREN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.RPAREN, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_query;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterQuery) {
             listener.enterQuery(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitQuery) {
             listener.exitQuery(this);
        }
    }
}


export class EmptyQueryContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public EmptyStringLiteral(): antlr.TerminalNode {
        return this.getToken(GremlinParser.EmptyStringLiteral, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_emptyQuery;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterEmptyQuery) {
             listener.enterEmptyQuery(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitEmptyQuery) {
             listener.exitEmptyQuery(this);
        }
    }
}


export class TraversalSourceContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public TRAVERSAL_ROOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.TRAVERSAL_ROOT, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public traversalSourceSelfMethod(): TraversalSourceSelfMethodContext | null {
        return this.getRuleContext(0, TraversalSourceSelfMethodContext);
    }
    public traversalSource(): TraversalSourceContext | null {
        return this.getRuleContext(0, TraversalSourceContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSource;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSource) {
             listener.enterTraversalSource(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSource) {
             listener.exitTraversalSource(this);
        }
    }
}


export class TransactionPartContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_TX(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TX, 0)!;
    }
    public LPAREN(): antlr.TerminalNode[];
    public LPAREN(i: number): antlr.TerminalNode | null;
    public LPAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.LPAREN);
    	} else {
    		return this.getToken(GremlinParser.LPAREN, i);
    	}
    }
    public RPAREN(): antlr.TerminalNode[];
    public RPAREN(i: number): antlr.TerminalNode | null;
    public RPAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.RPAREN);
    	} else {
    		return this.getToken(GremlinParser.RPAREN, i);
    	}
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_BEGIN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BEGIN, 0);
    }
    public K_COMMIT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_COMMIT, 0);
    }
    public K_ROLLBACK(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ROLLBACK, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_transactionPart;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTransactionPart) {
             listener.enterTransactionPart(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTransactionPart) {
             listener.exitTransactionPart(this);
        }
    }
}


export class RootTraversalContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalSource(): TraversalSourceContext {
        return this.getRuleContext(0, TraversalSourceContext)!;
    }
    public DOT(): antlr.TerminalNode[];
    public DOT(i: number): antlr.TerminalNode | null;
    public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.DOT);
    	} else {
    		return this.getToken(GremlinParser.DOT, i);
    	}
    }
    public traversalSourceSpawnMethod(): TraversalSourceSpawnMethodContext {
        return this.getRuleContext(0, TraversalSourceSpawnMethodContext)!;
    }
    public chainedTraversal(): ChainedTraversalContext | null {
        return this.getRuleContext(0, ChainedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_rootTraversal;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterRootTraversal) {
             listener.enterRootTraversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitRootTraversal) {
             listener.exitRootTraversal(this);
        }
    }
}


export class TraversalSourceSelfMethodContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalSourceSelfMethod_withBulk(): TraversalSourceSelfMethod_withBulkContext | null {
        return this.getRuleContext(0, TraversalSourceSelfMethod_withBulkContext);
    }
    public traversalSourceSelfMethod_withPath(): TraversalSourceSelfMethod_withPathContext | null {
        return this.getRuleContext(0, TraversalSourceSelfMethod_withPathContext);
    }
    public traversalSourceSelfMethod_withSack(): TraversalSourceSelfMethod_withSackContext | null {
        return this.getRuleContext(0, TraversalSourceSelfMethod_withSackContext);
    }
    public traversalSourceSelfMethod_withSideEffect(): TraversalSourceSelfMethod_withSideEffectContext | null {
        return this.getRuleContext(0, TraversalSourceSelfMethod_withSideEffectContext);
    }
    public traversalSourceSelfMethod_withStrategies(): TraversalSourceSelfMethod_withStrategiesContext | null {
        return this.getRuleContext(0, TraversalSourceSelfMethod_withStrategiesContext);
    }
    public traversalSourceSelfMethod_withoutStrategies(): TraversalSourceSelfMethod_withoutStrategiesContext | null {
        return this.getRuleContext(0, TraversalSourceSelfMethod_withoutStrategiesContext);
    }
    public traversalSourceSelfMethod_with(): TraversalSourceSelfMethod_withContext | null {
        return this.getRuleContext(0, TraversalSourceSelfMethod_withContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSelfMethod;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSelfMethod) {
             listener.enterTraversalSourceSelfMethod(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSelfMethod) {
             listener.exitTraversalSourceSelfMethod(this);
        }
    }
}


export class TraversalSourceSelfMethod_withBulkContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_WITHBULK(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WITHBULK, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public booleanLiteral(): BooleanLiteralContext {
        return this.getRuleContext(0, BooleanLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSelfMethod_withBulk;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSelfMethod_withBulk) {
             listener.enterTraversalSourceSelfMethod_withBulk(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSelfMethod_withBulk) {
             listener.exitTraversalSourceSelfMethod_withBulk(this);
        }
    }
}


export class TraversalSourceSelfMethod_withPathContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_WITHPATH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WITHPATH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSelfMethod_withPath;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSelfMethod_withPath) {
             listener.enterTraversalSourceSelfMethod_withPath(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSelfMethod_withPath) {
             listener.exitTraversalSourceSelfMethod_withPath(this);
        }
    }
}


export class TraversalSourceSelfMethod_withSackContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_WITHSACK(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WITHSACK, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public traversalBiFunction(): TraversalBiFunctionContext | null {
        return this.getRuleContext(0, TraversalBiFunctionContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSelfMethod_withSack;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSelfMethod_withSack) {
             listener.enterTraversalSourceSelfMethod_withSack(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSelfMethod_withSack) {
             listener.exitTraversalSourceSelfMethod_withSack(this);
        }
    }
}


export class TraversalSourceSelfMethod_withSideEffectContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_WITHSIDEEFFECT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WITHSIDEEFFECT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public traversalBiFunction(): TraversalBiFunctionContext | null {
        return this.getRuleContext(0, TraversalBiFunctionContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSelfMethod_withSideEffect;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSelfMethod_withSideEffect) {
             listener.enterTraversalSourceSelfMethod_withSideEffect(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSelfMethod_withSideEffect) {
             listener.exitTraversalSourceSelfMethod_withSideEffect(this);
        }
    }
}


export class TraversalSourceSelfMethod_withStrategiesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_WITHSTRATEGIES(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WITHSTRATEGIES, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalStrategy(): TraversalStrategyContext {
        return this.getRuleContext(0, TraversalStrategyContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public traversalStrategyVarargs(): TraversalStrategyVarargsContext | null {
        return this.getRuleContext(0, TraversalStrategyVarargsContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSelfMethod_withStrategies;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSelfMethod_withStrategies) {
             listener.enterTraversalSourceSelfMethod_withStrategies(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSelfMethod_withStrategies) {
             listener.exitTraversalSourceSelfMethod_withStrategies(this);
        }
    }
}


export class TraversalSourceSelfMethod_withoutStrategiesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_WITHOUTSTRATEGIES(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WITHOUTSTRATEGIES, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public classType(): ClassTypeContext {
        return this.getRuleContext(0, ClassTypeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public classTypeList(): ClassTypeListContext | null {
        return this.getRuleContext(0, ClassTypeListContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSelfMethod_withoutStrategies;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSelfMethod_withoutStrategies) {
             listener.enterTraversalSourceSelfMethod_withoutStrategies(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSelfMethod_withoutStrategies) {
             listener.exitTraversalSourceSelfMethod_withoutStrategies(this);
        }
    }
}


export class TraversalSourceSelfMethod_withContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_WITH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WITH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public genericLiteral(): GenericLiteralContext | null {
        return this.getRuleContext(0, GenericLiteralContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSelfMethod_with;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSelfMethod_with) {
             listener.enterTraversalSourceSelfMethod_with(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSelfMethod_with) {
             listener.exitTraversalSourceSelfMethod_with(this);
        }
    }
}


export class TraversalSourceSpawnMethodContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalSourceSpawnMethod_addE(): TraversalSourceSpawnMethod_addEContext | null {
        return this.getRuleContext(0, TraversalSourceSpawnMethod_addEContext);
    }
    public traversalSourceSpawnMethod_addV(): TraversalSourceSpawnMethod_addVContext | null {
        return this.getRuleContext(0, TraversalSourceSpawnMethod_addVContext);
    }
    public traversalSourceSpawnMethod_E(): TraversalSourceSpawnMethod_EContext | null {
        return this.getRuleContext(0, TraversalSourceSpawnMethod_EContext);
    }
    public traversalSourceSpawnMethod_V(): TraversalSourceSpawnMethod_VContext | null {
        return this.getRuleContext(0, TraversalSourceSpawnMethod_VContext);
    }
    public traversalSourceSpawnMethod_mergeE(): TraversalSourceSpawnMethod_mergeEContext | null {
        return this.getRuleContext(0, TraversalSourceSpawnMethod_mergeEContext);
    }
    public traversalSourceSpawnMethod_mergeV(): TraversalSourceSpawnMethod_mergeVContext | null {
        return this.getRuleContext(0, TraversalSourceSpawnMethod_mergeVContext);
    }
    public traversalSourceSpawnMethod_inject(): TraversalSourceSpawnMethod_injectContext | null {
        return this.getRuleContext(0, TraversalSourceSpawnMethod_injectContext);
    }
    public traversalSourceSpawnMethod_io(): TraversalSourceSpawnMethod_ioContext | null {
        return this.getRuleContext(0, TraversalSourceSpawnMethod_ioContext);
    }
    public traversalSourceSpawnMethod_call(): TraversalSourceSpawnMethod_callContext | null {
        return this.getRuleContext(0, TraversalSourceSpawnMethod_callContext);
    }
    public traversalSourceSpawnMethod_union(): TraversalSourceSpawnMethod_unionContext | null {
        return this.getRuleContext(0, TraversalSourceSpawnMethod_unionContext);
    }
    public traversalSourceSpawnMethod_match(): TraversalSourceSpawnMethod_matchContext | null {
        return this.getRuleContext(0, TraversalSourceSpawnMethod_matchContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSpawnMethod;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod) {
             listener.enterTraversalSourceSpawnMethod(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod) {
             listener.exitTraversalSourceSpawnMethod(this);
        }
    }
}


export class TraversalSourceSpawnMethod_addEContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_ADDE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ADDE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringArgument(): StringArgumentContext | null {
        return this.getRuleContext(0, StringArgumentContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSpawnMethod_addE;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_addE) {
             listener.enterTraversalSourceSpawnMethod_addE(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_addE) {
             listener.exitTraversalSourceSpawnMethod_addE(this);
        }
    }
}


export class TraversalSourceSpawnMethod_addVContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSpawnMethod_addV;
    }
    public override copyFrom(ctx: TraversalSourceSpawnMethod_addVContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalSourceSpawnMethod_addV_EmptyContext extends TraversalSourceSpawnMethod_addVContext {
    public constructor(ctx: TraversalSourceSpawnMethod_addVContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ADDV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ADDV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_addV_Empty) {
             listener.enterTraversalSourceSpawnMethod_addV_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_addV_Empty) {
             listener.exitTraversalSourceSpawnMethod_addV_Empty(this);
        }
    }
}
export class TraversalSourceSpawnMethod_addV_StringContext extends TraversalSourceSpawnMethod_addVContext {
    public constructor(ctx: TraversalSourceSpawnMethod_addVContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ADDV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ADDV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringArgumentVarargs(): StringArgumentVarargsContext {
        return this.getRuleContext(0, StringArgumentVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_addV_String) {
             listener.enterTraversalSourceSpawnMethod_addV_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_addV_String) {
             listener.exitTraversalSourceSpawnMethod_addV_String(this);
        }
    }
}
export class TraversalSourceSpawnMethod_addV_TraversalContext extends TraversalSourceSpawnMethod_addVContext {
    public constructor(ctx: TraversalSourceSpawnMethod_addVContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ADDV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ADDV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext[];
    public nestedTraversal(i: number): NestedTraversalContext | null;
    public nestedTraversal(i?: number): NestedTraversalContext[] | NestedTraversalContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NestedTraversalContext);
        }

        return this.getRuleContext(i, NestedTraversalContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_addV_Traversal) {
             listener.enterTraversalSourceSpawnMethod_addV_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_addV_Traversal) {
             listener.exitTraversalSourceSpawnMethod_addV_Traversal(this);
        }
    }
}


export class TraversalSourceSpawnMethod_EContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_E(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_E, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgumentVarargs(): GenericArgumentVarargsContext | null {
        return this.getRuleContext(0, GenericArgumentVarargsContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSpawnMethod_E;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_E) {
             listener.enterTraversalSourceSpawnMethod_E(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_E) {
             listener.exitTraversalSourceSpawnMethod_E(this);
        }
    }
}


export class TraversalSourceSpawnMethod_VContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_V(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_V, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgumentVarargs(): GenericArgumentVarargsContext | null {
        return this.getRuleContext(0, GenericArgumentVarargsContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSpawnMethod_V;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_V) {
             listener.enterTraversalSourceSpawnMethod_V(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_V) {
             listener.exitTraversalSourceSpawnMethod_V(this);
        }
    }
}


export class TraversalSourceSpawnMethod_injectContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_INJECT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_INJECT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericLiteralVarargs(): GenericLiteralVarargsContext {
        return this.getRuleContext(0, GenericLiteralVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSpawnMethod_inject;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_inject) {
             listener.enterTraversalSourceSpawnMethod_inject(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_inject) {
             listener.exitTraversalSourceSpawnMethod_inject(this);
        }
    }
}


export class TraversalSourceSpawnMethod_ioContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_IO(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_IO, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSpawnMethod_io;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_io) {
             listener.enterTraversalSourceSpawnMethod_io(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_io) {
             listener.exitTraversalSourceSpawnMethod_io(this);
        }
    }
}


export class TraversalSourceSpawnMethod_mergeVContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSpawnMethod_mergeV;
    }
    public override copyFrom(ctx: TraversalSourceSpawnMethod_mergeVContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalSourceSpawnMethod_mergeV_MapContext extends TraversalSourceSpawnMethod_mergeVContext {
    public constructor(ctx: TraversalSourceSpawnMethod_mergeVContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MERGEV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MERGEV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericMapNullableArgument(): GenericMapNullableArgumentContext {
        return this.getRuleContext(0, GenericMapNullableArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_mergeV_Map) {
             listener.enterTraversalSourceSpawnMethod_mergeV_Map(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_mergeV_Map) {
             listener.exitTraversalSourceSpawnMethod_mergeV_Map(this);
        }
    }
}
export class TraversalSourceSpawnMethod_mergeV_TraversalContext extends TraversalSourceSpawnMethod_mergeVContext {
    public constructor(ctx: TraversalSourceSpawnMethod_mergeVContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MERGEV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MERGEV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_mergeV_Traversal) {
             listener.enterTraversalSourceSpawnMethod_mergeV_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_mergeV_Traversal) {
             listener.exitTraversalSourceSpawnMethod_mergeV_Traversal(this);
        }
    }
}


export class TraversalSourceSpawnMethod_mergeEContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSpawnMethod_mergeE;
    }
    public override copyFrom(ctx: TraversalSourceSpawnMethod_mergeEContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalSourceSpawnMethod_mergeE_MapContext extends TraversalSourceSpawnMethod_mergeEContext {
    public constructor(ctx: TraversalSourceSpawnMethod_mergeEContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MERGEE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MERGEE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericMapNullableArgument(): GenericMapNullableArgumentContext {
        return this.getRuleContext(0, GenericMapNullableArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_mergeE_Map) {
             listener.enterTraversalSourceSpawnMethod_mergeE_Map(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_mergeE_Map) {
             listener.exitTraversalSourceSpawnMethod_mergeE_Map(this);
        }
    }
}
export class TraversalSourceSpawnMethod_mergeE_TraversalContext extends TraversalSourceSpawnMethod_mergeEContext {
    public constructor(ctx: TraversalSourceSpawnMethod_mergeEContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MERGEE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MERGEE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_mergeE_Traversal) {
             listener.enterTraversalSourceSpawnMethod_mergeE_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_mergeE_Traversal) {
             listener.exitTraversalSourceSpawnMethod_mergeE_Traversal(this);
        }
    }
}


export class TraversalSourceSpawnMethod_callContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSpawnMethod_call;
    }
    public override copyFrom(ctx: TraversalSourceSpawnMethod_callContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalSourceSpawnMethod_call_emptyContext extends TraversalSourceSpawnMethod_callContext {
    public constructor(ctx: TraversalSourceSpawnMethod_callContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CALL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CALL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_call_empty) {
             listener.enterTraversalSourceSpawnMethod_call_empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_call_empty) {
             listener.exitTraversalSourceSpawnMethod_call_empty(this);
        }
    }
}
export class TraversalSourceSpawnMethod_call_stringContext extends TraversalSourceSpawnMethod_callContext {
    public constructor(ctx: TraversalSourceSpawnMethod_callContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CALL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CALL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_call_string) {
             listener.enterTraversalSourceSpawnMethod_call_string(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_call_string) {
             listener.exitTraversalSourceSpawnMethod_call_string(this);
        }
    }
}
export class TraversalSourceSpawnMethod_call_string_mapContext extends TraversalSourceSpawnMethod_callContext {
    public constructor(ctx: TraversalSourceSpawnMethod_callContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CALL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CALL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public genericMapArgument(): GenericMapArgumentContext {
        return this.getRuleContext(0, GenericMapArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_call_string_map) {
             listener.enterTraversalSourceSpawnMethod_call_string_map(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_call_string_map) {
             listener.exitTraversalSourceSpawnMethod_call_string_map(this);
        }
    }
}
export class TraversalSourceSpawnMethod_call_string_traversalContext extends TraversalSourceSpawnMethod_callContext {
    public constructor(ctx: TraversalSourceSpawnMethod_callContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CALL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CALL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_call_string_traversal) {
             listener.enterTraversalSourceSpawnMethod_call_string_traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_call_string_traversal) {
             listener.exitTraversalSourceSpawnMethod_call_string_traversal(this);
        }
    }
}
export class TraversalSourceSpawnMethod_call_string_map_traversalContext extends TraversalSourceSpawnMethod_callContext {
    public constructor(ctx: TraversalSourceSpawnMethod_callContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CALL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CALL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public genericMapArgument(): GenericMapArgumentContext {
        return this.getRuleContext(0, GenericMapArgumentContext)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_call_string_map_traversal) {
             listener.enterTraversalSourceSpawnMethod_call_string_map_traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_call_string_map_traversal) {
             listener.exitTraversalSourceSpawnMethod_call_string_map_traversal(this);
        }
    }
}


export class TraversalSourceSpawnMethod_unionContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_UNION(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_UNION, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversalList(): NestedTraversalListContext {
        return this.getRuleContext(0, NestedTraversalListContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSpawnMethod_union;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_union) {
             listener.enterTraversalSourceSpawnMethod_union(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_union) {
             listener.exitTraversalSourceSpawnMethod_union(this);
        }
    }
}


export class TraversalSourceSpawnMethod_matchContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSourceSpawnMethod_match;
    }
    public override copyFrom(ctx: TraversalSourceSpawnMethod_matchContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalSourceSpawnMethod_match_stringContext extends TraversalSourceSpawnMethod_matchContext {
    public constructor(ctx: TraversalSourceSpawnMethod_matchContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MATCH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MATCH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_match_string) {
             listener.enterTraversalSourceSpawnMethod_match_string(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_match_string) {
             listener.exitTraversalSourceSpawnMethod_match_string(this);
        }
    }
}
export class TraversalSourceSpawnMethod_match_string_mapContext extends TraversalSourceSpawnMethod_matchContext {
    public constructor(ctx: TraversalSourceSpawnMethod_matchContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MATCH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MATCH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public genericMapLiteral(): GenericMapLiteralContext {
        return this.getRuleContext(0, GenericMapLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSourceSpawnMethod_match_string_map) {
             listener.enterTraversalSourceSpawnMethod_match_string_map(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSourceSpawnMethod_match_string_map) {
             listener.exitTraversalSourceSpawnMethod_match_string_map(this);
        }
    }
}


export class ChainedTraversalContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalMethod(): TraversalMethodContext {
        return this.getRuleContext(0, TraversalMethodContext)!;
    }
    public chainedTraversal(): ChainedTraversalContext | null {
        return this.getRuleContext(0, ChainedTraversalContext);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_chainedTraversal;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterChainedTraversal) {
             listener.enterChainedTraversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitChainedTraversal) {
             listener.exitChainedTraversal(this);
        }
    }
}


export class NestedTraversalContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public chainedTraversal(): ChainedTraversalContext {
        return this.getRuleContext(0, ChainedTraversalContext)!;
    }
    public ANON_TRAVERSAL_ROOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.ANON_TRAVERSAL_ROOT, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_nestedTraversal;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterNestedTraversal) {
             listener.enterNestedTraversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitNestedTraversal) {
             listener.exitNestedTraversal(this);
        }
    }
}


export class TerminatedTraversalContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public rootTraversal(): RootTraversalContext {
        return this.getRuleContext(0, RootTraversalContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public traversalTerminalMethod(): TraversalTerminalMethodContext {
        return this.getRuleContext(0, TraversalTerminalMethodContext)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_terminatedTraversal;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTerminatedTraversal) {
             listener.enterTerminatedTraversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTerminatedTraversal) {
             listener.exitTerminatedTraversal(this);
        }
    }
}


export class TraversalMethodContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalMethod_V(): TraversalMethod_VContext | null {
        return this.getRuleContext(0, TraversalMethod_VContext);
    }
    public traversalMethod_E(): TraversalMethod_EContext | null {
        return this.getRuleContext(0, TraversalMethod_EContext);
    }
    public traversalMethod_addE(): TraversalMethod_addEContext | null {
        return this.getRuleContext(0, TraversalMethod_addEContext);
    }
    public traversalMethod_addV(): TraversalMethod_addVContext | null {
        return this.getRuleContext(0, TraversalMethod_addVContext);
    }
    public traversalMethod_mergeE(): TraversalMethod_mergeEContext | null {
        return this.getRuleContext(0, TraversalMethod_mergeEContext);
    }
    public traversalMethod_mergeV(): TraversalMethod_mergeVContext | null {
        return this.getRuleContext(0, TraversalMethod_mergeVContext);
    }
    public traversalMethod_aggregate(): TraversalMethod_aggregateContext | null {
        return this.getRuleContext(0, TraversalMethod_aggregateContext);
    }
    public traversalMethod_all(): TraversalMethod_allContext | null {
        return this.getRuleContext(0, TraversalMethod_allContext);
    }
    public traversalMethod_and(): TraversalMethod_andContext | null {
        return this.getRuleContext(0, TraversalMethod_andContext);
    }
    public traversalMethod_any(): TraversalMethod_anyContext | null {
        return this.getRuleContext(0, TraversalMethod_anyContext);
    }
    public traversalMethod_as(): TraversalMethod_asContext | null {
        return this.getRuleContext(0, TraversalMethod_asContext);
    }
    public traversalMethod_barrier(): TraversalMethod_barrierContext | null {
        return this.getRuleContext(0, TraversalMethod_barrierContext);
    }
    public traversalMethod_both(): TraversalMethod_bothContext | null {
        return this.getRuleContext(0, TraversalMethod_bothContext);
    }
    public traversalMethod_bothE(): TraversalMethod_bothEContext | null {
        return this.getRuleContext(0, TraversalMethod_bothEContext);
    }
    public traversalMethod_bothV(): TraversalMethod_bothVContext | null {
        return this.getRuleContext(0, TraversalMethod_bothVContext);
    }
    public traversalMethod_branch(): TraversalMethod_branchContext | null {
        return this.getRuleContext(0, TraversalMethod_branchContext);
    }
    public traversalMethod_by(): TraversalMethod_byContext | null {
        return this.getRuleContext(0, TraversalMethod_byContext);
    }
    public traversalMethod_cap(): TraversalMethod_capContext | null {
        return this.getRuleContext(0, TraversalMethod_capContext);
    }
    public traversalMethod_choose(): TraversalMethod_chooseContext | null {
        return this.getRuleContext(0, TraversalMethod_chooseContext);
    }
    public traversalMethod_coalesce(): TraversalMethod_coalesceContext | null {
        return this.getRuleContext(0, TraversalMethod_coalesceContext);
    }
    public traversalMethod_coin(): TraversalMethod_coinContext | null {
        return this.getRuleContext(0, TraversalMethod_coinContext);
    }
    public traversalMethod_conjoin(): TraversalMethod_conjoinContext | null {
        return this.getRuleContext(0, TraversalMethod_conjoinContext);
    }
    public traversalMethod_connectedComponent(): TraversalMethod_connectedComponentContext | null {
        return this.getRuleContext(0, TraversalMethod_connectedComponentContext);
    }
    public traversalMethod_constant(): TraversalMethod_constantContext | null {
        return this.getRuleContext(0, TraversalMethod_constantContext);
    }
    public traversalMethod_count(): TraversalMethod_countContext | null {
        return this.getRuleContext(0, TraversalMethod_countContext);
    }
    public traversalMethod_cyclicPath(): TraversalMethod_cyclicPathContext | null {
        return this.getRuleContext(0, TraversalMethod_cyclicPathContext);
    }
    public traversalMethod_dedup(): TraversalMethod_dedupContext | null {
        return this.getRuleContext(0, TraversalMethod_dedupContext);
    }
    public traversalMethod_difference(): TraversalMethod_differenceContext | null {
        return this.getRuleContext(0, TraversalMethod_differenceContext);
    }
    public traversalMethod_discard(): TraversalMethod_discardContext | null {
        return this.getRuleContext(0, TraversalMethod_discardContext);
    }
    public traversalMethod_disjunct(): TraversalMethod_disjunctContext | null {
        return this.getRuleContext(0, TraversalMethod_disjunctContext);
    }
    public traversalMethod_drop(): TraversalMethod_dropContext | null {
        return this.getRuleContext(0, TraversalMethod_dropContext);
    }
    public traversalMethod_elementMap(): TraversalMethod_elementMapContext | null {
        return this.getRuleContext(0, TraversalMethod_elementMapContext);
    }
    public traversalMethod_emit(): TraversalMethod_emitContext | null {
        return this.getRuleContext(0, TraversalMethod_emitContext);
    }
    public traversalMethod_filter(): TraversalMethod_filterContext | null {
        return this.getRuleContext(0, TraversalMethod_filterContext);
    }
    public traversalMethod_flatMap(): TraversalMethod_flatMapContext | null {
        return this.getRuleContext(0, TraversalMethod_flatMapContext);
    }
    public traversalMethod_fold(): TraversalMethod_foldContext | null {
        return this.getRuleContext(0, TraversalMethod_foldContext);
    }
    public traversalMethod_from(): TraversalMethod_fromContext | null {
        return this.getRuleContext(0, TraversalMethod_fromContext);
    }
    public traversalMethod_group(): TraversalMethod_groupContext | null {
        return this.getRuleContext(0, TraversalMethod_groupContext);
    }
    public traversalMethod_groupCount(): TraversalMethod_groupCountContext | null {
        return this.getRuleContext(0, TraversalMethod_groupCountContext);
    }
    public traversalMethod_has(): TraversalMethod_hasContext | null {
        return this.getRuleContext(0, TraversalMethod_hasContext);
    }
    public traversalMethod_hasId(): TraversalMethod_hasIdContext | null {
        return this.getRuleContext(0, TraversalMethod_hasIdContext);
    }
    public traversalMethod_hasKey(): TraversalMethod_hasKeyContext | null {
        return this.getRuleContext(0, TraversalMethod_hasKeyContext);
    }
    public traversalMethod_hasLabel(): TraversalMethod_hasLabelContext | null {
        return this.getRuleContext(0, TraversalMethod_hasLabelContext);
    }
    public traversalMethod_hasNot(): TraversalMethod_hasNotContext | null {
        return this.getRuleContext(0, TraversalMethod_hasNotContext);
    }
    public traversalMethod_hasValue(): TraversalMethod_hasValueContext | null {
        return this.getRuleContext(0, TraversalMethod_hasValueContext);
    }
    public traversalMethod_id(): TraversalMethod_idContext | null {
        return this.getRuleContext(0, TraversalMethod_idContext);
    }
    public traversalMethod_identity(): TraversalMethod_identityContext | null {
        return this.getRuleContext(0, TraversalMethod_identityContext);
    }
    public traversalMethod_in(): TraversalMethod_inContext | null {
        return this.getRuleContext(0, TraversalMethod_inContext);
    }
    public traversalMethod_inE(): TraversalMethod_inEContext | null {
        return this.getRuleContext(0, TraversalMethod_inEContext);
    }
    public traversalMethod_intersect(): TraversalMethod_intersectContext | null {
        return this.getRuleContext(0, TraversalMethod_intersectContext);
    }
    public traversalMethod_inV(): TraversalMethod_inVContext | null {
        return this.getRuleContext(0, TraversalMethod_inVContext);
    }
    public traversalMethod_index(): TraversalMethod_indexContext | null {
        return this.getRuleContext(0, TraversalMethod_indexContext);
    }
    public traversalMethod_inject(): TraversalMethod_injectContext | null {
        return this.getRuleContext(0, TraversalMethod_injectContext);
    }
    public traversalMethod_is(): TraversalMethod_isContext | null {
        return this.getRuleContext(0, TraversalMethod_isContext);
    }
    public traversalMethod_key(): TraversalMethod_keyContext | null {
        return this.getRuleContext(0, TraversalMethod_keyContext);
    }
    public traversalMethod_label(): TraversalMethod_labelContext | null {
        return this.getRuleContext(0, TraversalMethod_labelContext);
    }
    public traversalMethod_limit(): TraversalMethod_limitContext | null {
        return this.getRuleContext(0, TraversalMethod_limitContext);
    }
    public traversalMethod_local(): TraversalMethod_localContext | null {
        return this.getRuleContext(0, TraversalMethod_localContext);
    }
    public traversalMethod_loops(): TraversalMethod_loopsContext | null {
        return this.getRuleContext(0, TraversalMethod_loopsContext);
    }
    public traversalMethod_map(): TraversalMethod_mapContext | null {
        return this.getRuleContext(0, TraversalMethod_mapContext);
    }
    public traversalMethod_match(): TraversalMethod_matchContext | null {
        return this.getRuleContext(0, TraversalMethod_matchContext);
    }
    public traversalMethod_math(): TraversalMethod_mathContext | null {
        return this.getRuleContext(0, TraversalMethod_mathContext);
    }
    public traversalMethod_max(): TraversalMethod_maxContext | null {
        return this.getRuleContext(0, TraversalMethod_maxContext);
    }
    public traversalMethod_mean(): TraversalMethod_meanContext | null {
        return this.getRuleContext(0, TraversalMethod_meanContext);
    }
    public traversalMethod_min(): TraversalMethod_minContext | null {
        return this.getRuleContext(0, TraversalMethod_minContext);
    }
    public traversalMethod_none(): TraversalMethod_noneContext | null {
        return this.getRuleContext(0, TraversalMethod_noneContext);
    }
    public traversalMethod_not(): TraversalMethod_notContext | null {
        return this.getRuleContext(0, TraversalMethod_notContext);
    }
    public traversalMethod_option(): TraversalMethod_optionContext | null {
        return this.getRuleContext(0, TraversalMethod_optionContext);
    }
    public traversalMethod_optional(): TraversalMethod_optionalContext | null {
        return this.getRuleContext(0, TraversalMethod_optionalContext);
    }
    public traversalMethod_or(): TraversalMethod_orContext | null {
        return this.getRuleContext(0, TraversalMethod_orContext);
    }
    public traversalMethod_order(): TraversalMethod_orderContext | null {
        return this.getRuleContext(0, TraversalMethod_orderContext);
    }
    public traversalMethod_otherV(): TraversalMethod_otherVContext | null {
        return this.getRuleContext(0, TraversalMethod_otherVContext);
    }
    public traversalMethod_out(): TraversalMethod_outContext | null {
        return this.getRuleContext(0, TraversalMethod_outContext);
    }
    public traversalMethod_outE(): TraversalMethod_outEContext | null {
        return this.getRuleContext(0, TraversalMethod_outEContext);
    }
    public traversalMethod_outV(): TraversalMethod_outVContext | null {
        return this.getRuleContext(0, TraversalMethod_outVContext);
    }
    public traversalMethod_pageRank(): TraversalMethod_pageRankContext | null {
        return this.getRuleContext(0, TraversalMethod_pageRankContext);
    }
    public traversalMethod_path(): TraversalMethod_pathContext | null {
        return this.getRuleContext(0, TraversalMethod_pathContext);
    }
    public traversalMethod_peerPressure(): TraversalMethod_peerPressureContext | null {
        return this.getRuleContext(0, TraversalMethod_peerPressureContext);
    }
    public traversalMethod_profile(): TraversalMethod_profileContext | null {
        return this.getRuleContext(0, TraversalMethod_profileContext);
    }
    public traversalMethod_project(): TraversalMethod_projectContext | null {
        return this.getRuleContext(0, TraversalMethod_projectContext);
    }
    public traversalMethod_properties(): TraversalMethod_propertiesContext | null {
        return this.getRuleContext(0, TraversalMethod_propertiesContext);
    }
    public traversalMethod_property(): TraversalMethod_propertyContext | null {
        return this.getRuleContext(0, TraversalMethod_propertyContext);
    }
    public traversalMethod_propertyMap(): TraversalMethod_propertyMapContext | null {
        return this.getRuleContext(0, TraversalMethod_propertyMapContext);
    }
    public traversalMethod_range(): TraversalMethod_rangeContext | null {
        return this.getRuleContext(0, TraversalMethod_rangeContext);
    }
    public traversalMethod_read(): TraversalMethod_readContext | null {
        return this.getRuleContext(0, TraversalMethod_readContext);
    }
    public traversalMethod_repeat(): TraversalMethod_repeatContext | null {
        return this.getRuleContext(0, TraversalMethod_repeatContext);
    }
    public traversalMethod_sack(): TraversalMethod_sackContext | null {
        return this.getRuleContext(0, TraversalMethod_sackContext);
    }
    public traversalMethod_sample(): TraversalMethod_sampleContext | null {
        return this.getRuleContext(0, TraversalMethod_sampleContext);
    }
    public traversalMethod_select(): TraversalMethod_selectContext | null {
        return this.getRuleContext(0, TraversalMethod_selectContext);
    }
    public traversalMethod_combine(): TraversalMethod_combineContext | null {
        return this.getRuleContext(0, TraversalMethod_combineContext);
    }
    public traversalMethod_product(): TraversalMethod_productContext | null {
        return this.getRuleContext(0, TraversalMethod_productContext);
    }
    public traversalMethod_merge(): TraversalMethod_mergeContext | null {
        return this.getRuleContext(0, TraversalMethod_mergeContext);
    }
    public traversalMethod_shortestPath(): TraversalMethod_shortestPathContext | null {
        return this.getRuleContext(0, TraversalMethod_shortestPathContext);
    }
    public traversalMethod_sideEffect(): TraversalMethod_sideEffectContext | null {
        return this.getRuleContext(0, TraversalMethod_sideEffectContext);
    }
    public traversalMethod_simplePath(): TraversalMethod_simplePathContext | null {
        return this.getRuleContext(0, TraversalMethod_simplePathContext);
    }
    public traversalMethod_skip(): TraversalMethod_skipContext | null {
        return this.getRuleContext(0, TraversalMethod_skipContext);
    }
    public traversalMethod_subgraph(): TraversalMethod_subgraphContext | null {
        return this.getRuleContext(0, TraversalMethod_subgraphContext);
    }
    public traversalMethod_sum(): TraversalMethod_sumContext | null {
        return this.getRuleContext(0, TraversalMethod_sumContext);
    }
    public traversalMethod_tail(): TraversalMethod_tailContext | null {
        return this.getRuleContext(0, TraversalMethod_tailContext);
    }
    public traversalMethod_fail(): TraversalMethod_failContext | null {
        return this.getRuleContext(0, TraversalMethod_failContext);
    }
    public traversalMethod_timeLimit(): TraversalMethod_timeLimitContext | null {
        return this.getRuleContext(0, TraversalMethod_timeLimitContext);
    }
    public traversalMethod_times(): TraversalMethod_timesContext | null {
        return this.getRuleContext(0, TraversalMethod_timesContext);
    }
    public traversalMethod_to(): TraversalMethod_toContext | null {
        return this.getRuleContext(0, TraversalMethod_toContext);
    }
    public traversalMethod_toE(): TraversalMethod_toEContext | null {
        return this.getRuleContext(0, TraversalMethod_toEContext);
    }
    public traversalMethod_toV(): TraversalMethod_toVContext | null {
        return this.getRuleContext(0, TraversalMethod_toVContext);
    }
    public traversalMethod_tree(): TraversalMethod_treeContext | null {
        return this.getRuleContext(0, TraversalMethod_treeContext);
    }
    public traversalMethod_unfold(): TraversalMethod_unfoldContext | null {
        return this.getRuleContext(0, TraversalMethod_unfoldContext);
    }
    public traversalMethod_union(): TraversalMethod_unionContext | null {
        return this.getRuleContext(0, TraversalMethod_unionContext);
    }
    public traversalMethod_until(): TraversalMethod_untilContext | null {
        return this.getRuleContext(0, TraversalMethod_untilContext);
    }
    public traversalMethod_value(): TraversalMethod_valueContext | null {
        return this.getRuleContext(0, TraversalMethod_valueContext);
    }
    public traversalMethod_valueMap(): TraversalMethod_valueMapContext | null {
        return this.getRuleContext(0, TraversalMethod_valueMapContext);
    }
    public traversalMethod_values(): TraversalMethod_valuesContext | null {
        return this.getRuleContext(0, TraversalMethod_valuesContext);
    }
    public traversalMethod_where(): TraversalMethod_whereContext | null {
        return this.getRuleContext(0, TraversalMethod_whereContext);
    }
    public traversalMethod_with(): TraversalMethod_withContext | null {
        return this.getRuleContext(0, TraversalMethod_withContext);
    }
    public traversalMethod_write(): TraversalMethod_writeContext | null {
        return this.getRuleContext(0, TraversalMethod_writeContext);
    }
    public traversalMethod_element(): TraversalMethod_elementContext | null {
        return this.getRuleContext(0, TraversalMethod_elementContext);
    }
    public traversalMethod_call(): TraversalMethod_callContext | null {
        return this.getRuleContext(0, TraversalMethod_callContext);
    }
    public traversalMethod_concat(): TraversalMethod_concatContext | null {
        return this.getRuleContext(0, TraversalMethod_concatContext);
    }
    public traversalMethod_asString(): TraversalMethod_asStringContext | null {
        return this.getRuleContext(0, TraversalMethod_asStringContext);
    }
    public traversalMethod_format(): TraversalMethod_formatContext | null {
        return this.getRuleContext(0, TraversalMethod_formatContext);
    }
    public traversalMethod_toUpper(): TraversalMethod_toUpperContext | null {
        return this.getRuleContext(0, TraversalMethod_toUpperContext);
    }
    public traversalMethod_toLower(): TraversalMethod_toLowerContext | null {
        return this.getRuleContext(0, TraversalMethod_toLowerContext);
    }
    public traversalMethod_length(): TraversalMethod_lengthContext | null {
        return this.getRuleContext(0, TraversalMethod_lengthContext);
    }
    public traversalMethod_trim(): TraversalMethod_trimContext | null {
        return this.getRuleContext(0, TraversalMethod_trimContext);
    }
    public traversalMethod_lTrim(): TraversalMethod_lTrimContext | null {
        return this.getRuleContext(0, TraversalMethod_lTrimContext);
    }
    public traversalMethod_rTrim(): TraversalMethod_rTrimContext | null {
        return this.getRuleContext(0, TraversalMethod_rTrimContext);
    }
    public traversalMethod_reverse(): TraversalMethod_reverseContext | null {
        return this.getRuleContext(0, TraversalMethod_reverseContext);
    }
    public traversalMethod_replace(): TraversalMethod_replaceContext | null {
        return this.getRuleContext(0, TraversalMethod_replaceContext);
    }
    public traversalMethod_split(): TraversalMethod_splitContext | null {
        return this.getRuleContext(0, TraversalMethod_splitContext);
    }
    public traversalMethod_substring(): TraversalMethod_substringContext | null {
        return this.getRuleContext(0, TraversalMethod_substringContext);
    }
    public traversalMethod_asBool(): TraversalMethod_asBoolContext | null {
        return this.getRuleContext(0, TraversalMethod_asBoolContext);
    }
    public traversalMethod_asDate(): TraversalMethod_asDateContext | null {
        return this.getRuleContext(0, TraversalMethod_asDateContext);
    }
    public traversalMethod_dateAdd(): TraversalMethod_dateAddContext | null {
        return this.getRuleContext(0, TraversalMethod_dateAddContext);
    }
    public traversalMethod_dateDiff(): TraversalMethod_dateDiffContext | null {
        return this.getRuleContext(0, TraversalMethod_dateDiffContext);
    }
    public traversalMethod_asNumber(): TraversalMethod_asNumberContext | null {
        return this.getRuleContext(0, TraversalMethod_asNumberContext);
    }
    public traversalMethod_labels(): TraversalMethod_labelsContext | null {
        return this.getRuleContext(0, TraversalMethod_labelsContext);
    }
    public traversalMethod_addLabel(): TraversalMethod_addLabelContext | null {
        return this.getRuleContext(0, TraversalMethod_addLabelContext);
    }
    public traversalMethod_dropLabels(): TraversalMethod_dropLabelsContext | null {
        return this.getRuleContext(0, TraversalMethod_dropLabelsContext);
    }
    public traversalMethod_dropLabel(): TraversalMethod_dropLabelContext | null {
        return this.getRuleContext(0, TraversalMethod_dropLabelContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod) {
             listener.enterTraversalMethod(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod) {
             listener.exitTraversalMethod(this);
        }
    }
}


export class TraversalMethod_VContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_V(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_V, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgumentVarargs(): GenericArgumentVarargsContext | null {
        return this.getRuleContext(0, GenericArgumentVarargsContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_V;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_V) {
             listener.enterTraversalMethod_V(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_V) {
             listener.exitTraversalMethod_V(this);
        }
    }
}


export class TraversalMethod_EContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_E(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_E, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgumentVarargs(): GenericArgumentVarargsContext | null {
        return this.getRuleContext(0, GenericArgumentVarargsContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_E;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_E) {
             listener.enterTraversalMethod_E(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_E) {
             listener.exitTraversalMethod_E(this);
        }
    }
}


export class TraversalMethod_addEContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_addE;
    }
    public override copyFrom(ctx: TraversalMethod_addEContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_addE_StringContext extends TraversalMethod_addEContext {
    public constructor(ctx: TraversalMethod_addEContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ADDE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ADDE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringArgument(): StringArgumentContext {
        return this.getRuleContext(0, StringArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_addE_String) {
             listener.enterTraversalMethod_addE_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_addE_String) {
             listener.exitTraversalMethod_addE_String(this);
        }
    }
}
export class TraversalMethod_addE_TraversalContext extends TraversalMethod_addEContext {
    public constructor(ctx: TraversalMethod_addEContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ADDE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ADDE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_addE_Traversal) {
             listener.enterTraversalMethod_addE_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_addE_Traversal) {
             listener.exitTraversalMethod_addE_Traversal(this);
        }
    }
}


export class TraversalMethod_addVContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_addV;
    }
    public override copyFrom(ctx: TraversalMethod_addVContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_addV_EmptyContext extends TraversalMethod_addVContext {
    public constructor(ctx: TraversalMethod_addVContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ADDV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ADDV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_addV_Empty) {
             listener.enterTraversalMethod_addV_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_addV_Empty) {
             listener.exitTraversalMethod_addV_Empty(this);
        }
    }
}
export class TraversalMethod_addV_StringContext extends TraversalMethod_addVContext {
    public constructor(ctx: TraversalMethod_addVContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ADDV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ADDV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringArgumentVarargs(): StringArgumentVarargsContext {
        return this.getRuleContext(0, StringArgumentVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_addV_String) {
             listener.enterTraversalMethod_addV_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_addV_String) {
             listener.exitTraversalMethod_addV_String(this);
        }
    }
}
export class TraversalMethod_addV_TraversalContext extends TraversalMethod_addVContext {
    public constructor(ctx: TraversalMethod_addVContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ADDV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ADDV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext[];
    public nestedTraversal(i: number): NestedTraversalContext | null;
    public nestedTraversal(i?: number): NestedTraversalContext[] | NestedTraversalContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NestedTraversalContext);
        }

        return this.getRuleContext(i, NestedTraversalContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_addV_Traversal) {
             listener.enterTraversalMethod_addV_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_addV_Traversal) {
             listener.exitTraversalMethod_addV_Traversal(this);
        }
    }
}


export class TraversalMethod_aggregateContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_aggregate;
    }
    public override copyFrom(ctx: TraversalMethod_aggregateContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_aggregate_StringContext extends TraversalMethod_aggregateContext {
    public constructor(ctx: TraversalMethod_aggregateContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_AGGREGATE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_AGGREGATE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_aggregate_String) {
             listener.enterTraversalMethod_aggregate_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_aggregate_String) {
             listener.exitTraversalMethod_aggregate_String(this);
        }
    }
}


export class TraversalMethod_allContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_all;
    }
    public override copyFrom(ctx: TraversalMethod_allContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_all_PContext extends TraversalMethod_allContext {
    public constructor(ctx: TraversalMethod_allContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ALL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ALL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_all_P) {
             listener.enterTraversalMethod_all_P(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_all_P) {
             listener.exitTraversalMethod_all_P(this);
        }
    }
}


export class TraversalMethod_andContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_AND(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_AND, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversalList(): NestedTraversalListContext {
        return this.getRuleContext(0, NestedTraversalListContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_and;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_and) {
             listener.enterTraversalMethod_and(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_and) {
             listener.exitTraversalMethod_and(this);
        }
    }
}


export class TraversalMethod_anyContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_any;
    }
    public override copyFrom(ctx: TraversalMethod_anyContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_any_PContext extends TraversalMethod_anyContext {
    public constructor(ctx: TraversalMethod_anyContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ANY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ANY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_any_P) {
             listener.enterTraversalMethod_any_P(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_any_P) {
             listener.exitTraversalMethod_any_P(this);
        }
    }
}


export class TraversalMethod_asContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_AS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_AS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext | null {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_as;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_as) {
             listener.enterTraversalMethod_as(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_as) {
             listener.exitTraversalMethod_as(this);
        }
    }
}


export class TraversalMethod_asBoolContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_ASBOOL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ASBOOL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_asBool;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_asBool) {
             listener.enterTraversalMethod_asBool(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_asBool) {
             listener.exitTraversalMethod_asBool(this);
        }
    }
}


export class TraversalMethod_asDateContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_ASDATE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ASDATE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_asDate;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_asDate) {
             listener.enterTraversalMethod_asDate(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_asDate) {
             listener.exitTraversalMethod_asDate(this);
        }
    }
}


export class TraversalMethod_asNumberContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_asNumber;
    }
    public override copyFrom(ctx: TraversalMethod_asNumberContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_asNumber_EmptyContext extends TraversalMethod_asNumberContext {
    public constructor(ctx: TraversalMethod_asNumberContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ASNUMBER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ASNUMBER, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_asNumber_Empty) {
             listener.enterTraversalMethod_asNumber_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_asNumber_Empty) {
             listener.exitTraversalMethod_asNumber_Empty(this);
        }
    }
}
export class TraversalMethod_asNumber_traversalGTypeContext extends TraversalMethod_asNumberContext {
    public constructor(ctx: TraversalMethod_asNumberContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ASNUMBER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ASNUMBER, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalGType(): TraversalGTypeContext {
        return this.getRuleContext(0, TraversalGTypeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_asNumber_traversalGType) {
             listener.enterTraversalMethod_asNumber_traversalGType(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_asNumber_traversalGType) {
             listener.exitTraversalMethod_asNumber_traversalGType(this);
        }
    }
}


export class TraversalMethod_asStringContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_asString;
    }
    public override copyFrom(ctx: TraversalMethod_asStringContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_asString_EmptyContext extends TraversalMethod_asStringContext {
    public constructor(ctx: TraversalMethod_asStringContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ASSTRING(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ASSTRING, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_asString_Empty) {
             listener.enterTraversalMethod_asString_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_asString_Empty) {
             listener.exitTraversalMethod_asString_Empty(this);
        }
    }
}
export class TraversalMethod_asString_ScopeContext extends TraversalMethod_asStringContext {
    public constructor(ctx: TraversalMethod_asStringContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ASSTRING(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ASSTRING, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_asString_Scope) {
             listener.enterTraversalMethod_asString_Scope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_asString_Scope) {
             listener.exitTraversalMethod_asString_Scope(this);
        }
    }
}


export class TraversalMethod_barrierContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_barrier;
    }
    public override copyFrom(ctx: TraversalMethod_barrierContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_barrier_ConsumerContext extends TraversalMethod_barrierContext {
    public constructor(ctx: TraversalMethod_barrierContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_BARRIER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BARRIER, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalSackMethod(): TraversalSackMethodContext {
        return this.getRuleContext(0, TraversalSackMethodContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_barrier_Consumer) {
             listener.enterTraversalMethod_barrier_Consumer(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_barrier_Consumer) {
             listener.exitTraversalMethod_barrier_Consumer(this);
        }
    }
}
export class TraversalMethod_barrier_EmptyContext extends TraversalMethod_barrierContext {
    public constructor(ctx: TraversalMethod_barrierContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_BARRIER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BARRIER, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_barrier_Empty) {
             listener.enterTraversalMethod_barrier_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_barrier_Empty) {
             listener.exitTraversalMethod_barrier_Empty(this);
        }
    }
}
export class TraversalMethod_barrier_intContext extends TraversalMethod_barrierContext {
    public constructor(ctx: TraversalMethod_barrierContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_BARRIER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BARRIER, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public integerLiteral(): IntegerLiteralContext {
        return this.getRuleContext(0, IntegerLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_barrier_int) {
             listener.enterTraversalMethod_barrier_int(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_barrier_int) {
             listener.exitTraversalMethod_barrier_int(this);
        }
    }
}


export class TraversalMethod_bothContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_BOTH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BOTH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableArgumentVarargs(): StringNullableArgumentVarargsContext {
        return this.getRuleContext(0, StringNullableArgumentVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_both;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_both) {
             listener.enterTraversalMethod_both(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_both) {
             listener.exitTraversalMethod_both(this);
        }
    }
}


export class TraversalMethod_bothEContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_BOTHE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BOTHE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableArgumentVarargs(): StringNullableArgumentVarargsContext {
        return this.getRuleContext(0, StringNullableArgumentVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_bothE;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_bothE) {
             listener.enterTraversalMethod_bothE(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_bothE) {
             listener.exitTraversalMethod_bothE(this);
        }
    }
}


export class TraversalMethod_bothVContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_BOTHV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BOTHV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_bothV;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_bothV) {
             listener.enterTraversalMethod_bothV(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_bothV) {
             listener.exitTraversalMethod_bothV(this);
        }
    }
}


export class TraversalMethod_branchContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_BRANCH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BRANCH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_branch;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_branch) {
             listener.enterTraversalMethod_branch(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_branch) {
             listener.exitTraversalMethod_branch(this);
        }
    }
}


export class TraversalMethod_byContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_by;
    }
    public override copyFrom(ctx: TraversalMethod_byContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_by_ComparatorContext extends TraversalMethod_byContext {
    public constructor(ctx: TraversalMethod_byContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_BY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalComparator(): TraversalComparatorContext {
        return this.getRuleContext(0, TraversalComparatorContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_by_Comparator) {
             listener.enterTraversalMethod_by_Comparator(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_by_Comparator) {
             listener.exitTraversalMethod_by_Comparator(this);
        }
    }
}
export class TraversalMethod_by_EmptyContext extends TraversalMethod_byContext {
    public constructor(ctx: TraversalMethod_byContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_BY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_by_Empty) {
             listener.enterTraversalMethod_by_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_by_Empty) {
             listener.exitTraversalMethod_by_Empty(this);
        }
    }
}
export class TraversalMethod_by_FunctionContext extends TraversalMethod_byContext {
    public constructor(ctx: TraversalMethod_byContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_BY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalFunction(): TraversalFunctionContext {
        return this.getRuleContext(0, TraversalFunctionContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_by_Function) {
             listener.enterTraversalMethod_by_Function(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_by_Function) {
             listener.exitTraversalMethod_by_Function(this);
        }
    }
}
export class TraversalMethod_by_Function_ComparatorContext extends TraversalMethod_byContext {
    public constructor(ctx: TraversalMethod_byContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_BY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalFunction(): TraversalFunctionContext {
        return this.getRuleContext(0, TraversalFunctionContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public traversalComparator(): TraversalComparatorContext {
        return this.getRuleContext(0, TraversalComparatorContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_by_Function_Comparator) {
             listener.enterTraversalMethod_by_Function_Comparator(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_by_Function_Comparator) {
             listener.exitTraversalMethod_by_Function_Comparator(this);
        }
    }
}
export class TraversalMethod_by_OrderContext extends TraversalMethod_byContext {
    public constructor(ctx: TraversalMethod_byContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_BY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalOrder(): TraversalOrderContext {
        return this.getRuleContext(0, TraversalOrderContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_by_Order) {
             listener.enterTraversalMethod_by_Order(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_by_Order) {
             listener.exitTraversalMethod_by_Order(this);
        }
    }
}
export class TraversalMethod_by_StringContext extends TraversalMethod_byContext {
    public constructor(ctx: TraversalMethod_byContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_BY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_by_String) {
             listener.enterTraversalMethod_by_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_by_String) {
             listener.exitTraversalMethod_by_String(this);
        }
    }
}
export class TraversalMethod_by_String_ComparatorContext extends TraversalMethod_byContext {
    public constructor(ctx: TraversalMethod_byContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_BY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public traversalComparator(): TraversalComparatorContext {
        return this.getRuleContext(0, TraversalComparatorContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_by_String_Comparator) {
             listener.enterTraversalMethod_by_String_Comparator(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_by_String_Comparator) {
             listener.exitTraversalMethod_by_String_Comparator(this);
        }
    }
}
export class TraversalMethod_by_TContext extends TraversalMethod_byContext {
    public constructor(ctx: TraversalMethod_byContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_BY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalT(): TraversalTContext {
        return this.getRuleContext(0, TraversalTContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_by_T) {
             listener.enterTraversalMethod_by_T(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_by_T) {
             listener.exitTraversalMethod_by_T(this);
        }
    }
}
export class TraversalMethod_by_TraversalContext extends TraversalMethod_byContext {
    public constructor(ctx: TraversalMethod_byContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_BY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_by_Traversal) {
             listener.enterTraversalMethod_by_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_by_Traversal) {
             listener.exitTraversalMethod_by_Traversal(this);
        }
    }
}
export class TraversalMethod_by_Traversal_ComparatorContext extends TraversalMethod_byContext {
    public constructor(ctx: TraversalMethod_byContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_BY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public traversalComparator(): TraversalComparatorContext {
        return this.getRuleContext(0, TraversalComparatorContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_by_Traversal_Comparator) {
             listener.enterTraversalMethod_by_Traversal_Comparator(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_by_Traversal_Comparator) {
             listener.exitTraversalMethod_by_Traversal_Comparator(this);
        }
    }
}


export class TraversalMethod_callContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_call;
    }
    public override copyFrom(ctx: TraversalMethod_callContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_call_stringContext extends TraversalMethod_callContext {
    public constructor(ctx: TraversalMethod_callContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CALL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CALL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_call_string) {
             listener.enterTraversalMethod_call_string(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_call_string) {
             listener.exitTraversalMethod_call_string(this);
        }
    }
}
export class TraversalMethod_call_string_mapContext extends TraversalMethod_callContext {
    public constructor(ctx: TraversalMethod_callContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CALL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CALL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public genericMapArgument(): GenericMapArgumentContext {
        return this.getRuleContext(0, GenericMapArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_call_string_map) {
             listener.enterTraversalMethod_call_string_map(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_call_string_map) {
             listener.exitTraversalMethod_call_string_map(this);
        }
    }
}
export class TraversalMethod_call_string_traversalContext extends TraversalMethod_callContext {
    public constructor(ctx: TraversalMethod_callContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CALL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CALL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_call_string_traversal) {
             listener.enterTraversalMethod_call_string_traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_call_string_traversal) {
             listener.exitTraversalMethod_call_string_traversal(this);
        }
    }
}
export class TraversalMethod_call_string_map_traversalContext extends TraversalMethod_callContext {
    public constructor(ctx: TraversalMethod_callContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CALL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CALL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public genericMapArgument(): GenericMapArgumentContext {
        return this.getRuleContext(0, GenericMapArgumentContext)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_call_string_map_traversal) {
             listener.enterTraversalMethod_call_string_map_traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_call_string_map_traversal) {
             listener.exitTraversalMethod_call_string_map_traversal(this);
        }
    }
}


export class TraversalMethod_capContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_CAP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CAP, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext | null {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_cap;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_cap) {
             listener.enterTraversalMethod_cap(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_cap) {
             listener.exitTraversalMethod_cap(this);
        }
    }
}


export class TraversalMethod_chooseContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_choose;
    }
    public override copyFrom(ctx: TraversalMethod_chooseContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_choose_FunctionContext extends TraversalMethod_chooseContext {
    public constructor(ctx: TraversalMethod_chooseContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CHOOSE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CHOOSE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalFunction(): TraversalFunctionContext {
        return this.getRuleContext(0, TraversalFunctionContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_choose_Function) {
             listener.enterTraversalMethod_choose_Function(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_choose_Function) {
             listener.exitTraversalMethod_choose_Function(this);
        }
    }
}
export class TraversalMethod_choose_Predicate_TraversalContext extends TraversalMethod_chooseContext {
    public constructor(ctx: TraversalMethod_chooseContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CHOOSE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CHOOSE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_choose_Predicate_Traversal) {
             listener.enterTraversalMethod_choose_Predicate_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_choose_Predicate_Traversal) {
             listener.exitTraversalMethod_choose_Predicate_Traversal(this);
        }
    }
}
export class TraversalMethod_choose_Predicate_Traversal_TraversalContext extends TraversalMethod_chooseContext {
    public constructor(ctx: TraversalMethod_chooseContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CHOOSE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CHOOSE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public nestedTraversal(): NestedTraversalContext[];
    public nestedTraversal(i: number): NestedTraversalContext | null;
    public nestedTraversal(i?: number): NestedTraversalContext[] | NestedTraversalContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NestedTraversalContext);
        }

        return this.getRuleContext(i, NestedTraversalContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_choose_Predicate_Traversal_Traversal) {
             listener.enterTraversalMethod_choose_Predicate_Traversal_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_choose_Predicate_Traversal_Traversal) {
             listener.exitTraversalMethod_choose_Predicate_Traversal_Traversal(this);
        }
    }
}
export class TraversalMethod_choose_TraversalContext extends TraversalMethod_chooseContext {
    public constructor(ctx: TraversalMethod_chooseContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CHOOSE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CHOOSE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_choose_Traversal) {
             listener.enterTraversalMethod_choose_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_choose_Traversal) {
             listener.exitTraversalMethod_choose_Traversal(this);
        }
    }
}
export class TraversalMethod_choose_Traversal_TraversalContext extends TraversalMethod_chooseContext {
    public constructor(ctx: TraversalMethod_chooseContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CHOOSE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CHOOSE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext[];
    public nestedTraversal(i: number): NestedTraversalContext | null;
    public nestedTraversal(i?: number): NestedTraversalContext[] | NestedTraversalContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NestedTraversalContext);
        }

        return this.getRuleContext(i, NestedTraversalContext);
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_choose_Traversal_Traversal) {
             listener.enterTraversalMethod_choose_Traversal_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_choose_Traversal_Traversal) {
             listener.exitTraversalMethod_choose_Traversal_Traversal(this);
        }
    }
}
export class TraversalMethod_choose_Traversal_Traversal_TraversalContext extends TraversalMethod_chooseContext {
    public constructor(ctx: TraversalMethod_chooseContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CHOOSE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CHOOSE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext[];
    public nestedTraversal(i: number): NestedTraversalContext | null;
    public nestedTraversal(i?: number): NestedTraversalContext[] | NestedTraversalContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NestedTraversalContext);
        }

        return this.getRuleContext(i, NestedTraversalContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_choose_Traversal_Traversal_Traversal) {
             listener.enterTraversalMethod_choose_Traversal_Traversal_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_choose_Traversal_Traversal_Traversal) {
             listener.exitTraversalMethod_choose_Traversal_Traversal_Traversal(this);
        }
    }
}


export class TraversalMethod_coalesceContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_COALESCE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_COALESCE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversalList(): NestedTraversalListContext {
        return this.getRuleContext(0, NestedTraversalListContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_coalesce;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_coalesce) {
             listener.enterTraversalMethod_coalesce(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_coalesce) {
             listener.exitTraversalMethod_coalesce(this);
        }
    }
}


export class TraversalMethod_coinContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_COIN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_COIN, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public numericLiteral(): NumericLiteralContext {
        return this.getRuleContext(0, NumericLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_coin;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_coin) {
             listener.enterTraversalMethod_coin(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_coin) {
             listener.exitTraversalMethod_coin(this);
        }
    }
}


export class TraversalMethod_combineContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_combine;
    }
    public override copyFrom(ctx: TraversalMethod_combineContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_combine_ObjectContext extends TraversalMethod_combineContext {
    public constructor(ctx: TraversalMethod_combineContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_COMBINE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_COMBINE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_combine_Object) {
             listener.enterTraversalMethod_combine_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_combine_Object) {
             listener.exitTraversalMethod_combine_Object(this);
        }
    }
}


export class TraversalMethod_concatContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_concat;
    }
    public override copyFrom(ctx: TraversalMethod_concatContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_concat_Traversal_TraversalContext extends TraversalMethod_concatContext {
    public constructor(ctx: TraversalMethod_concatContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CONCAT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CONCAT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public nestedTraversalList(): NestedTraversalListContext | null {
        return this.getRuleContext(0, NestedTraversalListContext);
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_concat_Traversal_Traversal) {
             listener.enterTraversalMethod_concat_Traversal_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_concat_Traversal_Traversal) {
             listener.exitTraversalMethod_concat_Traversal_Traversal(this);
        }
    }
}
export class TraversalMethod_concat_StringContext extends TraversalMethod_concatContext {
    public constructor(ctx: TraversalMethod_concatContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CONCAT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CONCAT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_concat_String) {
             listener.enterTraversalMethod_concat_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_concat_String) {
             listener.exitTraversalMethod_concat_String(this);
        }
    }
}


export class TraversalMethod_conjoinContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_conjoin;
    }
    public override copyFrom(ctx: TraversalMethod_conjoinContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_conjoin_StringContext extends TraversalMethod_conjoinContext {
    public constructor(ctx: TraversalMethod_conjoinContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_CONJOIN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CONJOIN, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_conjoin_String) {
             listener.enterTraversalMethod_conjoin_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_conjoin_String) {
             listener.exitTraversalMethod_conjoin_String(this);
        }
    }
}


export class TraversalMethod_connectedComponentContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_CONNECTEDCOMPONENT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CONNECTEDCOMPONENT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_connectedComponent;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_connectedComponent) {
             listener.enterTraversalMethod_connectedComponent(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_connectedComponent) {
             listener.exitTraversalMethod_connectedComponent(this);
        }
    }
}


export class TraversalMethod_constantContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_CONSTANT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CONSTANT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_constant;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_constant) {
             listener.enterTraversalMethod_constant(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_constant) {
             listener.exitTraversalMethod_constant(this);
        }
    }
}


export class TraversalMethod_countContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_count;
    }
    public override copyFrom(ctx: TraversalMethod_countContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_count_EmptyContext extends TraversalMethod_countContext {
    public constructor(ctx: TraversalMethod_countContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_COUNT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_COUNT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_count_Empty) {
             listener.enterTraversalMethod_count_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_count_Empty) {
             listener.exitTraversalMethod_count_Empty(this);
        }
    }
}
export class TraversalMethod_count_ScopeContext extends TraversalMethod_countContext {
    public constructor(ctx: TraversalMethod_countContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_COUNT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_COUNT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_count_Scope) {
             listener.enterTraversalMethod_count_Scope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_count_Scope) {
             listener.exitTraversalMethod_count_Scope(this);
        }
    }
}


export class TraversalMethod_cyclicPathContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_CYCLICPATH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CYCLICPATH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_cyclicPath;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_cyclicPath) {
             listener.enterTraversalMethod_cyclicPath(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_cyclicPath) {
             listener.exitTraversalMethod_cyclicPath(this);
        }
    }
}


export class TraversalMethod_dateAddContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_DATEADD(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DATEADD, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalDT(): TraversalDTContext {
        return this.getRuleContext(0, TraversalDTContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public integerLiteral(): IntegerLiteralContext {
        return this.getRuleContext(0, IntegerLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_dateAdd;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_dateAdd) {
             listener.enterTraversalMethod_dateAdd(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_dateAdd) {
             listener.exitTraversalMethod_dateAdd(this);
        }
    }
}


export class TraversalMethod_dateDiffContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_dateDiff;
    }
    public override copyFrom(ctx: TraversalMethod_dateDiffContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_dateDiff_TraversalContext extends TraversalMethod_dateDiffContext {
    public constructor(ctx: TraversalMethod_dateDiffContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_DATEDIFF(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DATEDIFF, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_dateDiff_Traversal) {
             listener.enterTraversalMethod_dateDiff_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_dateDiff_Traversal) {
             listener.exitTraversalMethod_dateDiff_Traversal(this);
        }
    }
}
export class TraversalMethod_dateDiff_DateContext extends TraversalMethod_dateDiffContext {
    public constructor(ctx: TraversalMethod_dateDiffContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_DATEDIFF(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DATEDIFF, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public dateLiteral(): DateLiteralContext {
        return this.getRuleContext(0, DateLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_dateDiff_Date) {
             listener.enterTraversalMethod_dateDiff_Date(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_dateDiff_Date) {
             listener.exitTraversalMethod_dateDiff_Date(this);
        }
    }
}


export class TraversalMethod_dedupContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_dedup;
    }
    public override copyFrom(ctx: TraversalMethod_dedupContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_dedup_Scope_StringContext extends TraversalMethod_dedupContext {
    public constructor(ctx: TraversalMethod_dedupContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_DEDUP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DEDUP, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext | null {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext);
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_dedup_Scope_String) {
             listener.enterTraversalMethod_dedup_Scope_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_dedup_Scope_String) {
             listener.exitTraversalMethod_dedup_Scope_String(this);
        }
    }
}
export class TraversalMethod_dedup_StringContext extends TraversalMethod_dedupContext {
    public constructor(ctx: TraversalMethod_dedupContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_DEDUP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DEDUP, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_dedup_String) {
             listener.enterTraversalMethod_dedup_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_dedup_String) {
             listener.exitTraversalMethod_dedup_String(this);
        }
    }
}


export class TraversalMethod_differenceContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_difference;
    }
    public override copyFrom(ctx: TraversalMethod_differenceContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_difference_ObjectContext extends TraversalMethod_differenceContext {
    public constructor(ctx: TraversalMethod_differenceContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_DIFFERENCE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DIFFERENCE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_difference_Object) {
             listener.enterTraversalMethod_difference_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_difference_Object) {
             listener.exitTraversalMethod_difference_Object(this);
        }
    }
}


export class TraversalMethod_discardContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_DISCARD(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DISCARD, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_discard;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_discard) {
             listener.enterTraversalMethod_discard(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_discard) {
             listener.exitTraversalMethod_discard(this);
        }
    }
}


export class TraversalMethod_disjunctContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_disjunct;
    }
    public override copyFrom(ctx: TraversalMethod_disjunctContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_disjunct_ObjectContext extends TraversalMethod_disjunctContext {
    public constructor(ctx: TraversalMethod_disjunctContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_DISJUNCT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DISJUNCT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_disjunct_Object) {
             listener.enterTraversalMethod_disjunct_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_disjunct_Object) {
             listener.exitTraversalMethod_disjunct_Object(this);
        }
    }
}


export class TraversalMethod_dropContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_DROP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DROP, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_drop;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_drop) {
             listener.enterTraversalMethod_drop(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_drop) {
             listener.exitTraversalMethod_drop(this);
        }
    }
}


export class TraversalMethod_elementContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_ELEMENT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ELEMENT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_element;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_element) {
             listener.enterTraversalMethod_element(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_element) {
             listener.exitTraversalMethod_element(this);
        }
    }
}


export class TraversalMethod_elementMapContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_ELEMENTMAP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ELEMENTMAP, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_elementMap;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_elementMap) {
             listener.enterTraversalMethod_elementMap(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_elementMap) {
             listener.exitTraversalMethod_elementMap(this);
        }
    }
}


export class TraversalMethod_emitContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_emit;
    }
    public override copyFrom(ctx: TraversalMethod_emitContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_emit_EmptyContext extends TraversalMethod_emitContext {
    public constructor(ctx: TraversalMethod_emitContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_EMIT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_EMIT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_emit_Empty) {
             listener.enterTraversalMethod_emit_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_emit_Empty) {
             listener.exitTraversalMethod_emit_Empty(this);
        }
    }
}
export class TraversalMethod_emit_PredicateContext extends TraversalMethod_emitContext {
    public constructor(ctx: TraversalMethod_emitContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_EMIT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_EMIT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_emit_Predicate) {
             listener.enterTraversalMethod_emit_Predicate(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_emit_Predicate) {
             listener.exitTraversalMethod_emit_Predicate(this);
        }
    }
}
export class TraversalMethod_emit_TraversalContext extends TraversalMethod_emitContext {
    public constructor(ctx: TraversalMethod_emitContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_EMIT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_EMIT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_emit_Traversal) {
             listener.enterTraversalMethod_emit_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_emit_Traversal) {
             listener.exitTraversalMethod_emit_Traversal(this);
        }
    }
}


export class TraversalMethod_failContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_fail;
    }
    public override copyFrom(ctx: TraversalMethod_failContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_fail_EmptyContext extends TraversalMethod_failContext {
    public constructor(ctx: TraversalMethod_failContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_FAIL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_FAIL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_fail_Empty) {
             listener.enterTraversalMethod_fail_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_fail_Empty) {
             listener.exitTraversalMethod_fail_Empty(this);
        }
    }
}
export class TraversalMethod_fail_StringContext extends TraversalMethod_failContext {
    public constructor(ctx: TraversalMethod_failContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_FAIL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_FAIL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_fail_String) {
             listener.enterTraversalMethod_fail_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_fail_String) {
             listener.exitTraversalMethod_fail_String(this);
        }
    }
}


export class TraversalMethod_filterContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_filter;
    }
    public override copyFrom(ctx: TraversalMethod_filterContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_filter_PredicateContext extends TraversalMethod_filterContext {
    public constructor(ctx: TraversalMethod_filterContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_FILTER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_FILTER, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_filter_Predicate) {
             listener.enterTraversalMethod_filter_Predicate(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_filter_Predicate) {
             listener.exitTraversalMethod_filter_Predicate(this);
        }
    }
}
export class TraversalMethod_filter_TraversalContext extends TraversalMethod_filterContext {
    public constructor(ctx: TraversalMethod_filterContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_FILTER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_FILTER, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_filter_Traversal) {
             listener.enterTraversalMethod_filter_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_filter_Traversal) {
             listener.exitTraversalMethod_filter_Traversal(this);
        }
    }
}


export class TraversalMethod_flatMapContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_FLATMAP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_FLATMAP, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_flatMap;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_flatMap) {
             listener.enterTraversalMethod_flatMap(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_flatMap) {
             listener.exitTraversalMethod_flatMap(this);
        }
    }
}


export class TraversalMethod_foldContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_fold;
    }
    public override copyFrom(ctx: TraversalMethod_foldContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_fold_EmptyContext extends TraversalMethod_foldContext {
    public constructor(ctx: TraversalMethod_foldContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_FOLD(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_FOLD, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_fold_Empty) {
             listener.enterTraversalMethod_fold_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_fold_Empty) {
             listener.exitTraversalMethod_fold_Empty(this);
        }
    }
}
export class TraversalMethod_fold_Object_BiFunctionContext extends TraversalMethod_foldContext {
    public constructor(ctx: TraversalMethod_foldContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_FOLD(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_FOLD, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public traversalBiFunction(): TraversalBiFunctionContext {
        return this.getRuleContext(0, TraversalBiFunctionContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_fold_Object_BiFunction) {
             listener.enterTraversalMethod_fold_Object_BiFunction(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_fold_Object_BiFunction) {
             listener.exitTraversalMethod_fold_Object_BiFunction(this);
        }
    }
}


export class TraversalMethod_formatContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_format;
    }
    public override copyFrom(ctx: TraversalMethod_formatContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_format_StringContext extends TraversalMethod_formatContext {
    public constructor(ctx: TraversalMethod_formatContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_FORMAT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_FORMAT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_format_String) {
             listener.enterTraversalMethod_format_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_format_String) {
             listener.exitTraversalMethod_format_String(this);
        }
    }
}


export class TraversalMethod_fromContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_from;
    }
    public override copyFrom(ctx: TraversalMethod_fromContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_from_StringContext extends TraversalMethod_fromContext {
    public constructor(ctx: TraversalMethod_fromContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_FROM(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_FROM, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_from_String) {
             listener.enterTraversalMethod_from_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_from_String) {
             listener.exitTraversalMethod_from_String(this);
        }
    }
}
export class TraversalMethod_from_TraversalContext extends TraversalMethod_fromContext {
    public constructor(ctx: TraversalMethod_fromContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_FROM(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_FROM, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_from_Traversal) {
             listener.enterTraversalMethod_from_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_from_Traversal) {
             listener.exitTraversalMethod_from_Traversal(this);
        }
    }
}


export class TraversalMethod_groupContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_group;
    }
    public override copyFrom(ctx: TraversalMethod_groupContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_group_EmptyContext extends TraversalMethod_groupContext {
    public constructor(ctx: TraversalMethod_groupContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_GROUP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_GROUP, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_group_Empty) {
             listener.enterTraversalMethod_group_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_group_Empty) {
             listener.exitTraversalMethod_group_Empty(this);
        }
    }
}
export class TraversalMethod_group_StringContext extends TraversalMethod_groupContext {
    public constructor(ctx: TraversalMethod_groupContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_GROUP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_GROUP, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_group_String) {
             listener.enterTraversalMethod_group_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_group_String) {
             listener.exitTraversalMethod_group_String(this);
        }
    }
}


export class TraversalMethod_groupCountContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_groupCount;
    }
    public override copyFrom(ctx: TraversalMethod_groupCountContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_groupCount_EmptyContext extends TraversalMethod_groupCountContext {
    public constructor(ctx: TraversalMethod_groupCountContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_GROUPCOUNT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_GROUPCOUNT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_groupCount_Empty) {
             listener.enterTraversalMethod_groupCount_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_groupCount_Empty) {
             listener.exitTraversalMethod_groupCount_Empty(this);
        }
    }
}
export class TraversalMethod_groupCount_StringContext extends TraversalMethod_groupCountContext {
    public constructor(ctx: TraversalMethod_groupCountContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_GROUPCOUNT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_GROUPCOUNT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_groupCount_String) {
             listener.enterTraversalMethod_groupCount_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_groupCount_String) {
             listener.exitTraversalMethod_groupCount_String(this);
        }
    }
}


export class TraversalMethod_hasContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_has;
    }
    public override copyFrom(ctx: TraversalMethod_hasContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_has_StringContext extends TraversalMethod_hasContext {
    public constructor(ctx: TraversalMethod_hasContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HAS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HAS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteral(): StringNullableLiteralContext {
        return this.getRuleContext(0, StringNullableLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_has_String) {
             listener.enterTraversalMethod_has_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_has_String) {
             listener.exitTraversalMethod_has_String(this);
        }
    }
}
export class TraversalMethod_has_String_ObjectContext extends TraversalMethod_hasContext {
    public constructor(ctx: TraversalMethod_hasContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HAS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HAS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteral(): StringNullableLiteralContext {
        return this.getRuleContext(0, StringNullableLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public genericArgument(): GenericArgumentContext {
        return this.getRuleContext(0, GenericArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_has_String_Object) {
             listener.enterTraversalMethod_has_String_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_has_String_Object) {
             listener.exitTraversalMethod_has_String_Object(this);
        }
    }
}
export class TraversalMethod_has_String_PContext extends TraversalMethod_hasContext {
    public constructor(ctx: TraversalMethod_hasContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HAS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HAS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteral(): StringNullableLiteralContext {
        return this.getRuleContext(0, StringNullableLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_has_String_P) {
             listener.enterTraversalMethod_has_String_P(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_has_String_P) {
             listener.exitTraversalMethod_has_String_P(this);
        }
    }
}
export class TraversalMethod_has_String_TraversalContext extends TraversalMethod_hasContext {
    public constructor(ctx: TraversalMethod_hasContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HAS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HAS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteral(): StringNullableLiteralContext {
        return this.getRuleContext(0, StringNullableLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_has_String_Traversal) {
             listener.enterTraversalMethod_has_String_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_has_String_Traversal) {
             listener.exitTraversalMethod_has_String_Traversal(this);
        }
    }
}
export class TraversalMethod_has_String_String_ObjectContext extends TraversalMethod_hasContext {
    public constructor(ctx: TraversalMethod_hasContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HAS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HAS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableArgument(): StringNullableArgumentContext {
        return this.getRuleContext(0, StringNullableArgumentContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public stringNullableLiteral(): StringNullableLiteralContext {
        return this.getRuleContext(0, StringNullableLiteralContext)!;
    }
    public genericArgument(): GenericArgumentContext {
        return this.getRuleContext(0, GenericArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_has_String_String_Object) {
             listener.enterTraversalMethod_has_String_String_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_has_String_String_Object) {
             listener.exitTraversalMethod_has_String_String_Object(this);
        }
    }
}
export class TraversalMethod_has_String_String_PContext extends TraversalMethod_hasContext {
    public constructor(ctx: TraversalMethod_hasContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HAS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HAS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableArgument(): StringNullableArgumentContext {
        return this.getRuleContext(0, StringNullableArgumentContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public stringNullableLiteral(): StringNullableLiteralContext {
        return this.getRuleContext(0, StringNullableLiteralContext)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_has_String_String_P) {
             listener.enterTraversalMethod_has_String_String_P(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_has_String_String_P) {
             listener.exitTraversalMethod_has_String_String_P(this);
        }
    }
}
export class TraversalMethod_has_String_String_TraversalContext extends TraversalMethod_hasContext {
    public constructor(ctx: TraversalMethod_hasContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HAS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HAS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableArgument(): StringNullableArgumentContext {
        return this.getRuleContext(0, StringNullableArgumentContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public stringNullableLiteral(): StringNullableLiteralContext {
        return this.getRuleContext(0, StringNullableLiteralContext)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_has_String_String_Traversal) {
             listener.enterTraversalMethod_has_String_String_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_has_String_String_Traversal) {
             listener.exitTraversalMethod_has_String_String_Traversal(this);
        }
    }
}
export class TraversalMethod_has_T_ObjectContext extends TraversalMethod_hasContext {
    public constructor(ctx: TraversalMethod_hasContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HAS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HAS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalT(): TraversalTContext {
        return this.getRuleContext(0, TraversalTContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public genericArgument(): GenericArgumentContext {
        return this.getRuleContext(0, GenericArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_has_T_Object) {
             listener.enterTraversalMethod_has_T_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_has_T_Object) {
             listener.exitTraversalMethod_has_T_Object(this);
        }
    }
}
export class TraversalMethod_has_T_PContext extends TraversalMethod_hasContext {
    public constructor(ctx: TraversalMethod_hasContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HAS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HAS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalT(): TraversalTContext {
        return this.getRuleContext(0, TraversalTContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_has_T_P) {
             listener.enterTraversalMethod_has_T_P(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_has_T_P) {
             listener.exitTraversalMethod_has_T_P(this);
        }
    }
}
export class TraversalMethod_has_T_TraversalContext extends TraversalMethod_hasContext {
    public constructor(ctx: TraversalMethod_hasContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HAS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HAS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalT(): TraversalTContext {
        return this.getRuleContext(0, TraversalTContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_has_T_Traversal) {
             listener.enterTraversalMethod_has_T_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_has_T_Traversal) {
             listener.exitTraversalMethod_has_T_Traversal(this);
        }
    }
}


export class TraversalMethod_hasIdContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_hasId;
    }
    public override copyFrom(ctx: TraversalMethod_hasIdContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_hasId_Object_ObjectContext extends TraversalMethod_hasIdContext {
    public constructor(ctx: TraversalMethod_hasIdContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HASID(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HASID, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgument(): GenericArgumentContext {
        return this.getRuleContext(0, GenericArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public genericArgumentVarargs(): GenericArgumentVarargsContext | null {
        return this.getRuleContext(0, GenericArgumentVarargsContext);
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_hasId_Object_Object) {
             listener.enterTraversalMethod_hasId_Object_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_hasId_Object_Object) {
             listener.exitTraversalMethod_hasId_Object_Object(this);
        }
    }
}
export class TraversalMethod_hasId_PContext extends TraversalMethod_hasIdContext {
    public constructor(ctx: TraversalMethod_hasIdContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HASID(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HASID, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_hasId_P) {
             listener.enterTraversalMethod_hasId_P(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_hasId_P) {
             listener.exitTraversalMethod_hasId_P(this);
        }
    }
}


export class TraversalMethod_hasKeyContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_hasKey;
    }
    public override copyFrom(ctx: TraversalMethod_hasKeyContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_hasKey_PContext extends TraversalMethod_hasKeyContext {
    public constructor(ctx: TraversalMethod_hasKeyContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HASKEY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HASKEY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_hasKey_P) {
             listener.enterTraversalMethod_hasKey_P(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_hasKey_P) {
             listener.exitTraversalMethod_hasKey_P(this);
        }
    }
}
export class TraversalMethod_hasKey_String_StringContext extends TraversalMethod_hasKeyContext {
    public constructor(ctx: TraversalMethod_hasKeyContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HASKEY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HASKEY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteral(): StringNullableLiteralContext {
        return this.getRuleContext(0, StringNullableLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext | null {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext);
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_hasKey_String_String) {
             listener.enterTraversalMethod_hasKey_String_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_hasKey_String_String) {
             listener.exitTraversalMethod_hasKey_String_String(this);
        }
    }
}
export class TraversalMethod_hasKey_TraversalContext extends TraversalMethod_hasKeyContext {
    public constructor(ctx: TraversalMethod_hasKeyContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HASKEY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HASKEY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_hasKey_Traversal) {
             listener.enterTraversalMethod_hasKey_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_hasKey_Traversal) {
             listener.exitTraversalMethod_hasKey_Traversal(this);
        }
    }
}


export class TraversalMethod_hasLabelContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_hasLabel;
    }
    public override copyFrom(ctx: TraversalMethod_hasLabelContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_hasLabel_PContext extends TraversalMethod_hasLabelContext {
    public constructor(ctx: TraversalMethod_hasLabelContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HASLABEL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HASLABEL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_hasLabel_P) {
             listener.enterTraversalMethod_hasLabel_P(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_hasLabel_P) {
             listener.exitTraversalMethod_hasLabel_P(this);
        }
    }
}
export class TraversalMethod_hasLabel_String_StringContext extends TraversalMethod_hasLabelContext {
    public constructor(ctx: TraversalMethod_hasLabelContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HASLABEL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HASLABEL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableArgument(): StringNullableArgumentContext {
        return this.getRuleContext(0, StringNullableArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public stringNullableArgumentVarargs(): StringNullableArgumentVarargsContext | null {
        return this.getRuleContext(0, StringNullableArgumentVarargsContext);
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_hasLabel_String_String) {
             listener.enterTraversalMethod_hasLabel_String_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_hasLabel_String_String) {
             listener.exitTraversalMethod_hasLabel_String_String(this);
        }
    }
}
export class TraversalMethod_hasLabel_TraversalContext extends TraversalMethod_hasLabelContext {
    public constructor(ctx: TraversalMethod_hasLabelContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HASLABEL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HASLABEL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_hasLabel_Traversal) {
             listener.enterTraversalMethod_hasLabel_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_hasLabel_Traversal) {
             listener.exitTraversalMethod_hasLabel_Traversal(this);
        }
    }
}


export class TraversalMethod_hasNotContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_HASNOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HASNOT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteral(): StringNullableLiteralContext {
        return this.getRuleContext(0, StringNullableLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_hasNot;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_hasNot) {
             listener.enterTraversalMethod_hasNot(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_hasNot) {
             listener.exitTraversalMethod_hasNot(this);
        }
    }
}


export class TraversalMethod_hasValueContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_hasValue;
    }
    public override copyFrom(ctx: TraversalMethod_hasValueContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_hasValue_Object_ObjectContext extends TraversalMethod_hasValueContext {
    public constructor(ctx: TraversalMethod_hasValueContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HASVALUE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HASVALUE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgument(): GenericArgumentContext {
        return this.getRuleContext(0, GenericArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public genericArgumentVarargs(): GenericArgumentVarargsContext | null {
        return this.getRuleContext(0, GenericArgumentVarargsContext);
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_hasValue_Object_Object) {
             listener.enterTraversalMethod_hasValue_Object_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_hasValue_Object_Object) {
             listener.exitTraversalMethod_hasValue_Object_Object(this);
        }
    }
}
export class TraversalMethod_hasValue_PContext extends TraversalMethod_hasValueContext {
    public constructor(ctx: TraversalMethod_hasValueContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HASVALUE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HASVALUE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_hasValue_P) {
             listener.enterTraversalMethod_hasValue_P(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_hasValue_P) {
             listener.exitTraversalMethod_hasValue_P(this);
        }
    }
}
export class TraversalMethod_hasValue_TraversalContext extends TraversalMethod_hasValueContext {
    public constructor(ctx: TraversalMethod_hasValueContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_HASVALUE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HASVALUE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_hasValue_Traversal) {
             listener.enterTraversalMethod_hasValue_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_hasValue_Traversal) {
             listener.exitTraversalMethod_hasValue_Traversal(this);
        }
    }
}


export class TraversalMethod_idContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_ID(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ID, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_id;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_id) {
             listener.enterTraversalMethod_id(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_id) {
             listener.exitTraversalMethod_id(this);
        }
    }
}


export class TraversalMethod_identityContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_IDENTITY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_IDENTITY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_identity;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_identity) {
             listener.enterTraversalMethod_identity(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_identity) {
             listener.exitTraversalMethod_identity(this);
        }
    }
}


export class TraversalMethod_inContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_IN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_IN, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableArgumentVarargs(): StringNullableArgumentVarargsContext {
        return this.getRuleContext(0, StringNullableArgumentVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_in;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_in) {
             listener.enterTraversalMethod_in(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_in) {
             listener.exitTraversalMethod_in(this);
        }
    }
}


export class TraversalMethod_inEContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_INE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_INE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableArgumentVarargs(): StringNullableArgumentVarargsContext {
        return this.getRuleContext(0, StringNullableArgumentVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_inE;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_inE) {
             listener.enterTraversalMethod_inE(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_inE) {
             listener.exitTraversalMethod_inE(this);
        }
    }
}


export class TraversalMethod_intersectContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_intersect;
    }
    public override copyFrom(ctx: TraversalMethod_intersectContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_intersect_ObjectContext extends TraversalMethod_intersectContext {
    public constructor(ctx: TraversalMethod_intersectContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_INTERSECT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_INTERSECT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_intersect_Object) {
             listener.enterTraversalMethod_intersect_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_intersect_Object) {
             listener.exitTraversalMethod_intersect_Object(this);
        }
    }
}


export class TraversalMethod_inVContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_INV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_INV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_inV;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_inV) {
             listener.enterTraversalMethod_inV(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_inV) {
             listener.exitTraversalMethod_inV(this);
        }
    }
}


export class TraversalMethod_indexContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_INDEX(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_INDEX, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_index;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_index) {
             listener.enterTraversalMethod_index(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_index) {
             listener.exitTraversalMethod_index(this);
        }
    }
}


export class TraversalMethod_injectContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_INJECT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_INJECT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericLiteralVarargs(): GenericLiteralVarargsContext {
        return this.getRuleContext(0, GenericLiteralVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_inject;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_inject) {
             listener.enterTraversalMethod_inject(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_inject) {
             listener.exitTraversalMethod_inject(this);
        }
    }
}


export class TraversalMethod_isContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_is;
    }
    public override copyFrom(ctx: TraversalMethod_isContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_is_ObjectContext extends TraversalMethod_isContext {
    public constructor(ctx: TraversalMethod_isContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_IS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_IS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgument(): GenericArgumentContext {
        return this.getRuleContext(0, GenericArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_is_Object) {
             listener.enterTraversalMethod_is_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_is_Object) {
             listener.exitTraversalMethod_is_Object(this);
        }
    }
}
export class TraversalMethod_is_PContext extends TraversalMethod_isContext {
    public constructor(ctx: TraversalMethod_isContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_IS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_IS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_is_P) {
             listener.enterTraversalMethod_is_P(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_is_P) {
             listener.exitTraversalMethod_is_P(this);
        }
    }
}


export class TraversalMethod_keyContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_KEY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_KEY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_key;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_key) {
             listener.enterTraversalMethod_key(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_key) {
             listener.exitTraversalMethod_key(this);
        }
    }
}


export class TraversalMethod_labelContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_LABEL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_LABEL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_label;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_label) {
             listener.enterTraversalMethod_label(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_label) {
             listener.exitTraversalMethod_label(this);
        }
    }
}


export class TraversalMethod_labelsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_LABELS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_LABELS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_labels;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_labels) {
             listener.enterTraversalMethod_labels(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_labels) {
             listener.exitTraversalMethod_labels(this);
        }
    }
}


export class TraversalMethod_addLabelContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_addLabel;
    }
    public override copyFrom(ctx: TraversalMethod_addLabelContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_addLabel_StringContext extends TraversalMethod_addLabelContext {
    public constructor(ctx: TraversalMethod_addLabelContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ADDLABEL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ADDLABEL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteralVarargs(): StringLiteralVarargsContext {
        return this.getRuleContext(0, StringLiteralVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_addLabel_String) {
             listener.enterTraversalMethod_addLabel_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_addLabel_String) {
             listener.exitTraversalMethod_addLabel_String(this);
        }
    }
}
export class TraversalMethod_addLabel_TraversalContext extends TraversalMethod_addLabelContext {
    public constructor(ctx: TraversalMethod_addLabelContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ADDLABEL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ADDLABEL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext[];
    public nestedTraversal(i: number): NestedTraversalContext | null;
    public nestedTraversal(i?: number): NestedTraversalContext[] | NestedTraversalContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NestedTraversalContext);
        }

        return this.getRuleContext(i, NestedTraversalContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_addLabel_Traversal) {
             listener.enterTraversalMethod_addLabel_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_addLabel_Traversal) {
             listener.exitTraversalMethod_addLabel_Traversal(this);
        }
    }
}


export class TraversalMethod_dropLabelsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_dropLabels;
    }
    public override copyFrom(ctx: TraversalMethod_dropLabelsContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_dropLabels_EmptyContext extends TraversalMethod_dropLabelsContext {
    public constructor(ctx: TraversalMethod_dropLabelsContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_DROPLABELS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DROPLABELS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_dropLabels_Empty) {
             listener.enterTraversalMethod_dropLabels_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_dropLabels_Empty) {
             listener.exitTraversalMethod_dropLabels_Empty(this);
        }
    }
}


export class TraversalMethod_dropLabelContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_dropLabel;
    }
    public override copyFrom(ctx: TraversalMethod_dropLabelContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_dropLabel_StringContext extends TraversalMethod_dropLabelContext {
    public constructor(ctx: TraversalMethod_dropLabelContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_DROPLABEL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DROPLABEL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteralVarargs(): StringLiteralVarargsContext {
        return this.getRuleContext(0, StringLiteralVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_dropLabel_String) {
             listener.enterTraversalMethod_dropLabel_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_dropLabel_String) {
             listener.exitTraversalMethod_dropLabel_String(this);
        }
    }
}
export class TraversalMethod_dropLabel_TraversalContext extends TraversalMethod_dropLabelContext {
    public constructor(ctx: TraversalMethod_dropLabelContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_DROPLABEL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DROPLABEL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext[];
    public nestedTraversal(i: number): NestedTraversalContext | null;
    public nestedTraversal(i?: number): NestedTraversalContext[] | NestedTraversalContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NestedTraversalContext);
        }

        return this.getRuleContext(i, NestedTraversalContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_dropLabel_Traversal) {
             listener.enterTraversalMethod_dropLabel_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_dropLabel_Traversal) {
             listener.exitTraversalMethod_dropLabel_Traversal(this);
        }
    }
}


export class TraversalMethod_lengthContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_length;
    }
    public override copyFrom(ctx: TraversalMethod_lengthContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_length_EmptyContext extends TraversalMethod_lengthContext {
    public constructor(ctx: TraversalMethod_lengthContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_LENGTH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_LENGTH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_length_Empty) {
             listener.enterTraversalMethod_length_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_length_Empty) {
             listener.exitTraversalMethod_length_Empty(this);
        }
    }
}
export class TraversalMethod_length_ScopeContext extends TraversalMethod_lengthContext {
    public constructor(ctx: TraversalMethod_lengthContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_LENGTH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_LENGTH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_length_Scope) {
             listener.enterTraversalMethod_length_Scope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_length_Scope) {
             listener.exitTraversalMethod_length_Scope(this);
        }
    }
}


export class TraversalMethod_limitContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_limit;
    }
    public override copyFrom(ctx: TraversalMethod_limitContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_limit_Scope_longContext extends TraversalMethod_limitContext {
    public constructor(ctx: TraversalMethod_limitContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_LIMIT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_LIMIT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public integerArgument(): IntegerArgumentContext {
        return this.getRuleContext(0, IntegerArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_limit_Scope_long) {
             listener.enterTraversalMethod_limit_Scope_long(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_limit_Scope_long) {
             listener.exitTraversalMethod_limit_Scope_long(this);
        }
    }
}
export class TraversalMethod_limit_longContext extends TraversalMethod_limitContext {
    public constructor(ctx: TraversalMethod_limitContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_LIMIT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_LIMIT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public integerArgument(): IntegerArgumentContext {
        return this.getRuleContext(0, IntegerArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_limit_long) {
             listener.enterTraversalMethod_limit_long(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_limit_long) {
             listener.exitTraversalMethod_limit_long(this);
        }
    }
}


export class TraversalMethod_localContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_LOCAL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_LOCAL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_local;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_local) {
             listener.enterTraversalMethod_local(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_local) {
             listener.exitTraversalMethod_local(this);
        }
    }
}


export class TraversalMethod_loopsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_loops;
    }
    public override copyFrom(ctx: TraversalMethod_loopsContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_loops_EmptyContext extends TraversalMethod_loopsContext {
    public constructor(ctx: TraversalMethod_loopsContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_LOOPS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_LOOPS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_loops_Empty) {
             listener.enterTraversalMethod_loops_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_loops_Empty) {
             listener.exitTraversalMethod_loops_Empty(this);
        }
    }
}
export class TraversalMethod_loops_StringContext extends TraversalMethod_loopsContext {
    public constructor(ctx: TraversalMethod_loopsContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_LOOPS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_LOOPS, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_loops_String) {
             listener.enterTraversalMethod_loops_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_loops_String) {
             listener.exitTraversalMethod_loops_String(this);
        }
    }
}


export class TraversalMethod_lTrimContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_lTrim;
    }
    public override copyFrom(ctx: TraversalMethod_lTrimContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_lTrim_EmptyContext extends TraversalMethod_lTrimContext {
    public constructor(ctx: TraversalMethod_lTrimContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_LTRIM(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_LTRIM, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_lTrim_Empty) {
             listener.enterTraversalMethod_lTrim_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_lTrim_Empty) {
             listener.exitTraversalMethod_lTrim_Empty(this);
        }
    }
}
export class TraversalMethod_lTrim_ScopeContext extends TraversalMethod_lTrimContext {
    public constructor(ctx: TraversalMethod_lTrimContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_LTRIM(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_LTRIM, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_lTrim_Scope) {
             listener.enterTraversalMethod_lTrim_Scope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_lTrim_Scope) {
             listener.exitTraversalMethod_lTrim_Scope(this);
        }
    }
}


export class TraversalMethod_mapContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_MAP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MAP, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_map;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_map) {
             listener.enterTraversalMethod_map(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_map) {
             listener.exitTraversalMethod_map(this);
        }
    }
}


export class TraversalMethod_matchContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_match;
    }
    public override copyFrom(ctx: TraversalMethod_matchContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_match_traversalContext extends TraversalMethod_matchContext {
    public constructor(ctx: TraversalMethod_matchContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MATCH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MATCH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversalList(): NestedTraversalListContext {
        return this.getRuleContext(0, NestedTraversalListContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_match_traversal) {
             listener.enterTraversalMethod_match_traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_match_traversal) {
             listener.exitTraversalMethod_match_traversal(this);
        }
    }
}
export class TraversalMethod_match_stringContext extends TraversalMethod_matchContext {
    public constructor(ctx: TraversalMethod_matchContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MATCH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MATCH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_match_string) {
             listener.enterTraversalMethod_match_string(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_match_string) {
             listener.exitTraversalMethod_match_string(this);
        }
    }
}
export class TraversalMethod_match_string_mapContext extends TraversalMethod_matchContext {
    public constructor(ctx: TraversalMethod_matchContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MATCH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MATCH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public genericMapLiteral(): GenericMapLiteralContext {
        return this.getRuleContext(0, GenericMapLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_match_string_map) {
             listener.enterTraversalMethod_match_string_map(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_match_string_map) {
             listener.exitTraversalMethod_match_string_map(this);
        }
    }
}


export class TraversalMethod_mathContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_MATH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MATH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_math;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_math) {
             listener.enterTraversalMethod_math(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_math) {
             listener.exitTraversalMethod_math(this);
        }
    }
}


export class TraversalMethod_maxContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_max;
    }
    public override copyFrom(ctx: TraversalMethod_maxContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_max_EmptyContext extends TraversalMethod_maxContext {
    public constructor(ctx: TraversalMethod_maxContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MAX(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MAX, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_max_Empty) {
             listener.enterTraversalMethod_max_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_max_Empty) {
             listener.exitTraversalMethod_max_Empty(this);
        }
    }
}
export class TraversalMethod_max_ScopeContext extends TraversalMethod_maxContext {
    public constructor(ctx: TraversalMethod_maxContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MAX(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MAX, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_max_Scope) {
             listener.enterTraversalMethod_max_Scope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_max_Scope) {
             listener.exitTraversalMethod_max_Scope(this);
        }
    }
}


export class TraversalMethod_meanContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_mean;
    }
    public override copyFrom(ctx: TraversalMethod_meanContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_mean_EmptyContext extends TraversalMethod_meanContext {
    public constructor(ctx: TraversalMethod_meanContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MEAN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MEAN, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_mean_Empty) {
             listener.enterTraversalMethod_mean_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_mean_Empty) {
             listener.exitTraversalMethod_mean_Empty(this);
        }
    }
}
export class TraversalMethod_mean_ScopeContext extends TraversalMethod_meanContext {
    public constructor(ctx: TraversalMethod_meanContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MEAN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MEAN, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_mean_Scope) {
             listener.enterTraversalMethod_mean_Scope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_mean_Scope) {
             listener.exitTraversalMethod_mean_Scope(this);
        }
    }
}


export class TraversalMethod_mergeContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_merge;
    }
    public override copyFrom(ctx: TraversalMethod_mergeContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_merge_ObjectContext extends TraversalMethod_mergeContext {
    public constructor(ctx: TraversalMethod_mergeContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MERGE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MERGE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_merge_Object) {
             listener.enterTraversalMethod_merge_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_merge_Object) {
             listener.exitTraversalMethod_merge_Object(this);
        }
    }
}


export class TraversalMethod_mergeVContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_mergeV;
    }
    public override copyFrom(ctx: TraversalMethod_mergeVContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_mergeV_emptyContext extends TraversalMethod_mergeVContext {
    public constructor(ctx: TraversalMethod_mergeVContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MERGEV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MERGEV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_mergeV_empty) {
             listener.enterTraversalMethod_mergeV_empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_mergeV_empty) {
             listener.exitTraversalMethod_mergeV_empty(this);
        }
    }
}
export class TraversalMethod_mergeV_MapContext extends TraversalMethod_mergeVContext {
    public constructor(ctx: TraversalMethod_mergeVContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MERGEV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MERGEV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericMapNullableArgument(): GenericMapNullableArgumentContext {
        return this.getRuleContext(0, GenericMapNullableArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_mergeV_Map) {
             listener.enterTraversalMethod_mergeV_Map(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_mergeV_Map) {
             listener.exitTraversalMethod_mergeV_Map(this);
        }
    }
}
export class TraversalMethod_mergeV_TraversalContext extends TraversalMethod_mergeVContext {
    public constructor(ctx: TraversalMethod_mergeVContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MERGEV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MERGEV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_mergeV_Traversal) {
             listener.enterTraversalMethod_mergeV_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_mergeV_Traversal) {
             listener.exitTraversalMethod_mergeV_Traversal(this);
        }
    }
}


export class TraversalMethod_mergeEContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_mergeE;
    }
    public override copyFrom(ctx: TraversalMethod_mergeEContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_mergeE_emptyContext extends TraversalMethod_mergeEContext {
    public constructor(ctx: TraversalMethod_mergeEContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MERGEE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MERGEE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_mergeE_empty) {
             listener.enterTraversalMethod_mergeE_empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_mergeE_empty) {
             listener.exitTraversalMethod_mergeE_empty(this);
        }
    }
}
export class TraversalMethod_mergeE_MapContext extends TraversalMethod_mergeEContext {
    public constructor(ctx: TraversalMethod_mergeEContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MERGEE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MERGEE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericMapNullableArgument(): GenericMapNullableArgumentContext {
        return this.getRuleContext(0, GenericMapNullableArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_mergeE_Map) {
             listener.enterTraversalMethod_mergeE_Map(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_mergeE_Map) {
             listener.exitTraversalMethod_mergeE_Map(this);
        }
    }
}
export class TraversalMethod_mergeE_TraversalContext extends TraversalMethod_mergeEContext {
    public constructor(ctx: TraversalMethod_mergeEContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MERGEE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MERGEE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_mergeE_Traversal) {
             listener.enterTraversalMethod_mergeE_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_mergeE_Traversal) {
             listener.exitTraversalMethod_mergeE_Traversal(this);
        }
    }
}


export class TraversalMethod_minContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_min;
    }
    public override copyFrom(ctx: TraversalMethod_minContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_min_EmptyContext extends TraversalMethod_minContext {
    public constructor(ctx: TraversalMethod_minContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MIN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MIN, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_min_Empty) {
             listener.enterTraversalMethod_min_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_min_Empty) {
             listener.exitTraversalMethod_min_Empty(this);
        }
    }
}
export class TraversalMethod_min_ScopeContext extends TraversalMethod_minContext {
    public constructor(ctx: TraversalMethod_minContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_MIN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MIN, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_min_Scope) {
             listener.enterTraversalMethod_min_Scope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_min_Scope) {
             listener.exitTraversalMethod_min_Scope(this);
        }
    }
}


export class TraversalMethod_noneContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_none;
    }
    public override copyFrom(ctx: TraversalMethod_noneContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_none_PContext extends TraversalMethod_noneContext {
    public constructor(ctx: TraversalMethod_noneContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_NONE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_NONE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_none_P) {
             listener.enterTraversalMethod_none_P(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_none_P) {
             listener.exitTraversalMethod_none_P(this);
        }
    }
}


export class TraversalMethod_notContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_NOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_NOT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_not;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_not) {
             listener.enterTraversalMethod_not(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_not) {
             listener.exitTraversalMethod_not(this);
        }
    }
}


export class TraversalMethod_optionContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_option;
    }
    public override copyFrom(ctx: TraversalMethod_optionContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_option_Predicate_TraversalContext extends TraversalMethod_optionContext {
    public constructor(ctx: TraversalMethod_optionContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_OPTION(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_OPTION, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_option_Predicate_Traversal) {
             listener.enterTraversalMethod_option_Predicate_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_option_Predicate_Traversal) {
             listener.exitTraversalMethod_option_Predicate_Traversal(this);
        }
    }
}
export class TraversalMethod_option_Merge_MapContext extends TraversalMethod_optionContext {
    public constructor(ctx: TraversalMethod_optionContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_OPTION(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_OPTION, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalMerge(): TraversalMergeContext {
        return this.getRuleContext(0, TraversalMergeContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public genericMapNullableArgument(): GenericMapNullableArgumentContext {
        return this.getRuleContext(0, GenericMapNullableArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_option_Merge_Map) {
             listener.enterTraversalMethod_option_Merge_Map(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_option_Merge_Map) {
             listener.exitTraversalMethod_option_Merge_Map(this);
        }
    }
}
export class TraversalMethod_option_Merge_Map_CardinalityContext extends TraversalMethod_optionContext {
    public constructor(ctx: TraversalMethod_optionContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_OPTION(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_OPTION, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalMerge(): TraversalMergeContext {
        return this.getRuleContext(0, TraversalMergeContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public genericMapNullableArgument(): GenericMapNullableArgumentContext {
        return this.getRuleContext(0, GenericMapNullableArgumentContext)!;
    }
    public traversalCardinality(): TraversalCardinalityContext {
        return this.getRuleContext(0, TraversalCardinalityContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_option_Merge_Map_Cardinality) {
             listener.enterTraversalMethod_option_Merge_Map_Cardinality(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_option_Merge_Map_Cardinality) {
             listener.exitTraversalMethod_option_Merge_Map_Cardinality(this);
        }
    }
}
export class TraversalMethod_option_Merge_TraversalContext extends TraversalMethod_optionContext {
    public constructor(ctx: TraversalMethod_optionContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_OPTION(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_OPTION, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalMerge(): TraversalMergeContext {
        return this.getRuleContext(0, TraversalMergeContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_option_Merge_Traversal) {
             listener.enterTraversalMethod_option_Merge_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_option_Merge_Traversal) {
             listener.exitTraversalMethod_option_Merge_Traversal(this);
        }
    }
}
export class TraversalMethod_option_Object_TraversalContext extends TraversalMethod_optionContext {
    public constructor(ctx: TraversalMethod_optionContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_OPTION(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_OPTION, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgument(): GenericArgumentContext {
        return this.getRuleContext(0, GenericArgumentContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_option_Object_Traversal) {
             listener.enterTraversalMethod_option_Object_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_option_Object_Traversal) {
             listener.exitTraversalMethod_option_Object_Traversal(this);
        }
    }
}
export class TraversalMethod_option_TraversalContext extends TraversalMethod_optionContext {
    public constructor(ctx: TraversalMethod_optionContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_OPTION(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_OPTION, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_option_Traversal) {
             listener.enterTraversalMethod_option_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_option_Traversal) {
             listener.exitTraversalMethod_option_Traversal(this);
        }
    }
}


export class TraversalMethod_optionalContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_OPTIONAL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_OPTIONAL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_optional;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_optional) {
             listener.enterTraversalMethod_optional(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_optional) {
             listener.exitTraversalMethod_optional(this);
        }
    }
}


export class TraversalMethod_orContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_OR(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_OR, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversalList(): NestedTraversalListContext {
        return this.getRuleContext(0, NestedTraversalListContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_or;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_or) {
             listener.enterTraversalMethod_or(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_or) {
             listener.exitTraversalMethod_or(this);
        }
    }
}


export class TraversalMethod_orderContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_order;
    }
    public override copyFrom(ctx: TraversalMethod_orderContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_order_EmptyContext extends TraversalMethod_orderContext {
    public constructor(ctx: TraversalMethod_orderContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ORDER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ORDER, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_order_Empty) {
             listener.enterTraversalMethod_order_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_order_Empty) {
             listener.exitTraversalMethod_order_Empty(this);
        }
    }
}
export class TraversalMethod_order_ScopeContext extends TraversalMethod_orderContext {
    public constructor(ctx: TraversalMethod_orderContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_ORDER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ORDER, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_order_Scope) {
             listener.enterTraversalMethod_order_Scope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_order_Scope) {
             listener.exitTraversalMethod_order_Scope(this);
        }
    }
}


export class TraversalMethod_otherVContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_OTHERV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_OTHERV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_otherV;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_otherV) {
             listener.enterTraversalMethod_otherV(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_otherV) {
             listener.exitTraversalMethod_otherV(this);
        }
    }
}


export class TraversalMethod_outContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_OUT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_OUT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableArgumentVarargs(): StringNullableArgumentVarargsContext {
        return this.getRuleContext(0, StringNullableArgumentVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_out;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_out) {
             listener.enterTraversalMethod_out(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_out) {
             listener.exitTraversalMethod_out(this);
        }
    }
}


export class TraversalMethod_outEContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_OUTE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_OUTE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableArgumentVarargs(): StringNullableArgumentVarargsContext {
        return this.getRuleContext(0, StringNullableArgumentVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_outE;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_outE) {
             listener.enterTraversalMethod_outE(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_outE) {
             listener.exitTraversalMethod_outE(this);
        }
    }
}


export class TraversalMethod_outVContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_OUTV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_OUTV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_outV;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_outV) {
             listener.enterTraversalMethod_outV(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_outV) {
             listener.exitTraversalMethod_outV(this);
        }
    }
}


export class TraversalMethod_pageRankContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_pageRank;
    }
    public override copyFrom(ctx: TraversalMethod_pageRankContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_pageRank_EmptyContext extends TraversalMethod_pageRankContext {
    public constructor(ctx: TraversalMethod_pageRankContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_PAGERANK(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PAGERANK, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_pageRank_Empty) {
             listener.enterTraversalMethod_pageRank_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_pageRank_Empty) {
             listener.exitTraversalMethod_pageRank_Empty(this);
        }
    }
}
export class TraversalMethod_pageRank_doubleContext extends TraversalMethod_pageRankContext {
    public constructor(ctx: TraversalMethod_pageRankContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_PAGERANK(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PAGERANK, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public numericLiteral(): NumericLiteralContext {
        return this.getRuleContext(0, NumericLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_pageRank_double) {
             listener.enterTraversalMethod_pageRank_double(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_pageRank_double) {
             listener.exitTraversalMethod_pageRank_double(this);
        }
    }
}


export class TraversalMethod_pathContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_PATH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PATH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_path;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_path) {
             listener.enterTraversalMethod_path(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_path) {
             listener.exitTraversalMethod_path(this);
        }
    }
}


export class TraversalMethod_peerPressureContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_PEERPRESSURE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PEERPRESSURE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_peerPressure;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_peerPressure) {
             listener.enterTraversalMethod_peerPressure(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_peerPressure) {
             listener.exitTraversalMethod_peerPressure(this);
        }
    }
}


export class TraversalMethod_productContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_product;
    }
    public override copyFrom(ctx: TraversalMethod_productContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_product_ObjectContext extends TraversalMethod_productContext {
    public constructor(ctx: TraversalMethod_productContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_PRODUCT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PRODUCT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_product_Object) {
             listener.enterTraversalMethod_product_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_product_Object) {
             listener.exitTraversalMethod_product_Object(this);
        }
    }
}


export class TraversalMethod_profileContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_profile;
    }
    public override copyFrom(ctx: TraversalMethod_profileContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_profile_EmptyContext extends TraversalMethod_profileContext {
    public constructor(ctx: TraversalMethod_profileContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_PROFILE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROFILE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_profile_Empty) {
             listener.enterTraversalMethod_profile_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_profile_Empty) {
             listener.exitTraversalMethod_profile_Empty(this);
        }
    }
}
export class TraversalMethod_profile_StringContext extends TraversalMethod_profileContext {
    public constructor(ctx: TraversalMethod_profileContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_PROFILE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROFILE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_profile_String) {
             listener.enterTraversalMethod_profile_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_profile_String) {
             listener.exitTraversalMethod_profile_String(this);
        }
    }
}


export class TraversalMethod_projectContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_PROJECT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROJECT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext | null {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_project;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_project) {
             listener.enterTraversalMethod_project(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_project) {
             listener.exitTraversalMethod_project(this);
        }
    }
}


export class TraversalMethod_propertiesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_PROPERTIES(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROPERTIES, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_properties;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_properties) {
             listener.enterTraversalMethod_properties(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_properties) {
             listener.exitTraversalMethod_properties(this);
        }
    }
}


export class TraversalMethod_propertyContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_property;
    }
    public override copyFrom(ctx: TraversalMethod_propertyContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_property_Cardinality_Object_Object_ObjectContext extends TraversalMethod_propertyContext {
    public constructor(ctx: TraversalMethod_propertyContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_PROPERTY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROPERTY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalCardinality(): TraversalCardinalityContext {
        return this.getRuleContext(0, TraversalCardinalityContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public genericArgument(): GenericArgumentContext {
        return this.getRuleContext(0, GenericArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public genericArgumentVarargs(): GenericArgumentVarargsContext | null {
        return this.getRuleContext(0, GenericArgumentVarargsContext);
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_property_Cardinality_Object_Object_Object) {
             listener.enterTraversalMethod_property_Cardinality_Object_Object_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_property_Cardinality_Object_Object_Object) {
             listener.exitTraversalMethod_property_Cardinality_Object_Object_Object(this);
        }
    }
}
export class TraversalMethod_property_Cardinality_Object_TraversalContext extends TraversalMethod_propertyContext {
    public constructor(ctx: TraversalMethod_propertyContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_PROPERTY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROPERTY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalCardinality(): TraversalCardinalityContext {
        return this.getRuleContext(0, TraversalCardinalityContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_property_Cardinality_Object_Traversal) {
             listener.enterTraversalMethod_property_Cardinality_Object_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_property_Cardinality_Object_Traversal) {
             listener.exitTraversalMethod_property_Cardinality_Object_Traversal(this);
        }
    }
}
export class TraversalMethod_property_Cardinality_ObjectContext extends TraversalMethod_propertyContext {
    public constructor(ctx: TraversalMethod_propertyContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_PROPERTY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROPERTY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalCardinality(): TraversalCardinalityContext {
        return this.getRuleContext(0, TraversalCardinalityContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public genericMapNullableArgument(): GenericMapNullableArgumentContext {
        return this.getRuleContext(0, GenericMapNullableArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_property_Cardinality_Object) {
             listener.enterTraversalMethod_property_Cardinality_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_property_Cardinality_Object) {
             listener.exitTraversalMethod_property_Cardinality_Object(this);
        }
    }
}
export class TraversalMethod_property_Object_Object_ObjectContext extends TraversalMethod_propertyContext {
    public constructor(ctx: TraversalMethod_propertyContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_PROPERTY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROPERTY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public genericArgument(): GenericArgumentContext {
        return this.getRuleContext(0, GenericArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public genericArgumentVarargs(): GenericArgumentVarargsContext | null {
        return this.getRuleContext(0, GenericArgumentVarargsContext);
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_property_Object_Object_Object) {
             listener.enterTraversalMethod_property_Object_Object_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_property_Object_Object_Object) {
             listener.exitTraversalMethod_property_Object_Object_Object(this);
        }
    }
}
export class TraversalMethod_property_Object_TraversalContext extends TraversalMethod_propertyContext {
    public constructor(ctx: TraversalMethod_propertyContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_PROPERTY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROPERTY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_property_Object_Traversal) {
             listener.enterTraversalMethod_property_Object_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_property_Object_Traversal) {
             listener.exitTraversalMethod_property_Object_Traversal(this);
        }
    }
}
export class TraversalMethod_property_ObjectContext extends TraversalMethod_propertyContext {
    public constructor(ctx: TraversalMethod_propertyContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_PROPERTY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROPERTY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericMapNullableArgument(): GenericMapNullableArgumentContext {
        return this.getRuleContext(0, GenericMapNullableArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_property_Object) {
             listener.enterTraversalMethod_property_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_property_Object) {
             listener.exitTraversalMethod_property_Object(this);
        }
    }
}
export class TraversalMethod_property_TraversalContext extends TraversalMethod_propertyContext {
    public constructor(ctx: TraversalMethod_propertyContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_PROPERTY(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROPERTY, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_property_Traversal) {
             listener.enterTraversalMethod_property_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_property_Traversal) {
             listener.exitTraversalMethod_property_Traversal(this);
        }
    }
}


export class TraversalMethod_propertyMapContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_PROPERTYMAP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROPERTYMAP, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_propertyMap;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_propertyMap) {
             listener.enterTraversalMethod_propertyMap(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_propertyMap) {
             listener.exitTraversalMethod_propertyMap(this);
        }
    }
}


export class TraversalMethod_rangeContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_range;
    }
    public override copyFrom(ctx: TraversalMethod_rangeContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_range_Scope_long_longContext extends TraversalMethod_rangeContext {
    public constructor(ctx: TraversalMethod_rangeContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_RANGE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_RANGE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public integerArgument(): IntegerArgumentContext[];
    public integerArgument(i: number): IntegerArgumentContext | null;
    public integerArgument(i?: number): IntegerArgumentContext[] | IntegerArgumentContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IntegerArgumentContext);
        }

        return this.getRuleContext(i, IntegerArgumentContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_range_Scope_long_long) {
             listener.enterTraversalMethod_range_Scope_long_long(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_range_Scope_long_long) {
             listener.exitTraversalMethod_range_Scope_long_long(this);
        }
    }
}
export class TraversalMethod_range_long_longContext extends TraversalMethod_rangeContext {
    public constructor(ctx: TraversalMethod_rangeContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_RANGE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_RANGE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public integerArgument(): IntegerArgumentContext[];
    public integerArgument(i: number): IntegerArgumentContext | null;
    public integerArgument(i?: number): IntegerArgumentContext[] | IntegerArgumentContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IntegerArgumentContext);
        }

        return this.getRuleContext(i, IntegerArgumentContext);
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_range_long_long) {
             listener.enterTraversalMethod_range_long_long(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_range_long_long) {
             listener.exitTraversalMethod_range_long_long(this);
        }
    }
}


export class TraversalMethod_readContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_READ(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_READ, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_read;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_read) {
             listener.enterTraversalMethod_read(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_read) {
             listener.exitTraversalMethod_read(this);
        }
    }
}


export class TraversalMethod_repeatContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_repeat;
    }
    public override copyFrom(ctx: TraversalMethod_repeatContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_repeat_String_TraversalContext extends TraversalMethod_repeatContext {
    public constructor(ctx: TraversalMethod_repeatContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_REPEAT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_REPEAT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_repeat_String_Traversal) {
             listener.enterTraversalMethod_repeat_String_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_repeat_String_Traversal) {
             listener.exitTraversalMethod_repeat_String_Traversal(this);
        }
    }
}
export class TraversalMethod_repeat_TraversalContext extends TraversalMethod_repeatContext {
    public constructor(ctx: TraversalMethod_repeatContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_REPEAT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_REPEAT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_repeat_Traversal) {
             listener.enterTraversalMethod_repeat_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_repeat_Traversal) {
             listener.exitTraversalMethod_repeat_Traversal(this);
        }
    }
}


export class TraversalMethod_replaceContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_replace;
    }
    public override copyFrom(ctx: TraversalMethod_replaceContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_replace_String_StringContext extends TraversalMethod_replaceContext {
    public constructor(ctx: TraversalMethod_replaceContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_REPLACE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_REPLACE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteral(): StringNullableLiteralContext[];
    public stringNullableLiteral(i: number): StringNullableLiteralContext | null;
    public stringNullableLiteral(i?: number): StringNullableLiteralContext[] | StringNullableLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringNullableLiteralContext);
        }

        return this.getRuleContext(i, StringNullableLiteralContext);
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_replace_String_String) {
             listener.enterTraversalMethod_replace_String_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_replace_String_String) {
             listener.exitTraversalMethod_replace_String_String(this);
        }
    }
}
export class TraversalMethod_replace_Scope_String_StringContext extends TraversalMethod_replaceContext {
    public constructor(ctx: TraversalMethod_replaceContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_REPLACE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_REPLACE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public stringNullableLiteral(): StringNullableLiteralContext[];
    public stringNullableLiteral(i: number): StringNullableLiteralContext | null;
    public stringNullableLiteral(i?: number): StringNullableLiteralContext[] | StringNullableLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringNullableLiteralContext);
        }

        return this.getRuleContext(i, StringNullableLiteralContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_replace_Scope_String_String) {
             listener.enterTraversalMethod_replace_Scope_String_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_replace_Scope_String_String) {
             listener.exitTraversalMethod_replace_Scope_String_String(this);
        }
    }
}


export class TraversalMethod_reverseContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_reverse;
    }
    public override copyFrom(ctx: TraversalMethod_reverseContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_reverse_EmptyContext extends TraversalMethod_reverseContext {
    public constructor(ctx: TraversalMethod_reverseContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_REVERSE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_REVERSE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_reverse_Empty) {
             listener.enterTraversalMethod_reverse_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_reverse_Empty) {
             listener.exitTraversalMethod_reverse_Empty(this);
        }
    }
}


export class TraversalMethod_rTrimContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_rTrim;
    }
    public override copyFrom(ctx: TraversalMethod_rTrimContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_rTrim_EmptyContext extends TraversalMethod_rTrimContext {
    public constructor(ctx: TraversalMethod_rTrimContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_RTRIM(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_RTRIM, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_rTrim_Empty) {
             listener.enterTraversalMethod_rTrim_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_rTrim_Empty) {
             listener.exitTraversalMethod_rTrim_Empty(this);
        }
    }
}
export class TraversalMethod_rTrim_ScopeContext extends TraversalMethod_rTrimContext {
    public constructor(ctx: TraversalMethod_rTrimContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_RTRIM(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_RTRIM, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_rTrim_Scope) {
             listener.enterTraversalMethod_rTrim_Scope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_rTrim_Scope) {
             listener.exitTraversalMethod_rTrim_Scope(this);
        }
    }
}


export class TraversalMethod_sackContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_sack;
    }
    public override copyFrom(ctx: TraversalMethod_sackContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_sack_BiFunctionContext extends TraversalMethod_sackContext {
    public constructor(ctx: TraversalMethod_sackContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SACK(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SACK, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalBiFunction(): TraversalBiFunctionContext {
        return this.getRuleContext(0, TraversalBiFunctionContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_sack_BiFunction) {
             listener.enterTraversalMethod_sack_BiFunction(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_sack_BiFunction) {
             listener.exitTraversalMethod_sack_BiFunction(this);
        }
    }
}
export class TraversalMethod_sack_EmptyContext extends TraversalMethod_sackContext {
    public constructor(ctx: TraversalMethod_sackContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SACK(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SACK, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_sack_Empty) {
             listener.enterTraversalMethod_sack_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_sack_Empty) {
             listener.exitTraversalMethod_sack_Empty(this);
        }
    }
}


export class TraversalMethod_sampleContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_sample;
    }
    public override copyFrom(ctx: TraversalMethod_sampleContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_sample_Scope_intContext extends TraversalMethod_sampleContext {
    public constructor(ctx: TraversalMethod_sampleContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SAMPLE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SAMPLE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public integerLiteral(): IntegerLiteralContext {
        return this.getRuleContext(0, IntegerLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_sample_Scope_int) {
             listener.enterTraversalMethod_sample_Scope_int(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_sample_Scope_int) {
             listener.exitTraversalMethod_sample_Scope_int(this);
        }
    }
}
export class TraversalMethod_sample_intContext extends TraversalMethod_sampleContext {
    public constructor(ctx: TraversalMethod_sampleContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SAMPLE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SAMPLE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public integerLiteral(): IntegerLiteralContext {
        return this.getRuleContext(0, IntegerLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_sample_int) {
             listener.enterTraversalMethod_sample_int(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_sample_int) {
             listener.exitTraversalMethod_sample_int(this);
        }
    }
}


export class TraversalMethod_selectContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_select;
    }
    public override copyFrom(ctx: TraversalMethod_selectContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_select_ColumnContext extends TraversalMethod_selectContext {
    public constructor(ctx: TraversalMethod_selectContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SELECT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SELECT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalColumn(): TraversalColumnContext {
        return this.getRuleContext(0, TraversalColumnContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_select_Column) {
             listener.enterTraversalMethod_select_Column(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_select_Column) {
             listener.exitTraversalMethod_select_Column(this);
        }
    }
}
export class TraversalMethod_select_Pop_StringContext extends TraversalMethod_selectContext {
    public constructor(ctx: TraversalMethod_selectContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SELECT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SELECT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPop(): TraversalPopContext {
        return this.getRuleContext(0, TraversalPopContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_select_Pop_String) {
             listener.enterTraversalMethod_select_Pop_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_select_Pop_String) {
             listener.exitTraversalMethod_select_Pop_String(this);
        }
    }
}
export class TraversalMethod_select_Pop_String_String_StringContext extends TraversalMethod_selectContext {
    public constructor(ctx: TraversalMethod_selectContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SELECT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SELECT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPop(): TraversalPopContext {
        return this.getRuleContext(0, TraversalPopContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public stringLiteral(): StringLiteralContext[];
    public stringLiteral(i: number): StringLiteralContext | null;
    public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLiteralContext);
        }

        return this.getRuleContext(i, StringLiteralContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext | null {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext);
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_select_Pop_String_String_String) {
             listener.enterTraversalMethod_select_Pop_String_String_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_select_Pop_String_String_String) {
             listener.exitTraversalMethod_select_Pop_String_String_String(this);
        }
    }
}
export class TraversalMethod_select_Pop_TraversalContext extends TraversalMethod_selectContext {
    public constructor(ctx: TraversalMethod_selectContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SELECT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SELECT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPop(): TraversalPopContext {
        return this.getRuleContext(0, TraversalPopContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_select_Pop_Traversal) {
             listener.enterTraversalMethod_select_Pop_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_select_Pop_Traversal) {
             listener.exitTraversalMethod_select_Pop_Traversal(this);
        }
    }
}
export class TraversalMethod_select_StringContext extends TraversalMethod_selectContext {
    public constructor(ctx: TraversalMethod_selectContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SELECT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SELECT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_select_String) {
             listener.enterTraversalMethod_select_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_select_String) {
             listener.exitTraversalMethod_select_String(this);
        }
    }
}
export class TraversalMethod_select_String_String_StringContext extends TraversalMethod_selectContext {
    public constructor(ctx: TraversalMethod_selectContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SELECT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SELECT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext[];
    public stringLiteral(i: number): StringLiteralContext | null;
    public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLiteralContext);
        }

        return this.getRuleContext(i, StringLiteralContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext | null {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext);
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_select_String_String_String) {
             listener.enterTraversalMethod_select_String_String_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_select_String_String_String) {
             listener.exitTraversalMethod_select_String_String_String(this);
        }
    }
}
export class TraversalMethod_select_TraversalContext extends TraversalMethod_selectContext {
    public constructor(ctx: TraversalMethod_selectContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SELECT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SELECT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_select_Traversal) {
             listener.enterTraversalMethod_select_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_select_Traversal) {
             listener.exitTraversalMethod_select_Traversal(this);
        }
    }
}


export class TraversalMethod_shortestPathContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_SHORTESTPATH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SHORTESTPATH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_shortestPath;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_shortestPath) {
             listener.enterTraversalMethod_shortestPath(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_shortestPath) {
             listener.exitTraversalMethod_shortestPath(this);
        }
    }
}


export class TraversalMethod_sideEffectContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_SIDEEFFECT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SIDEEFFECT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_sideEffect;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_sideEffect) {
             listener.enterTraversalMethod_sideEffect(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_sideEffect) {
             listener.exitTraversalMethod_sideEffect(this);
        }
    }
}


export class TraversalMethod_simplePathContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_SIMPLEPATH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SIMPLEPATH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_simplePath;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_simplePath) {
             listener.enterTraversalMethod_simplePath(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_simplePath) {
             listener.exitTraversalMethod_simplePath(this);
        }
    }
}


export class TraversalMethod_skipContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_skip;
    }
    public override copyFrom(ctx: TraversalMethod_skipContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_skip_Scope_longContext extends TraversalMethod_skipContext {
    public constructor(ctx: TraversalMethod_skipContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SKIP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SKIP, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public integerArgument(): IntegerArgumentContext {
        return this.getRuleContext(0, IntegerArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_skip_Scope_long) {
             listener.enterTraversalMethod_skip_Scope_long(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_skip_Scope_long) {
             listener.exitTraversalMethod_skip_Scope_long(this);
        }
    }
}
export class TraversalMethod_skip_longContext extends TraversalMethod_skipContext {
    public constructor(ctx: TraversalMethod_skipContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SKIP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SKIP, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public integerArgument(): IntegerArgumentContext {
        return this.getRuleContext(0, IntegerArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_skip_long) {
             listener.enterTraversalMethod_skip_long(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_skip_long) {
             listener.exitTraversalMethod_skip_long(this);
        }
    }
}


export class TraversalMethod_splitContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_split;
    }
    public override copyFrom(ctx: TraversalMethod_splitContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_split_StringContext extends TraversalMethod_splitContext {
    public constructor(ctx: TraversalMethod_splitContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SPLIT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SPLIT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteral(): StringNullableLiteralContext {
        return this.getRuleContext(0, StringNullableLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_split_String) {
             listener.enterTraversalMethod_split_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_split_String) {
             listener.exitTraversalMethod_split_String(this);
        }
    }
}
export class TraversalMethod_split_Scope_StringContext extends TraversalMethod_splitContext {
    public constructor(ctx: TraversalMethod_splitContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SPLIT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SPLIT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public stringNullableLiteral(): StringNullableLiteralContext {
        return this.getRuleContext(0, StringNullableLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_split_Scope_String) {
             listener.enterTraversalMethod_split_Scope_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_split_Scope_String) {
             listener.exitTraversalMethod_split_Scope_String(this);
        }
    }
}


export class TraversalMethod_subgraphContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_SUBGRAPH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SUBGRAPH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_subgraph;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_subgraph) {
             listener.enterTraversalMethod_subgraph(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_subgraph) {
             listener.exitTraversalMethod_subgraph(this);
        }
    }
}


export class TraversalMethod_substringContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_substring;
    }
    public override copyFrom(ctx: TraversalMethod_substringContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_substring_intContext extends TraversalMethod_substringContext {
    public constructor(ctx: TraversalMethod_substringContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SUBSTRING(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SUBSTRING, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public integerLiteral(): IntegerLiteralContext {
        return this.getRuleContext(0, IntegerLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_substring_int) {
             listener.enterTraversalMethod_substring_int(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_substring_int) {
             listener.exitTraversalMethod_substring_int(this);
        }
    }
}
export class TraversalMethod_substring_Scope_intContext extends TraversalMethod_substringContext {
    public constructor(ctx: TraversalMethod_substringContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SUBSTRING(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SUBSTRING, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public integerLiteral(): IntegerLiteralContext {
        return this.getRuleContext(0, IntegerLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_substring_Scope_int) {
             listener.enterTraversalMethod_substring_Scope_int(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_substring_Scope_int) {
             listener.exitTraversalMethod_substring_Scope_int(this);
        }
    }
}
export class TraversalMethod_substring_int_intContext extends TraversalMethod_substringContext {
    public constructor(ctx: TraversalMethod_substringContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SUBSTRING(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SUBSTRING, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public integerLiteral(): IntegerLiteralContext[];
    public integerLiteral(i: number): IntegerLiteralContext | null;
    public integerLiteral(i?: number): IntegerLiteralContext[] | IntegerLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IntegerLiteralContext);
        }

        return this.getRuleContext(i, IntegerLiteralContext);
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_substring_int_int) {
             listener.enterTraversalMethod_substring_int_int(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_substring_int_int) {
             listener.exitTraversalMethod_substring_int_int(this);
        }
    }
}
export class TraversalMethod_substring_Scope_int_intContext extends TraversalMethod_substringContext {
    public constructor(ctx: TraversalMethod_substringContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SUBSTRING(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SUBSTRING, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public integerLiteral(): IntegerLiteralContext[];
    public integerLiteral(i: number): IntegerLiteralContext | null;
    public integerLiteral(i?: number): IntegerLiteralContext[] | IntegerLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IntegerLiteralContext);
        }

        return this.getRuleContext(i, IntegerLiteralContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_substring_Scope_int_int) {
             listener.enterTraversalMethod_substring_Scope_int_int(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_substring_Scope_int_int) {
             listener.exitTraversalMethod_substring_Scope_int_int(this);
        }
    }
}


export class TraversalMethod_sumContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_sum;
    }
    public override copyFrom(ctx: TraversalMethod_sumContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_sum_EmptyContext extends TraversalMethod_sumContext {
    public constructor(ctx: TraversalMethod_sumContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SUM(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SUM, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_sum_Empty) {
             listener.enterTraversalMethod_sum_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_sum_Empty) {
             listener.exitTraversalMethod_sum_Empty(this);
        }
    }
}
export class TraversalMethod_sum_ScopeContext extends TraversalMethod_sumContext {
    public constructor(ctx: TraversalMethod_sumContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_SUM(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SUM, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_sum_Scope) {
             listener.enterTraversalMethod_sum_Scope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_sum_Scope) {
             listener.exitTraversalMethod_sum_Scope(this);
        }
    }
}


export class TraversalMethod_tailContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_tail;
    }
    public override copyFrom(ctx: TraversalMethod_tailContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_tail_EmptyContext extends TraversalMethod_tailContext {
    public constructor(ctx: TraversalMethod_tailContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TAIL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TAIL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_tail_Empty) {
             listener.enterTraversalMethod_tail_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_tail_Empty) {
             listener.exitTraversalMethod_tail_Empty(this);
        }
    }
}
export class TraversalMethod_tail_ScopeContext extends TraversalMethod_tailContext {
    public constructor(ctx: TraversalMethod_tailContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TAIL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TAIL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_tail_Scope) {
             listener.enterTraversalMethod_tail_Scope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_tail_Scope) {
             listener.exitTraversalMethod_tail_Scope(this);
        }
    }
}
export class TraversalMethod_tail_Scope_longContext extends TraversalMethod_tailContext {
    public constructor(ctx: TraversalMethod_tailContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TAIL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TAIL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public integerArgument(): IntegerArgumentContext {
        return this.getRuleContext(0, IntegerArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_tail_Scope_long) {
             listener.enterTraversalMethod_tail_Scope_long(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_tail_Scope_long) {
             listener.exitTraversalMethod_tail_Scope_long(this);
        }
    }
}
export class TraversalMethod_tail_longContext extends TraversalMethod_tailContext {
    public constructor(ctx: TraversalMethod_tailContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TAIL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TAIL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public integerArgument(): IntegerArgumentContext {
        return this.getRuleContext(0, IntegerArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_tail_long) {
             listener.enterTraversalMethod_tail_long(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_tail_long) {
             listener.exitTraversalMethod_tail_long(this);
        }
    }
}


export class TraversalMethod_timeLimitContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_TIMELIMIT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TIMELIMIT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public integerLiteral(): IntegerLiteralContext {
        return this.getRuleContext(0, IntegerLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_timeLimit;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_timeLimit) {
             listener.enterTraversalMethod_timeLimit(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_timeLimit) {
             listener.exitTraversalMethod_timeLimit(this);
        }
    }
}


export class TraversalMethod_timesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_TIMES(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TIMES, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public integerLiteral(): IntegerLiteralContext {
        return this.getRuleContext(0, IntegerLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_times;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_times) {
             listener.enterTraversalMethod_times(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_times) {
             listener.exitTraversalMethod_times(this);
        }
    }
}


export class TraversalMethod_toContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_to;
    }
    public override copyFrom(ctx: TraversalMethod_toContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_to_Direction_StringContext extends TraversalMethod_toContext {
    public constructor(ctx: TraversalMethod_toContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TO(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TO, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalDirection(): TraversalDirectionContext {
        return this.getRuleContext(0, TraversalDirectionContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public stringNullableArgumentVarargs(): StringNullableArgumentVarargsContext | null {
        return this.getRuleContext(0, StringNullableArgumentVarargsContext);
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_to_Direction_String) {
             listener.enterTraversalMethod_to_Direction_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_to_Direction_String) {
             listener.exitTraversalMethod_to_Direction_String(this);
        }
    }
}
export class TraversalMethod_to_StringContext extends TraversalMethod_toContext {
    public constructor(ctx: TraversalMethod_toContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TO(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TO, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_to_String) {
             listener.enterTraversalMethod_to_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_to_String) {
             listener.exitTraversalMethod_to_String(this);
        }
    }
}
export class TraversalMethod_to_TraversalContext extends TraversalMethod_toContext {
    public constructor(ctx: TraversalMethod_toContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TO(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TO, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_to_Traversal) {
             listener.enterTraversalMethod_to_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_to_Traversal) {
             listener.exitTraversalMethod_to_Traversal(this);
        }
    }
}


export class TraversalMethod_toEContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_TOE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TOE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalDirection(): TraversalDirectionContext {
        return this.getRuleContext(0, TraversalDirectionContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public stringNullableArgumentVarargs(): StringNullableArgumentVarargsContext | null {
        return this.getRuleContext(0, StringNullableArgumentVarargsContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_toE;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_toE) {
             listener.enterTraversalMethod_toE(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_toE) {
             listener.exitTraversalMethod_toE(this);
        }
    }
}


export class TraversalMethod_toLowerContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_toLower;
    }
    public override copyFrom(ctx: TraversalMethod_toLowerContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_toLower_EmptyContext extends TraversalMethod_toLowerContext {
    public constructor(ctx: TraversalMethod_toLowerContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TOLOWER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TOLOWER, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_toLower_Empty) {
             listener.enterTraversalMethod_toLower_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_toLower_Empty) {
             listener.exitTraversalMethod_toLower_Empty(this);
        }
    }
}
export class TraversalMethod_toLower_ScopeContext extends TraversalMethod_toLowerContext {
    public constructor(ctx: TraversalMethod_toLowerContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TOLOWER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TOLOWER, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_toLower_Scope) {
             listener.enterTraversalMethod_toLower_Scope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_toLower_Scope) {
             listener.exitTraversalMethod_toLower_Scope(this);
        }
    }
}


export class TraversalMethod_toUpperContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_toUpper;
    }
    public override copyFrom(ctx: TraversalMethod_toUpperContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_toUpper_EmptyContext extends TraversalMethod_toUpperContext {
    public constructor(ctx: TraversalMethod_toUpperContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TOUPPER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TOUPPER, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_toUpper_Empty) {
             listener.enterTraversalMethod_toUpper_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_toUpper_Empty) {
             listener.exitTraversalMethod_toUpper_Empty(this);
        }
    }
}
export class TraversalMethod_toUpper_ScopeContext extends TraversalMethod_toUpperContext {
    public constructor(ctx: TraversalMethod_toUpperContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TOUPPER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TOUPPER, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_toUpper_Scope) {
             listener.enterTraversalMethod_toUpper_Scope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_toUpper_Scope) {
             listener.exitTraversalMethod_toUpper_Scope(this);
        }
    }
}


export class TraversalMethod_toVContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_TOV(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TOV, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalDirection(): TraversalDirectionContext {
        return this.getRuleContext(0, TraversalDirectionContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_toV;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_toV) {
             listener.enterTraversalMethod_toV(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_toV) {
             listener.exitTraversalMethod_toV(this);
        }
    }
}


export class TraversalMethod_treeContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_tree;
    }
    public override copyFrom(ctx: TraversalMethod_treeContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_tree_EmptyContext extends TraversalMethod_treeContext {
    public constructor(ctx: TraversalMethod_treeContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TREE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TREE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_tree_Empty) {
             listener.enterTraversalMethod_tree_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_tree_Empty) {
             listener.exitTraversalMethod_tree_Empty(this);
        }
    }
}
export class TraversalMethod_tree_StringContext extends TraversalMethod_treeContext {
    public constructor(ctx: TraversalMethod_treeContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TREE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TREE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_tree_String) {
             listener.enterTraversalMethod_tree_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_tree_String) {
             listener.exitTraversalMethod_tree_String(this);
        }
    }
}


export class TraversalMethod_trimContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_trim;
    }
    public override copyFrom(ctx: TraversalMethod_trimContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_trim_EmptyContext extends TraversalMethod_trimContext {
    public constructor(ctx: TraversalMethod_trimContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TRIM(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TRIM, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_trim_Empty) {
             listener.enterTraversalMethod_trim_Empty(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_trim_Empty) {
             listener.exitTraversalMethod_trim_Empty(this);
        }
    }
}
export class TraversalMethod_trim_ScopeContext extends TraversalMethod_trimContext {
    public constructor(ctx: TraversalMethod_trimContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_TRIM(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TRIM, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalScope(): TraversalScopeContext {
        return this.getRuleContext(0, TraversalScopeContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_trim_Scope) {
             listener.enterTraversalMethod_trim_Scope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_trim_Scope) {
             listener.exitTraversalMethod_trim_Scope(this);
        }
    }
}


export class TraversalMethod_unfoldContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_UNFOLD(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_UNFOLD, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_unfold;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_unfold) {
             listener.enterTraversalMethod_unfold(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_unfold) {
             listener.exitTraversalMethod_unfold(this);
        }
    }
}


export class TraversalMethod_unionContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_UNION(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_UNION, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversalList(): NestedTraversalListContext {
        return this.getRuleContext(0, NestedTraversalListContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_union;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_union) {
             listener.enterTraversalMethod_union(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_union) {
             listener.exitTraversalMethod_union(this);
        }
    }
}


export class TraversalMethod_untilContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_until;
    }
    public override copyFrom(ctx: TraversalMethod_untilContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_until_PredicateContext extends TraversalMethod_untilContext {
    public constructor(ctx: TraversalMethod_untilContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_UNTIL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_UNTIL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_until_Predicate) {
             listener.enterTraversalMethod_until_Predicate(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_until_Predicate) {
             listener.exitTraversalMethod_until_Predicate(this);
        }
    }
}
export class TraversalMethod_until_TraversalContext extends TraversalMethod_untilContext {
    public constructor(ctx: TraversalMethod_untilContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_UNTIL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_UNTIL, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_until_Traversal) {
             listener.enterTraversalMethod_until_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_until_Traversal) {
             listener.exitTraversalMethod_until_Traversal(this);
        }
    }
}


export class TraversalMethod_valueContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_VALUE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_VALUE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_value;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_value) {
             listener.enterTraversalMethod_value(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_value) {
             listener.exitTraversalMethod_value(this);
        }
    }
}


export class TraversalMethod_valueMapContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_valueMap;
    }
    public override copyFrom(ctx: TraversalMethod_valueMapContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_valueMap_StringContext extends TraversalMethod_valueMapContext {
    public constructor(ctx: TraversalMethod_valueMapContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_VALUEMAP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_VALUEMAP, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_valueMap_String) {
             listener.enterTraversalMethod_valueMap_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_valueMap_String) {
             listener.exitTraversalMethod_valueMap_String(this);
        }
    }
}
export class TraversalMethod_valueMap_boolean_StringContext extends TraversalMethod_valueMapContext {
    public constructor(ctx: TraversalMethod_valueMapContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_VALUEMAP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_VALUEMAP, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public booleanLiteral(): BooleanLiteralContext {
        return this.getRuleContext(0, BooleanLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COMMA, 0);
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext | null {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext);
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_valueMap_boolean_String) {
             listener.enterTraversalMethod_valueMap_boolean_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_valueMap_boolean_String) {
             listener.exitTraversalMethod_valueMap_boolean_String(this);
        }
    }
}


export class TraversalMethod_valuesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_VALUES(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_VALUES, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringNullableLiteralVarargs(): StringNullableLiteralVarargsContext {
        return this.getRuleContext(0, StringNullableLiteralVarargsContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_values;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_values) {
             listener.enterTraversalMethod_values(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_values) {
             listener.exitTraversalMethod_values(this);
        }
    }
}


export class TraversalMethod_whereContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_where;
    }
    public override copyFrom(ctx: TraversalMethod_whereContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_where_PContext extends TraversalMethod_whereContext {
    public constructor(ctx: TraversalMethod_whereContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_WHERE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WHERE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_where_P) {
             listener.enterTraversalMethod_where_P(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_where_P) {
             listener.exitTraversalMethod_where_P(this);
        }
    }
}
export class TraversalMethod_where_String_PContext extends TraversalMethod_whereContext {
    public constructor(ctx: TraversalMethod_whereContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_WHERE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WHERE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_where_String_P) {
             listener.enterTraversalMethod_where_String_P(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_where_String_P) {
             listener.exitTraversalMethod_where_String_P(this);
        }
    }
}
export class TraversalMethod_where_TraversalContext extends TraversalMethod_whereContext {
    public constructor(ctx: TraversalMethod_whereContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_WHERE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WHERE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public nestedTraversal(): NestedTraversalContext {
        return this.getRuleContext(0, NestedTraversalContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_where_Traversal) {
             listener.enterTraversalMethod_where_Traversal(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_where_Traversal) {
             listener.exitTraversalMethod_where_Traversal(this);
        }
    }
}


export class TraversalMethod_withContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_with;
    }
    public override copyFrom(ctx: TraversalMethod_withContext): void {
        super.copyFrom(ctx);
    }
}
export class TraversalMethod_with_StringContext extends TraversalMethod_withContext {
    public constructor(ctx: TraversalMethod_withContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_WITH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WITH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public withOptionKeys(): WithOptionKeysContext | null {
        return this.getRuleContext(0, WithOptionKeysContext);
    }
    public stringLiteral(): StringLiteralContext | null {
        return this.getRuleContext(0, StringLiteralContext);
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_with_String) {
             listener.enterTraversalMethod_with_String(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_with_String) {
             listener.exitTraversalMethod_with_String(this);
        }
    }
}
export class TraversalMethod_with_String_ObjectContext extends TraversalMethod_withContext {
    public constructor(ctx: TraversalMethod_withContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public K_WITH(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WITH, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public withOptionKeys(): WithOptionKeysContext | null {
        return this.getRuleContext(0, WithOptionKeysContext);
    }
    public stringLiteral(): StringLiteralContext | null {
        return this.getRuleContext(0, StringLiteralContext);
    }
    public withOptionsValues(): WithOptionsValuesContext | null {
        return this.getRuleContext(0, WithOptionsValuesContext);
    }
    public ioOptionsValues(): IoOptionsValuesContext | null {
        return this.getRuleContext(0, IoOptionsValuesContext);
    }
    public genericLiteral(): GenericLiteralContext | null {
        return this.getRuleContext(0, GenericLiteralContext);
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_with_String_Object) {
             listener.enterTraversalMethod_with_String_Object(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_with_String_Object) {
             listener.exitTraversalMethod_with_String_Object(this);
        }
    }
}


export class TraversalMethod_writeContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_WRITE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WRITE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMethod_write;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMethod_write) {
             listener.enterTraversalMethod_write(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMethod_write) {
             listener.exitTraversalMethod_write(this);
        }
    }
}


export class TraversalStrategyContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public classType(): ClassTypeContext {
        return this.getRuleContext(0, ClassTypeContext)!;
    }
    public K_NEW(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NEW, 0);
    }
    public LPAREN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.LPAREN, 0);
    }
    public RPAREN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.RPAREN, 0);
    }
    public configuration(): ConfigurationContext[];
    public configuration(i: number): ConfigurationContext | null;
    public configuration(i?: number): ConfigurationContext[] | ConfigurationContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ConfigurationContext);
        }

        return this.getRuleContext(i, ConfigurationContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalStrategy;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalStrategy) {
             listener.enterTraversalStrategy(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalStrategy) {
             listener.exitTraversalStrategy(this);
        }
    }
}


export class ConfigurationContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public COLON(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COLON, 0)!;
    }
    public genericArgument(): GenericArgumentContext {
        return this.getRuleContext(0, GenericArgumentContext)!;
    }
    public keyword(): KeywordContext | null {
        return this.getRuleContext(0, KeywordContext);
    }
    public nakedKey(): NakedKeyContext | null {
        return this.getRuleContext(0, NakedKeyContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_configuration;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterConfiguration) {
             listener.enterConfiguration(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitConfiguration) {
             listener.exitConfiguration(this);
        }
    }
}


export class TraversalScopeContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_LOCAL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LOCAL, 0);
    }
    public K_SCOPE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SCOPE, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_GLOBAL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GLOBAL, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalScope;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalScope) {
             listener.enterTraversalScope(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalScope) {
             listener.exitTraversalScope(this);
        }
    }
}


export class TraversalBarrierContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_NORMSACK(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_NORMSACK, 0)!;
    }
    public K_BARRIERU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BARRIERU, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalBarrier;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalBarrier) {
             listener.enterTraversalBarrier(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalBarrier) {
             listener.exitTraversalBarrier(this);
        }
    }
}


export class TraversalTContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalTShort(): TraversalTShortContext | null {
        return this.getRuleContext(0, TraversalTShortContext);
    }
    public traversalTLong(): TraversalTLongContext | null {
        return this.getRuleContext(0, TraversalTLongContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalT;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalT) {
             listener.enterTraversalT(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalT) {
             listener.exitTraversalT(this);
        }
    }
}


export class TraversalTShortContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_ID(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ID, 0);
    }
    public K_LABEL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LABEL, 0);
    }
    public K_KEY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_KEY, 0);
    }
    public K_VALUE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_VALUE, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalTShort;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalTShort) {
             listener.enterTraversalTShort(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalTShort) {
             listener.exitTraversalTShort(this);
        }
    }
}


export class TraversalTLongContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_T(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_T, 0)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_ID(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ID, 0);
    }
    public K_LABEL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LABEL, 0);
    }
    public K_KEY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_KEY, 0);
    }
    public K_VALUE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_VALUE, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalTLong;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalTLong) {
             listener.enterTraversalTLong(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalTLong) {
             listener.exitTraversalTLong(this);
        }
    }
}


export class TraversalMergeContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_ONCREATE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ONCREATE, 0);
    }
    public K_MERGEU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MERGEU, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_ONMATCH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ONMATCH, 0);
    }
    public K_OUTV(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OUTV, 0);
    }
    public K_INV(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INV, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalMerge;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalMerge) {
             listener.enterTraversalMerge(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalMerge) {
             listener.exitTraversalMerge(this);
        }
    }
}


export class TraversalOrderContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_ASC(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ASC, 0);
    }
    public K_ORDERU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ORDERU, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_DESC(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DESC, 0);
    }
    public K_SHUFFLE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SHUFFLE, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalOrder;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalOrder) {
             listener.enterTraversalOrder(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalOrder) {
             listener.exitTraversalOrder(this);
        }
    }
}


export class TraversalDirectionContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalDirectionShort(): TraversalDirectionShortContext | null {
        return this.getRuleContext(0, TraversalDirectionShortContext);
    }
    public traversalDirectionLong(): TraversalDirectionLongContext | null {
        return this.getRuleContext(0, TraversalDirectionLongContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalDirection;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalDirection) {
             listener.enterTraversalDirection(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalDirection) {
             listener.exitTraversalDirection(this);
        }
    }
}


export class TraversalDirectionShortContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_INU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INU, 0);
    }
    public K_FROM(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FROM, 0);
    }
    public K_OUTU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OUTU, 0);
    }
    public K_TO(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TO, 0);
    }
    public K_BOTHU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BOTHU, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalDirectionShort;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalDirectionShort) {
             listener.enterTraversalDirectionShort(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalDirectionShort) {
             listener.exitTraversalDirectionShort(this);
        }
    }
}


export class TraversalDirectionLongContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_DIRECTION(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DIRECTION, 0)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_INU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INU, 0);
    }
    public K_FROM(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FROM, 0);
    }
    public K_OUTU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OUTU, 0);
    }
    public K_TO(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TO, 0);
    }
    public K_BOTHU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BOTHU, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalDirectionLong;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalDirectionLong) {
             listener.enterTraversalDirectionLong(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalDirectionLong) {
             listener.exitTraversalDirectionLong(this);
        }
    }
}


export class TraversalCardinalityContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.LPAREN, 0);
    }
    public genericLiteral(): GenericLiteralContext | null {
        return this.getRuleContext(0, GenericLiteralContext);
    }
    public RPAREN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.RPAREN, 0);
    }
    public K_CARDINALITY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CARDINALITY, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_SINGLE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SINGLE, 0);
    }
    public K_SET(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SET, 0);
    }
    public K_LIST(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LIST, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalCardinality;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalCardinality) {
             listener.enterTraversalCardinality(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalCardinality) {
             listener.exitTraversalCardinality(this);
        }
    }
}


export class TraversalColumnContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_KEYS(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_KEYS, 0);
    }
    public K_COLUMN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_COLUMN, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_VALUES(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_VALUES, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalColumn;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalColumn) {
             listener.enterTraversalColumn(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalColumn) {
             listener.exitTraversalColumn(this);
        }
    }
}


export class TraversalPopContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_FIRST(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FIRST, 0);
    }
    public K_POP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_POP, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_LAST(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LAST, 0);
    }
    public K_ALL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ALL, 0);
    }
    public K_MIXED(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MIXED, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPop;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPop) {
             listener.enterTraversalPop(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPop) {
             listener.exitTraversalPop(this);
        }
    }
}


export class TraversalOperatorContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_ADDALL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ADDALL, 0);
    }
    public K_OPERATOR(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OPERATOR, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_AND(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_AND, 0);
    }
    public K_ASSIGN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ASSIGN, 0);
    }
    public K_DIV(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DIV, 0);
    }
    public K_MAX(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MAX, 0);
    }
    public K_MIN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MIN, 0);
    }
    public K_MINUS(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MINUS, 0);
    }
    public K_MULT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MULT, 0);
    }
    public K_OR(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OR, 0);
    }
    public K_SUM(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SUM, 0);
    }
    public K_SUMLONG(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SUMLONG, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalOperator;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalOperator) {
             listener.enterTraversalOperator(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalOperator) {
             listener.exitTraversalOperator(this);
        }
    }
}


export class TraversalPickContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_ANY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ANY, 0);
    }
    public K_PICK(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PICK, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_NONE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NONE, 0);
    }
    public K_UNPRODUCTIVE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_UNPRODUCTIVE, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPick;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPick) {
             listener.enterTraversalPick(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPick) {
             listener.exitTraversalPick(this);
        }
    }
}


export class TraversalDTContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_SECOND(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SECOND, 0);
    }
    public K_DT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DT, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_MINUTE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MINUTE, 0);
    }
    public K_HOUR(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_HOUR, 0);
    }
    public K_DAY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DAY, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalDT;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalDT) {
             listener.enterTraversalDT(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalDT) {
             listener.exitTraversalDT(this);
        }
    }
}


export class TraversalGTypeContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_BIGDECIMAL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BIGDECIMAL, 0);
    }
    public K_GTYPE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GTYPE, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_BIGDECIMALU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BIGDECIMALU, 0);
    }
    public K_BIGINT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BIGINT, 0);
    }
    public K_BIGINTU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BIGINTU, 0);
    }
    public K_BINARY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BINARY, 0);
    }
    public K_BINARYU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BINARYU, 0);
    }
    public K_BOOLEAN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BOOLEAN, 0);
    }
    public K_BOOLEANU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BOOLEANU, 0);
    }
    public K_BYTE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BYTE, 0);
    }
    public K_BYTEU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BYTEU, 0);
    }
    public K_CHAR(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CHAR, 0);
    }
    public K_CHARU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CHARU, 0);
    }
    public K_DATETIME(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DATETIME, 0);
    }
    public K_DATETIMEU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DATETIMEU, 0);
    }
    public K_DOUBLE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DOUBLE, 0);
    }
    public K_DOUBLEU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DOUBLEU, 0);
    }
    public K_DURATION(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DURATION, 0);
    }
    public K_DURATIONU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DURATIONU, 0);
    }
    public K_EDGE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_EDGE, 0);
    }
    public K_EDGEU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_EDGEU, 0);
    }
    public K_FLOAT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FLOAT, 0);
    }
    public K_FLOATU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FLOATU, 0);
    }
    public K_GRAPH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GRAPH, 0);
    }
    public K_GRAPHU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GRAPHU, 0);
    }
    public K_INT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INT, 0);
    }
    public K_INTU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INTU, 0);
    }
    public K_LIST(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LIST, 0);
    }
    public K_LISTU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LISTU, 0);
    }
    public K_LONG(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LONG, 0);
    }
    public K_LONGU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LONGU, 0);
    }
    public K_MAP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MAP, 0);
    }
    public K_MAPU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MAPU, 0);
    }
    public K_NULL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NULL, 0);
    }
    public K_NULLU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NULLU, 0);
    }
    public K_NUMBER(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NUMBER, 0);
    }
    public K_NUMBERU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NUMBERU, 0);
    }
    public K_PATH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PATH, 0);
    }
    public K_PATHU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PATHU, 0);
    }
    public K_PROPERTY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PROPERTY, 0);
    }
    public K_PROPERTYU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PROPERTYU, 0);
    }
    public K_SET(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SET, 0);
    }
    public K_SETU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SETU, 0);
    }
    public K_SHORT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SHORT, 0);
    }
    public K_SHORTU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SHORTU, 0);
    }
    public K_STRING(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_STRING, 0);
    }
    public K_STRINGU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_STRINGU, 0);
    }
    public K_TREE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TREE, 0);
    }
    public K_TREEU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TREEU, 0);
    }
    public K_UUID(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_UUID, 0);
    }
    public K_UUIDL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_UUIDL, 0);
    }
    public K_VERTEX(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_VERTEX, 0);
    }
    public K_VERTEXU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_VERTEXU, 0);
    }
    public K_VPROPERTY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_VPROPERTY, 0);
    }
    public K_VPROPERTYU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_VPROPERTYU, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalGType;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalGType) {
             listener.enterTraversalGType(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalGType) {
             listener.exitTraversalGType(this);
        }
    }
}


export class TraversalPredicateContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalPredicate_eq(): TraversalPredicate_eqContext | null {
        return this.getRuleContext(0, TraversalPredicate_eqContext);
    }
    public traversalPredicate_neq(): TraversalPredicate_neqContext | null {
        return this.getRuleContext(0, TraversalPredicate_neqContext);
    }
    public traversalPredicate_lt(): TraversalPredicate_ltContext | null {
        return this.getRuleContext(0, TraversalPredicate_ltContext);
    }
    public traversalPredicate_lte(): TraversalPredicate_lteContext | null {
        return this.getRuleContext(0, TraversalPredicate_lteContext);
    }
    public traversalPredicate_gt(): TraversalPredicate_gtContext | null {
        return this.getRuleContext(0, TraversalPredicate_gtContext);
    }
    public traversalPredicate_gte(): TraversalPredicate_gteContext | null {
        return this.getRuleContext(0, TraversalPredicate_gteContext);
    }
    public traversalPredicate_inside(): TraversalPredicate_insideContext | null {
        return this.getRuleContext(0, TraversalPredicate_insideContext);
    }
    public traversalPredicate_outside(): TraversalPredicate_outsideContext | null {
        return this.getRuleContext(0, TraversalPredicate_outsideContext);
    }
    public traversalPredicate_between(): TraversalPredicate_betweenContext | null {
        return this.getRuleContext(0, TraversalPredicate_betweenContext);
    }
    public traversalPredicate_typeOf(): TraversalPredicate_typeOfContext | null {
        return this.getRuleContext(0, TraversalPredicate_typeOfContext);
    }
    public traversalPredicate_within(): TraversalPredicate_withinContext | null {
        return this.getRuleContext(0, TraversalPredicate_withinContext);
    }
    public traversalPredicate_without(): TraversalPredicate_withoutContext | null {
        return this.getRuleContext(0, TraversalPredicate_withoutContext);
    }
    public traversalPredicate_not(): TraversalPredicate_notContext | null {
        return this.getRuleContext(0, TraversalPredicate_notContext);
    }
    public traversalPredicate_startingWith(): TraversalPredicate_startingWithContext | null {
        return this.getRuleContext(0, TraversalPredicate_startingWithContext);
    }
    public traversalPredicate_notStartingWith(): TraversalPredicate_notStartingWithContext | null {
        return this.getRuleContext(0, TraversalPredicate_notStartingWithContext);
    }
    public traversalPredicate_endingWith(): TraversalPredicate_endingWithContext | null {
        return this.getRuleContext(0, TraversalPredicate_endingWithContext);
    }
    public traversalPredicate_notEndingWith(): TraversalPredicate_notEndingWithContext | null {
        return this.getRuleContext(0, TraversalPredicate_notEndingWithContext);
    }
    public traversalPredicate_containing(): TraversalPredicate_containingContext | null {
        return this.getRuleContext(0, TraversalPredicate_containingContext);
    }
    public traversalPredicate_notContaining(): TraversalPredicate_notContainingContext | null {
        return this.getRuleContext(0, TraversalPredicate_notContainingContext);
    }
    public traversalPredicate_regex(): TraversalPredicate_regexContext | null {
        return this.getRuleContext(0, TraversalPredicate_regexContext);
    }
    public traversalPredicate_notRegex(): TraversalPredicate_notRegexContext | null {
        return this.getRuleContext(0, TraversalPredicate_notRegexContext);
    }
    public traversalPredicate(): TraversalPredicateContext[];
    public traversalPredicate(i: number): TraversalPredicateContext | null;
    public traversalPredicate(i?: number): TraversalPredicateContext[] | TraversalPredicateContext | null {
        if (i === undefined) {
            return this.getRuleContexts(TraversalPredicateContext);
        }

        return this.getRuleContext(i, TraversalPredicateContext);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_AND(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_AND, 0);
    }
    public LPAREN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.LPAREN, 0);
    }
    public RPAREN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.RPAREN, 0);
    }
    public K_OR(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OR, 0);
    }
    public K_NEGATE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NEGATE, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate) {
             listener.enterTraversalPredicate(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate) {
             listener.exitTraversalPredicate(this);
        }
    }
}


export class TraversalTerminalMethodContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalTerminalMethod_explain(): TraversalTerminalMethod_explainContext | null {
        return this.getRuleContext(0, TraversalTerminalMethod_explainContext);
    }
    public traversalTerminalMethod_iterate(): TraversalTerminalMethod_iterateContext | null {
        return this.getRuleContext(0, TraversalTerminalMethod_iterateContext);
    }
    public traversalTerminalMethod_hasNext(): TraversalTerminalMethod_hasNextContext | null {
        return this.getRuleContext(0, TraversalTerminalMethod_hasNextContext);
    }
    public traversalTerminalMethod_tryNext(): TraversalTerminalMethod_tryNextContext | null {
        return this.getRuleContext(0, TraversalTerminalMethod_tryNextContext);
    }
    public traversalTerminalMethod_next(): TraversalTerminalMethod_nextContext | null {
        return this.getRuleContext(0, TraversalTerminalMethod_nextContext);
    }
    public traversalTerminalMethod_toList(): TraversalTerminalMethod_toListContext | null {
        return this.getRuleContext(0, TraversalTerminalMethod_toListContext);
    }
    public traversalTerminalMethod_toSet(): TraversalTerminalMethod_toSetContext | null {
        return this.getRuleContext(0, TraversalTerminalMethod_toSetContext);
    }
    public traversalTerminalMethod_toBulkSet(): TraversalTerminalMethod_toBulkSetContext | null {
        return this.getRuleContext(0, TraversalTerminalMethod_toBulkSetContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalTerminalMethod;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalTerminalMethod) {
             listener.enterTraversalTerminalMethod(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalTerminalMethod) {
             listener.exitTraversalTerminalMethod(this);
        }
    }
}


export class TraversalSackMethodContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalBarrier(): TraversalBarrierContext {
        return this.getRuleContext(0, TraversalBarrierContext)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalSackMethod;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalSackMethod) {
             listener.enterTraversalSackMethod(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalSackMethod) {
             listener.exitTraversalSackMethod(this);
        }
    }
}


export class TraversalComparatorContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalOrder(): TraversalOrderContext {
        return this.getRuleContext(0, TraversalOrderContext)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalComparator;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalComparator) {
             listener.enterTraversalComparator(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalComparator) {
             listener.exitTraversalComparator(this);
        }
    }
}


export class TraversalFunctionContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalT(): TraversalTContext | null {
        return this.getRuleContext(0, TraversalTContext);
    }
    public traversalColumn(): TraversalColumnContext | null {
        return this.getRuleContext(0, TraversalColumnContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalFunction;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalFunction) {
             listener.enterTraversalFunction(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalFunction) {
             listener.exitTraversalFunction(this);
        }
    }
}


export class TraversalBiFunctionContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalOperator(): TraversalOperatorContext {
        return this.getRuleContext(0, TraversalOperatorContext)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalBiFunction;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalBiFunction) {
             listener.enterTraversalBiFunction(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalBiFunction) {
             listener.exitTraversalBiFunction(this);
        }
    }
}


export class TraversalPredicate_eqContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgument(): GenericArgumentContext | null {
        return this.getRuleContext(0, GenericArgumentContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_P(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_P, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_EQ(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_EQ, 0);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_eq;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_eq) {
             listener.enterTraversalPredicate_eq(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_eq) {
             listener.exitTraversalPredicate_eq(this);
        }
    }
}


export class TraversalPredicate_neqContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgument(): GenericArgumentContext | null {
        return this.getRuleContext(0, GenericArgumentContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_P(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_P, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_NEQ(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NEQ, 0);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_neq;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_neq) {
             listener.enterTraversalPredicate_neq(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_neq) {
             listener.exitTraversalPredicate_neq(this);
        }
    }
}


export class TraversalPredicate_typeOfContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalGType(): TraversalGTypeContext | null {
        return this.getRuleContext(0, TraversalGTypeContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_P(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_P, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_TYPEOF(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TYPEOF, 0);
    }
    public stringLiteral(): StringLiteralContext | null {
        return this.getRuleContext(0, StringLiteralContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_typeOf;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_typeOf) {
             listener.enterTraversalPredicate_typeOf(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_typeOf) {
             listener.exitTraversalPredicate_typeOf(this);
        }
    }
}


export class TraversalPredicate_ltContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgument(): GenericArgumentContext | null {
        return this.getRuleContext(0, GenericArgumentContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_P(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_P, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_LT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LT, 0);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_lt;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_lt) {
             listener.enterTraversalPredicate_lt(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_lt) {
             listener.exitTraversalPredicate_lt(this);
        }
    }
}


export class TraversalPredicate_lteContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgument(): GenericArgumentContext | null {
        return this.getRuleContext(0, GenericArgumentContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_P(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_P, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_LTE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LTE, 0);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_lte;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_lte) {
             listener.enterTraversalPredicate_lte(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_lte) {
             listener.exitTraversalPredicate_lte(this);
        }
    }
}


export class TraversalPredicate_gtContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgument(): GenericArgumentContext | null {
        return this.getRuleContext(0, GenericArgumentContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_P(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_P, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_GT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GT, 0);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_gt;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_gt) {
             listener.enterTraversalPredicate_gt(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_gt) {
             listener.exitTraversalPredicate_gt(this);
        }
    }
}


export class TraversalPredicate_gteContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgument(): GenericArgumentContext | null {
        return this.getRuleContext(0, GenericArgumentContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_P(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_P, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_GTE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GTE, 0);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_gte;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_gte) {
             listener.enterTraversalPredicate_gte(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_gte) {
             listener.exitTraversalPredicate_gte(this);
        }
    }
}


export class TraversalPredicate_insideContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgument(): GenericArgumentContext[];
    public genericArgument(i: number): GenericArgumentContext | null;
    public genericArgument(i?: number): GenericArgumentContext[] | GenericArgumentContext | null {
        if (i === undefined) {
            return this.getRuleContexts(GenericArgumentContext);
        }

        return this.getRuleContext(i, GenericArgumentContext);
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_P(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_P, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_INSIDE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INSIDE, 0);
    }
    public nestedTraversal(): NestedTraversalContext[];
    public nestedTraversal(i: number): NestedTraversalContext | null;
    public nestedTraversal(i?: number): NestedTraversalContext[] | NestedTraversalContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NestedTraversalContext);
        }

        return this.getRuleContext(i, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_inside;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_inside) {
             listener.enterTraversalPredicate_inside(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_inside) {
             listener.exitTraversalPredicate_inside(this);
        }
    }
}


export class TraversalPredicate_outsideContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgument(): GenericArgumentContext[];
    public genericArgument(i: number): GenericArgumentContext | null;
    public genericArgument(i?: number): GenericArgumentContext[] | GenericArgumentContext | null {
        if (i === undefined) {
            return this.getRuleContexts(GenericArgumentContext);
        }

        return this.getRuleContext(i, GenericArgumentContext);
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_P(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_P, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_OUTSIDE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OUTSIDE, 0);
    }
    public nestedTraversal(): NestedTraversalContext[];
    public nestedTraversal(i: number): NestedTraversalContext | null;
    public nestedTraversal(i?: number): NestedTraversalContext[] | NestedTraversalContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NestedTraversalContext);
        }

        return this.getRuleContext(i, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_outside;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_outside) {
             listener.enterTraversalPredicate_outside(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_outside) {
             listener.exitTraversalPredicate_outside(this);
        }
    }
}


export class TraversalPredicate_betweenContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public genericArgument(): GenericArgumentContext[];
    public genericArgument(i: number): GenericArgumentContext | null;
    public genericArgument(i?: number): GenericArgumentContext[] | GenericArgumentContext | null {
        if (i === undefined) {
            return this.getRuleContexts(GenericArgumentContext);
        }

        return this.getRuleContext(i, GenericArgumentContext);
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_P(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_P, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_BETWEEN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BETWEEN, 0);
    }
    public nestedTraversal(): NestedTraversalContext[];
    public nestedTraversal(i: number): NestedTraversalContext | null;
    public nestedTraversal(i?: number): NestedTraversalContext[] | NestedTraversalContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NestedTraversalContext);
        }

        return this.getRuleContext(i, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_between;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_between) {
             listener.enterTraversalPredicate_between(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_between) {
             listener.exitTraversalPredicate_between(this);
        }
    }
}


export class TraversalPredicate_withinContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_P(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_P, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_WITHIN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WITHIN, 0);
    }
    public genericArgumentVarargs(): GenericArgumentVarargsContext | null {
        return this.getRuleContext(0, GenericArgumentVarargsContext);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_within;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_within) {
             listener.enterTraversalPredicate_within(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_within) {
             listener.exitTraversalPredicate_within(this);
        }
    }
}


export class TraversalPredicate_withoutContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_P(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_P, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_WITHOUT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WITHOUT, 0);
    }
    public genericArgumentVarargs(): GenericArgumentVarargsContext | null {
        return this.getRuleContext(0, GenericArgumentVarargsContext);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_without;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_without) {
             listener.enterTraversalPredicate_without(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_without) {
             listener.exitTraversalPredicate_without(this);
        }
    }
}


export class TraversalPredicate_notContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public traversalPredicate(): TraversalPredicateContext {
        return this.getRuleContext(0, TraversalPredicateContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_P(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_P, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_NOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NOT, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_not;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_not) {
             listener.enterTraversalPredicate_not(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_not) {
             listener.exitTraversalPredicate_not(this);
        }
    }
}


export class TraversalPredicate_containingContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringArgument(): StringArgumentContext | null {
        return this.getRuleContext(0, StringArgumentContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_TEXTP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TEXTP, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_CONTAINING(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CONTAINING, 0);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_containing;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_containing) {
             listener.enterTraversalPredicate_containing(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_containing) {
             listener.exitTraversalPredicate_containing(this);
        }
    }
}


export class TraversalPredicate_notContainingContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringArgument(): StringArgumentContext | null {
        return this.getRuleContext(0, StringArgumentContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_TEXTP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TEXTP, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_NOTCONTAINING(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NOTCONTAINING, 0);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_notContaining;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_notContaining) {
             listener.enterTraversalPredicate_notContaining(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_notContaining) {
             listener.exitTraversalPredicate_notContaining(this);
        }
    }
}


export class TraversalPredicate_startingWithContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringArgument(): StringArgumentContext | null {
        return this.getRuleContext(0, StringArgumentContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_TEXTP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TEXTP, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_STARTINGWITH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_STARTINGWITH, 0);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_startingWith;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_startingWith) {
             listener.enterTraversalPredicate_startingWith(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_startingWith) {
             listener.exitTraversalPredicate_startingWith(this);
        }
    }
}


export class TraversalPredicate_notStartingWithContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringArgument(): StringArgumentContext | null {
        return this.getRuleContext(0, StringArgumentContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_TEXTP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TEXTP, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_NOTSTARTINGWITH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NOTSTARTINGWITH, 0);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_notStartingWith;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_notStartingWith) {
             listener.enterTraversalPredicate_notStartingWith(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_notStartingWith) {
             listener.exitTraversalPredicate_notStartingWith(this);
        }
    }
}


export class TraversalPredicate_endingWithContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringArgument(): StringArgumentContext | null {
        return this.getRuleContext(0, StringArgumentContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_TEXTP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TEXTP, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_ENDINGWITH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ENDINGWITH, 0);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_endingWith;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_endingWith) {
             listener.enterTraversalPredicate_endingWith(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_endingWith) {
             listener.exitTraversalPredicate_endingWith(this);
        }
    }
}


export class TraversalPredicate_notEndingWithContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringArgument(): StringArgumentContext | null {
        return this.getRuleContext(0, StringArgumentContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_TEXTP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TEXTP, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_NOTENDINGWITH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NOTENDINGWITH, 0);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_notEndingWith;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_notEndingWith) {
             listener.enterTraversalPredicate_notEndingWith(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_notEndingWith) {
             listener.exitTraversalPredicate_notEndingWith(this);
        }
    }
}


export class TraversalPredicate_regexContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringArgument(): StringArgumentContext {
        return this.getRuleContext(0, StringArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_TEXTP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TEXTP, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_REGEX(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_REGEX, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_regex;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_regex) {
             listener.enterTraversalPredicate_regex(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_regex) {
             listener.exitTraversalPredicate_regex(this);
        }
    }
}


export class TraversalPredicate_notRegexContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringArgument(): StringArgumentContext {
        return this.getRuleContext(0, StringArgumentContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_TEXTP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TEXTP, 0);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.DOT, 0);
    }
    public K_NOTREGEX(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NOTREGEX, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalPredicate_notRegex;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalPredicate_notRegex) {
             listener.enterTraversalPredicate_notRegex(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalPredicate_notRegex) {
             listener.exitTraversalPredicate_notRegex(this);
        }
    }
}


export class TraversalTerminalMethod_explainContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_EXPLAIN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_EXPLAIN, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalTerminalMethod_explain;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalTerminalMethod_explain) {
             listener.enterTraversalTerminalMethod_explain(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalTerminalMethod_explain) {
             listener.exitTraversalTerminalMethod_explain(this);
        }
    }
}


export class TraversalTerminalMethod_hasNextContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_HASNEXT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_HASNEXT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalTerminalMethod_hasNext;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalTerminalMethod_hasNext) {
             listener.enterTraversalTerminalMethod_hasNext(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalTerminalMethod_hasNext) {
             listener.exitTraversalTerminalMethod_hasNext(this);
        }
    }
}


export class TraversalTerminalMethod_iterateContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_ITERATE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ITERATE, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalTerminalMethod_iterate;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalTerminalMethod_iterate) {
             listener.enterTraversalTerminalMethod_iterate(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalTerminalMethod_iterate) {
             listener.exitTraversalTerminalMethod_iterate(this);
        }
    }
}


export class TraversalTerminalMethod_tryNextContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_TRYNEXT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TRYNEXT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalTerminalMethod_tryNext;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalTerminalMethod_tryNext) {
             listener.enterTraversalTerminalMethod_tryNext(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalTerminalMethod_tryNext) {
             listener.exitTraversalTerminalMethod_tryNext(this);
        }
    }
}


export class TraversalTerminalMethod_nextContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_NEXT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_NEXT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public integerLiteral(): IntegerLiteralContext | null {
        return this.getRuleContext(0, IntegerLiteralContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalTerminalMethod_next;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalTerminalMethod_next) {
             listener.enterTraversalTerminalMethod_next(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalTerminalMethod_next) {
             listener.exitTraversalTerminalMethod_next(this);
        }
    }
}


export class TraversalTerminalMethod_toListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_TOLIST(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TOLIST, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalTerminalMethod_toList;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalTerminalMethod_toList) {
             listener.enterTraversalTerminalMethod_toList(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalTerminalMethod_toList) {
             listener.exitTraversalTerminalMethod_toList(this);
        }
    }
}


export class TraversalTerminalMethod_toSetContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_TOSET(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TOSET, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalTerminalMethod_toSet;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalTerminalMethod_toSet) {
             listener.enterTraversalTerminalMethod_toSet(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalTerminalMethod_toSet) {
             listener.exitTraversalTerminalMethod_toSet(this);
        }
    }
}


export class TraversalTerminalMethod_toBulkSetContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_TOBULKSET(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TOBULKSET, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalTerminalMethod_toBulkSet;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalTerminalMethod_toBulkSet) {
             listener.enterTraversalTerminalMethod_toBulkSet(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalTerminalMethod_toBulkSet) {
             listener.exitTraversalTerminalMethod_toBulkSet(this);
        }
    }
}


export class WithOptionKeysContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public shortestPathConstants(): ShortestPathConstantsContext | null {
        return this.getRuleContext(0, ShortestPathConstantsContext);
    }
    public connectedComponentConstants(): ConnectedComponentConstantsContext | null {
        return this.getRuleContext(0, ConnectedComponentConstantsContext);
    }
    public pageRankConstants(): PageRankConstantsContext | null {
        return this.getRuleContext(0, PageRankConstantsContext);
    }
    public peerPressureConstants(): PeerPressureConstantsContext | null {
        return this.getRuleContext(0, PeerPressureConstantsContext);
    }
    public ioOptionsKeys(): IoOptionsKeysContext | null {
        return this.getRuleContext(0, IoOptionsKeysContext);
    }
    public withOptionsConstants_tokens(): WithOptionsConstants_tokensContext | null {
        return this.getRuleContext(0, WithOptionsConstants_tokensContext);
    }
    public withOptionsConstants_indexer(): WithOptionsConstants_indexerContext | null {
        return this.getRuleContext(0, WithOptionsConstants_indexerContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_withOptionKeys;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterWithOptionKeys) {
             listener.enterWithOptionKeys(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitWithOptionKeys) {
             listener.exitWithOptionKeys(this);
        }
    }
}


export class ConnectedComponentConstantsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public connectedComponentConstants_component(): ConnectedComponentConstants_componentContext | null {
        return this.getRuleContext(0, ConnectedComponentConstants_componentContext);
    }
    public connectedComponentConstants_edges(): ConnectedComponentConstants_edgesContext | null {
        return this.getRuleContext(0, ConnectedComponentConstants_edgesContext);
    }
    public connectedComponentConstants_propertyName(): ConnectedComponentConstants_propertyNameContext | null {
        return this.getRuleContext(0, ConnectedComponentConstants_propertyNameContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_connectedComponentConstants;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterConnectedComponentConstants) {
             listener.enterConnectedComponentConstants(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitConnectedComponentConstants) {
             listener.exitConnectedComponentConstants(this);
        }
    }
}


export class PageRankConstantsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public pageRankConstants_edges(): PageRankConstants_edgesContext | null {
        return this.getRuleContext(0, PageRankConstants_edgesContext);
    }
    public pageRankConstants_times(): PageRankConstants_timesContext | null {
        return this.getRuleContext(0, PageRankConstants_timesContext);
    }
    public pageRankConstants_propertyName(): PageRankConstants_propertyNameContext | null {
        return this.getRuleContext(0, PageRankConstants_propertyNameContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_pageRankConstants;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterPageRankConstants) {
             listener.enterPageRankConstants(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitPageRankConstants) {
             listener.exitPageRankConstants(this);
        }
    }
}


export class PeerPressureConstantsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public peerPressureConstants_edges(): PeerPressureConstants_edgesContext | null {
        return this.getRuleContext(0, PeerPressureConstants_edgesContext);
    }
    public peerPressureConstants_times(): PeerPressureConstants_timesContext | null {
        return this.getRuleContext(0, PeerPressureConstants_timesContext);
    }
    public peerPressureConstants_propertyName(): PeerPressureConstants_propertyNameContext | null {
        return this.getRuleContext(0, PeerPressureConstants_propertyNameContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_peerPressureConstants;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterPeerPressureConstants) {
             listener.enterPeerPressureConstants(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitPeerPressureConstants) {
             listener.exitPeerPressureConstants(this);
        }
    }
}


export class ShortestPathConstantsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public shortestPathConstants_target(): ShortestPathConstants_targetContext | null {
        return this.getRuleContext(0, ShortestPathConstants_targetContext);
    }
    public shortestPathConstants_edges(): ShortestPathConstants_edgesContext | null {
        return this.getRuleContext(0, ShortestPathConstants_edgesContext);
    }
    public shortestPathConstants_distance(): ShortestPathConstants_distanceContext | null {
        return this.getRuleContext(0, ShortestPathConstants_distanceContext);
    }
    public shortestPathConstants_maxDistance(): ShortestPathConstants_maxDistanceContext | null {
        return this.getRuleContext(0, ShortestPathConstants_maxDistanceContext);
    }
    public shortestPathConstants_includeEdges(): ShortestPathConstants_includeEdgesContext | null {
        return this.getRuleContext(0, ShortestPathConstants_includeEdgesContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_shortestPathConstants;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterShortestPathConstants) {
             listener.enterShortestPathConstants(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitShortestPathConstants) {
             listener.exitShortestPathConstants(this);
        }
    }
}


export class WithOptionsValuesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public withOptionsConstants_tokens(): WithOptionsConstants_tokensContext | null {
        return this.getRuleContext(0, WithOptionsConstants_tokensContext);
    }
    public withOptionsConstants_none(): WithOptionsConstants_noneContext | null {
        return this.getRuleContext(0, WithOptionsConstants_noneContext);
    }
    public withOptionsConstants_ids(): WithOptionsConstants_idsContext | null {
        return this.getRuleContext(0, WithOptionsConstants_idsContext);
    }
    public withOptionsConstants_labels(): WithOptionsConstants_labelsContext | null {
        return this.getRuleContext(0, WithOptionsConstants_labelsContext);
    }
    public withOptionsConstants_keys(): WithOptionsConstants_keysContext | null {
        return this.getRuleContext(0, WithOptionsConstants_keysContext);
    }
    public withOptionsConstants_values(): WithOptionsConstants_valuesContext | null {
        return this.getRuleContext(0, WithOptionsConstants_valuesContext);
    }
    public withOptionsConstants_all(): WithOptionsConstants_allContext | null {
        return this.getRuleContext(0, WithOptionsConstants_allContext);
    }
    public withOptionsConstants_list(): WithOptionsConstants_listContext | null {
        return this.getRuleContext(0, WithOptionsConstants_listContext);
    }
    public withOptionsConstants_map(): WithOptionsConstants_mapContext | null {
        return this.getRuleContext(0, WithOptionsConstants_mapContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_withOptionsValues;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterWithOptionsValues) {
             listener.enterWithOptionsValues(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitWithOptionsValues) {
             listener.exitWithOptionsValues(this);
        }
    }
}


export class IoOptionsKeysContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public ioOptionsConstants_reader(): IoOptionsConstants_readerContext | null {
        return this.getRuleContext(0, IoOptionsConstants_readerContext);
    }
    public ioOptionsConstants_writer(): IoOptionsConstants_writerContext | null {
        return this.getRuleContext(0, IoOptionsConstants_writerContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_ioOptionsKeys;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterIoOptionsKeys) {
             listener.enterIoOptionsKeys(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitIoOptionsKeys) {
             listener.exitIoOptionsKeys(this);
        }
    }
}


export class IoOptionsValuesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public ioOptionsConstants_gryo(): IoOptionsConstants_gryoContext | null {
        return this.getRuleContext(0, IoOptionsConstants_gryoContext);
    }
    public ioOptionsConstants_graphson(): IoOptionsConstants_graphsonContext | null {
        return this.getRuleContext(0, IoOptionsConstants_graphsonContext);
    }
    public ioOptionsConstants_graphml(): IoOptionsConstants_graphmlContext | null {
        return this.getRuleContext(0, IoOptionsConstants_graphmlContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_ioOptionsValues;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterIoOptionsValues) {
             listener.enterIoOptionsValues(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitIoOptionsValues) {
             listener.exitIoOptionsValues(this);
        }
    }
}


export class ConnectedComponentConstants_componentContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public connectedComponentStringConstant(): ConnectedComponentStringConstantContext {
        return this.getRuleContext(0, ConnectedComponentStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_COMPONENT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_COMPONENT, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_connectedComponentConstants_component;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterConnectedComponentConstants_component) {
             listener.enterConnectedComponentConstants_component(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitConnectedComponentConstants_component) {
             listener.exitConnectedComponentConstants_component(this);
        }
    }
}


export class ConnectedComponentConstants_edgesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public connectedComponentStringConstant(): ConnectedComponentStringConstantContext {
        return this.getRuleContext(0, ConnectedComponentStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_EDGES(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_EDGES, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_connectedComponentConstants_edges;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterConnectedComponentConstants_edges) {
             listener.enterConnectedComponentConstants_edges(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitConnectedComponentConstants_edges) {
             listener.exitConnectedComponentConstants_edges(this);
        }
    }
}


export class ConnectedComponentConstants_propertyNameContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public connectedComponentStringConstant(): ConnectedComponentStringConstantContext {
        return this.getRuleContext(0, ConnectedComponentStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_PROPERTYNAME(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROPERTYNAME, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_connectedComponentConstants_propertyName;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterConnectedComponentConstants_propertyName) {
             listener.enterConnectedComponentConstants_propertyName(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitConnectedComponentConstants_propertyName) {
             listener.exitConnectedComponentConstants_propertyName(this);
        }
    }
}


export class PageRankConstants_edgesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public pageRankStringConstant(): PageRankStringConstantContext {
        return this.getRuleContext(0, PageRankStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_EDGES(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_EDGES, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_pageRankConstants_edges;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterPageRankConstants_edges) {
             listener.enterPageRankConstants_edges(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitPageRankConstants_edges) {
             listener.exitPageRankConstants_edges(this);
        }
    }
}


export class PageRankConstants_timesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public pageRankStringConstant(): PageRankStringConstantContext {
        return this.getRuleContext(0, PageRankStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_TIMES(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TIMES, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_pageRankConstants_times;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterPageRankConstants_times) {
             listener.enterPageRankConstants_times(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitPageRankConstants_times) {
             listener.exitPageRankConstants_times(this);
        }
    }
}


export class PageRankConstants_propertyNameContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public pageRankStringConstant(): PageRankStringConstantContext {
        return this.getRuleContext(0, PageRankStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_PROPERTYNAME(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROPERTYNAME, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_pageRankConstants_propertyName;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterPageRankConstants_propertyName) {
             listener.enterPageRankConstants_propertyName(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitPageRankConstants_propertyName) {
             listener.exitPageRankConstants_propertyName(this);
        }
    }
}


export class PeerPressureConstants_edgesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public peerPressureStringConstant(): PeerPressureStringConstantContext {
        return this.getRuleContext(0, PeerPressureStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_EDGES(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_EDGES, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_peerPressureConstants_edges;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterPeerPressureConstants_edges) {
             listener.enterPeerPressureConstants_edges(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitPeerPressureConstants_edges) {
             listener.exitPeerPressureConstants_edges(this);
        }
    }
}


export class PeerPressureConstants_timesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public peerPressureStringConstant(): PeerPressureStringConstantContext {
        return this.getRuleContext(0, PeerPressureStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_TIMES(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TIMES, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_peerPressureConstants_times;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterPeerPressureConstants_times) {
             listener.enterPeerPressureConstants_times(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitPeerPressureConstants_times) {
             listener.exitPeerPressureConstants_times(this);
        }
    }
}


export class PeerPressureConstants_propertyNameContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public peerPressureStringConstant(): PeerPressureStringConstantContext {
        return this.getRuleContext(0, PeerPressureStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_PROPERTYNAME(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PROPERTYNAME, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_peerPressureConstants_propertyName;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterPeerPressureConstants_propertyName) {
             listener.enterPeerPressureConstants_propertyName(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitPeerPressureConstants_propertyName) {
             listener.exitPeerPressureConstants_propertyName(this);
        }
    }
}


export class ShortestPathConstants_targetContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public shortestPathStringConstant(): ShortestPathStringConstantContext {
        return this.getRuleContext(0, ShortestPathStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_TARGET(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TARGET, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_shortestPathConstants_target;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterShortestPathConstants_target) {
             listener.enterShortestPathConstants_target(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitShortestPathConstants_target) {
             listener.exitShortestPathConstants_target(this);
        }
    }
}


export class ShortestPathConstants_edgesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public shortestPathStringConstant(): ShortestPathStringConstantContext {
        return this.getRuleContext(0, ShortestPathStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_EDGES(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_EDGES, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_shortestPathConstants_edges;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterShortestPathConstants_edges) {
             listener.enterShortestPathConstants_edges(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitShortestPathConstants_edges) {
             listener.exitShortestPathConstants_edges(this);
        }
    }
}


export class ShortestPathConstants_distanceContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public shortestPathStringConstant(): ShortestPathStringConstantContext {
        return this.getRuleContext(0, ShortestPathStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_DISTANCE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DISTANCE, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_shortestPathConstants_distance;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterShortestPathConstants_distance) {
             listener.enterShortestPathConstants_distance(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitShortestPathConstants_distance) {
             listener.exitShortestPathConstants_distance(this);
        }
    }
}


export class ShortestPathConstants_maxDistanceContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public shortestPathStringConstant(): ShortestPathStringConstantContext {
        return this.getRuleContext(0, ShortestPathStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_MAXDISTANCE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MAXDISTANCE, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_shortestPathConstants_maxDistance;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterShortestPathConstants_maxDistance) {
             listener.enterShortestPathConstants_maxDistance(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitShortestPathConstants_maxDistance) {
             listener.exitShortestPathConstants_maxDistance(this);
        }
    }
}


export class ShortestPathConstants_includeEdgesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public shortestPathStringConstant(): ShortestPathStringConstantContext {
        return this.getRuleContext(0, ShortestPathStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_INCLUDEEDGES(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_INCLUDEEDGES, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_shortestPathConstants_includeEdges;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterShortestPathConstants_includeEdges) {
             listener.enterShortestPathConstants_includeEdges(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitShortestPathConstants_includeEdges) {
             listener.exitShortestPathConstants_includeEdges(this);
        }
    }
}


export class WithOptionsConstants_tokensContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public withOptionsStringConstant(): WithOptionsStringConstantContext {
        return this.getRuleContext(0, WithOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_TOKENS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_TOKENS, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_withOptionsConstants_tokens;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterWithOptionsConstants_tokens) {
             listener.enterWithOptionsConstants_tokens(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitWithOptionsConstants_tokens) {
             listener.exitWithOptionsConstants_tokens(this);
        }
    }
}


export class WithOptionsConstants_noneContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public withOptionsStringConstant(): WithOptionsStringConstantContext {
        return this.getRuleContext(0, WithOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_NONE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_NONE, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_withOptionsConstants_none;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterWithOptionsConstants_none) {
             listener.enterWithOptionsConstants_none(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitWithOptionsConstants_none) {
             listener.exitWithOptionsConstants_none(this);
        }
    }
}


export class WithOptionsConstants_idsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public withOptionsStringConstant(): WithOptionsStringConstantContext {
        return this.getRuleContext(0, WithOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_IDS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_IDS, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_withOptionsConstants_ids;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterWithOptionsConstants_ids) {
             listener.enterWithOptionsConstants_ids(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitWithOptionsConstants_ids) {
             listener.exitWithOptionsConstants_ids(this);
        }
    }
}


export class WithOptionsConstants_labelsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public withOptionsStringConstant(): WithOptionsStringConstantContext {
        return this.getRuleContext(0, WithOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_LABELS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_LABELS, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_withOptionsConstants_labels;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterWithOptionsConstants_labels) {
             listener.enterWithOptionsConstants_labels(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitWithOptionsConstants_labels) {
             listener.exitWithOptionsConstants_labels(this);
        }
    }
}


export class WithOptionsConstants_keysContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public withOptionsStringConstant(): WithOptionsStringConstantContext {
        return this.getRuleContext(0, WithOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_KEYS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_KEYS, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_withOptionsConstants_keys;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterWithOptionsConstants_keys) {
             listener.enterWithOptionsConstants_keys(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitWithOptionsConstants_keys) {
             listener.exitWithOptionsConstants_keys(this);
        }
    }
}


export class WithOptionsConstants_valuesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public withOptionsStringConstant(): WithOptionsStringConstantContext {
        return this.getRuleContext(0, WithOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_VALUES(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_VALUES, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_withOptionsConstants_values;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterWithOptionsConstants_values) {
             listener.enterWithOptionsConstants_values(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitWithOptionsConstants_values) {
             listener.exitWithOptionsConstants_values(this);
        }
    }
}


export class WithOptionsConstants_allContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public withOptionsStringConstant(): WithOptionsStringConstantContext {
        return this.getRuleContext(0, WithOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_ALL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_ALL, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_withOptionsConstants_all;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterWithOptionsConstants_all) {
             listener.enterWithOptionsConstants_all(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitWithOptionsConstants_all) {
             listener.exitWithOptionsConstants_all(this);
        }
    }
}


export class WithOptionsConstants_indexerContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public withOptionsStringConstant(): WithOptionsStringConstantContext {
        return this.getRuleContext(0, WithOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_INDEXER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_INDEXER, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_withOptionsConstants_indexer;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterWithOptionsConstants_indexer) {
             listener.enterWithOptionsConstants_indexer(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitWithOptionsConstants_indexer) {
             listener.exitWithOptionsConstants_indexer(this);
        }
    }
}


export class WithOptionsConstants_listContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public withOptionsStringConstant(): WithOptionsStringConstantContext {
        return this.getRuleContext(0, WithOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_LIST(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_LIST, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_withOptionsConstants_list;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterWithOptionsConstants_list) {
             listener.enterWithOptionsConstants_list(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitWithOptionsConstants_list) {
             listener.exitWithOptionsConstants_list(this);
        }
    }
}


export class WithOptionsConstants_mapContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public withOptionsStringConstant(): WithOptionsStringConstantContext {
        return this.getRuleContext(0, WithOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_MAP(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_MAP, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_withOptionsConstants_map;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterWithOptionsConstants_map) {
             listener.enterWithOptionsConstants_map(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitWithOptionsConstants_map) {
             listener.exitWithOptionsConstants_map(this);
        }
    }
}


export class IoOptionsConstants_readerContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public ioOptionsStringConstant(): IoOptionsStringConstantContext {
        return this.getRuleContext(0, IoOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_READER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_READER, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_ioOptionsConstants_reader;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterIoOptionsConstants_reader) {
             listener.enterIoOptionsConstants_reader(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitIoOptionsConstants_reader) {
             listener.exitIoOptionsConstants_reader(this);
        }
    }
}


export class IoOptionsConstants_writerContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public ioOptionsStringConstant(): IoOptionsStringConstantContext {
        return this.getRuleContext(0, IoOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_WRITER(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WRITER, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_ioOptionsConstants_writer;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterIoOptionsConstants_writer) {
             listener.enterIoOptionsConstants_writer(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitIoOptionsConstants_writer) {
             listener.exitIoOptionsConstants_writer(this);
        }
    }
}


export class IoOptionsConstants_gryoContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public ioOptionsStringConstant(): IoOptionsStringConstantContext {
        return this.getRuleContext(0, IoOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_GRYO(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_GRYO, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_ioOptionsConstants_gryo;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterIoOptionsConstants_gryo) {
             listener.enterIoOptionsConstants_gryo(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitIoOptionsConstants_gryo) {
             listener.exitIoOptionsConstants_gryo(this);
        }
    }
}


export class IoOptionsConstants_graphsonContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public ioOptionsStringConstant(): IoOptionsStringConstantContext {
        return this.getRuleContext(0, IoOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_GRAPHSON(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_GRAPHSON, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_ioOptionsConstants_graphson;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterIoOptionsConstants_graphson) {
             listener.enterIoOptionsConstants_graphson(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitIoOptionsConstants_graphson) {
             listener.exitIoOptionsConstants_graphson(this);
        }
    }
}


export class IoOptionsConstants_graphmlContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public ioOptionsStringConstant(): IoOptionsStringConstantContext {
        return this.getRuleContext(0, IoOptionsStringConstantContext)!;
    }
    public DOT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.DOT, 0)!;
    }
    public K_GRAPHML(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_GRAPHML, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_ioOptionsConstants_graphml;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterIoOptionsConstants_graphml) {
             listener.enterIoOptionsConstants_graphml(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitIoOptionsConstants_graphml) {
             listener.exitIoOptionsConstants_graphml(this);
        }
    }
}


export class ConnectedComponentStringConstantContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_CONNECTEDCOMPONENTU(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_CONNECTEDCOMPONENTU, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_connectedComponentStringConstant;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterConnectedComponentStringConstant) {
             listener.enterConnectedComponentStringConstant(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitConnectedComponentStringConstant) {
             listener.exitConnectedComponentStringConstant(this);
        }
    }
}


export class PageRankStringConstantContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_PAGERANKU(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PAGERANKU, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_pageRankStringConstant;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterPageRankStringConstant) {
             listener.enterPageRankStringConstant(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitPageRankStringConstant) {
             listener.exitPageRankStringConstant(this);
        }
    }
}


export class PeerPressureStringConstantContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_PEERPRESSUREU(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PEERPRESSUREU, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_peerPressureStringConstant;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterPeerPressureStringConstant) {
             listener.enterPeerPressureStringConstant(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitPeerPressureStringConstant) {
             listener.exitPeerPressureStringConstant(this);
        }
    }
}


export class ShortestPathStringConstantContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_SHORTESTPATHU(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_SHORTESTPATHU, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_shortestPathStringConstant;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterShortestPathStringConstant) {
             listener.enterShortestPathStringConstant(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitShortestPathStringConstant) {
             listener.exitShortestPathStringConstant(this);
        }
    }
}


export class WithOptionsStringConstantContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_WITHOPTOPTIONS(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_WITHOPTOPTIONS, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_withOptionsStringConstant;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterWithOptionsStringConstant) {
             listener.enterWithOptionsStringConstant(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitWithOptionsStringConstant) {
             listener.exitWithOptionsStringConstant(this);
        }
    }
}


export class IoOptionsStringConstantContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_IOU(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_IOU, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_ioOptionsStringConstant;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterIoOptionsStringConstant) {
             listener.enterIoOptionsStringConstant(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitIoOptionsStringConstant) {
             listener.exitIoOptionsStringConstant(this);
        }
    }
}


export class BooleanArgumentContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public booleanLiteral(): BooleanLiteralContext | null {
        return this.getRuleContext(0, BooleanLiteralContext);
    }
    public variable(): VariableContext | null {
        return this.getRuleContext(0, VariableContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_booleanArgument;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterBooleanArgument) {
             listener.enterBooleanArgument(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitBooleanArgument) {
             listener.exitBooleanArgument(this);
        }
    }
}


export class IntegerArgumentContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public integerLiteral(): IntegerLiteralContext | null {
        return this.getRuleContext(0, IntegerLiteralContext);
    }
    public variable(): VariableContext | null {
        return this.getRuleContext(0, VariableContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_integerArgument;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterIntegerArgument) {
             listener.enterIntegerArgument(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitIntegerArgument) {
             listener.exitIntegerArgument(this);
        }
    }
}


export class StringArgumentContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public stringLiteral(): StringLiteralContext | null {
        return this.getRuleContext(0, StringLiteralContext);
    }
    public variable(): VariableContext | null {
        return this.getRuleContext(0, VariableContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_stringArgument;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterStringArgument) {
             listener.enterStringArgument(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitStringArgument) {
             listener.exitStringArgument(this);
        }
    }
}


export class StringArgumentVarargsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public stringArgument(): StringArgumentContext[];
    public stringArgument(i: number): StringArgumentContext | null;
    public stringArgument(i?: number): StringArgumentContext[] | StringArgumentContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringArgumentContext);
        }

        return this.getRuleContext(i, StringArgumentContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_stringArgumentVarargs;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterStringArgumentVarargs) {
             listener.enterStringArgumentVarargs(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitStringArgumentVarargs) {
             listener.exitStringArgumentVarargs(this);
        }
    }
}


export class StringNullableArgumentContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public stringNullableLiteral(): StringNullableLiteralContext | null {
        return this.getRuleContext(0, StringNullableLiteralContext);
    }
    public variable(): VariableContext | null {
        return this.getRuleContext(0, VariableContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_stringNullableArgument;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterStringNullableArgument) {
             listener.enterStringNullableArgument(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitStringNullableArgument) {
             listener.exitStringNullableArgument(this);
        }
    }
}


export class StringNullableArgumentVarargsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public stringNullableArgument(): StringNullableArgumentContext[];
    public stringNullableArgument(i: number): StringNullableArgumentContext | null;
    public stringNullableArgument(i?: number): StringNullableArgumentContext[] | StringNullableArgumentContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringNullableArgumentContext);
        }

        return this.getRuleContext(i, StringNullableArgumentContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_stringNullableArgumentVarargs;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterStringNullableArgumentVarargs) {
             listener.enterStringNullableArgumentVarargs(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitStringNullableArgumentVarargs) {
             listener.exitStringNullableArgumentVarargs(this);
        }
    }
}


export class DateArgumentContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public dateLiteral(): DateLiteralContext | null {
        return this.getRuleContext(0, DateLiteralContext);
    }
    public variable(): VariableContext | null {
        return this.getRuleContext(0, VariableContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_dateArgument;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterDateArgument) {
             listener.enterDateArgument(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitDateArgument) {
             listener.exitDateArgument(this);
        }
    }
}


export class GenericArgumentContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public genericLiteral(): GenericLiteralContext | null {
        return this.getRuleContext(0, GenericLiteralContext);
    }
    public variable(): VariableContext | null {
        return this.getRuleContext(0, VariableContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_genericArgument;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterGenericArgument) {
             listener.enterGenericArgument(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitGenericArgument) {
             listener.exitGenericArgument(this);
        }
    }
}


export class GenericArgumentVarargsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public genericArgument(): GenericArgumentContext[];
    public genericArgument(i: number): GenericArgumentContext | null;
    public genericArgument(i?: number): GenericArgumentContext[] | GenericArgumentContext | null {
        if (i === undefined) {
            return this.getRuleContexts(GenericArgumentContext);
        }

        return this.getRuleContext(i, GenericArgumentContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_genericArgumentVarargs;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterGenericArgumentVarargs) {
             listener.enterGenericArgumentVarargs(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitGenericArgumentVarargs) {
             listener.exitGenericArgumentVarargs(this);
        }
    }
}


export class GenericMapArgumentContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public genericMapLiteral(): GenericMapLiteralContext | null {
        return this.getRuleContext(0, GenericMapLiteralContext);
    }
    public variable(): VariableContext | null {
        return this.getRuleContext(0, VariableContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_genericMapArgument;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterGenericMapArgument) {
             listener.enterGenericMapArgument(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitGenericMapArgument) {
             listener.exitGenericMapArgument(this);
        }
    }
}


export class GenericMapNullableArgumentContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public genericMapNullableLiteral(): GenericMapNullableLiteralContext | null {
        return this.getRuleContext(0, GenericMapNullableLiteralContext);
    }
    public variable(): VariableContext | null {
        return this.getRuleContext(0, VariableContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_genericMapNullableArgument;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterGenericMapNullableArgument) {
             listener.enterGenericMapNullableArgument(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitGenericMapNullableArgument) {
             listener.exitGenericMapNullableArgument(this);
        }
    }
}


export class NullableGenericLiteralMapContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public genericMapLiteral(): GenericMapLiteralContext | null {
        return this.getRuleContext(0, GenericMapLiteralContext);
    }
    public nullLiteral(): NullLiteralContext | null {
        return this.getRuleContext(0, NullLiteralContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_nullableGenericLiteralMap;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterNullableGenericLiteralMap) {
             listener.enterNullableGenericLiteralMap(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitNullableGenericLiteralMap) {
             listener.exitNullableGenericLiteralMap(this);
        }
    }
}


export class TraversalStrategyVarargsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalStrategyExpr(): TraversalStrategyExprContext | null {
        return this.getRuleContext(0, TraversalStrategyExprContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalStrategyVarargs;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalStrategyVarargs) {
             listener.enterTraversalStrategyVarargs(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalStrategyVarargs) {
             listener.exitTraversalStrategyVarargs(this);
        }
    }
}


export class TraversalStrategyExprContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public traversalStrategy(): TraversalStrategyContext[];
    public traversalStrategy(i: number): TraversalStrategyContext | null;
    public traversalStrategy(i?: number): TraversalStrategyContext[] | TraversalStrategyContext | null {
        if (i === undefined) {
            return this.getRuleContexts(TraversalStrategyContext);
        }

        return this.getRuleContext(i, TraversalStrategyContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_traversalStrategyExpr;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterTraversalStrategyExpr) {
             listener.enterTraversalStrategyExpr(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitTraversalStrategyExpr) {
             listener.exitTraversalStrategyExpr(this);
        }
    }
}


export class ClassTypeListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public classTypeExpr(): ClassTypeExprContext | null {
        return this.getRuleContext(0, ClassTypeExprContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_classTypeList;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterClassTypeList) {
             listener.enterClassTypeList(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitClassTypeList) {
             listener.exitClassTypeList(this);
        }
    }
}


export class ClassTypeExprContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public classType(): ClassTypeContext[];
    public classType(i: number): ClassTypeContext | null;
    public classType(i?: number): ClassTypeContext[] | ClassTypeContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ClassTypeContext);
        }

        return this.getRuleContext(i, ClassTypeContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_classTypeExpr;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterClassTypeExpr) {
             listener.enterClassTypeExpr(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitClassTypeExpr) {
             listener.exitClassTypeExpr(this);
        }
    }
}


export class NestedTraversalListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public nestedTraversalExpr(): NestedTraversalExprContext | null {
        return this.getRuleContext(0, NestedTraversalExprContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_nestedTraversalList;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterNestedTraversalList) {
             listener.enterNestedTraversalList(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitNestedTraversalList) {
             listener.exitNestedTraversalList(this);
        }
    }
}


export class NestedTraversalExprContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public nestedTraversal(): NestedTraversalContext[];
    public nestedTraversal(i: number): NestedTraversalContext | null;
    public nestedTraversal(i?: number): NestedTraversalContext[] | NestedTraversalContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NestedTraversalContext);
        }

        return this.getRuleContext(i, NestedTraversalContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_nestedTraversalExpr;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterNestedTraversalExpr) {
             listener.enterNestedTraversalExpr(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitNestedTraversalExpr) {
             listener.exitNestedTraversalExpr(this);
        }
    }
}


export class GenericCollectionLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LBRACK(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LBRACK, 0)!;
    }
    public RBRACK(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RBRACK, 0)!;
    }
    public genericLiteral(): GenericLiteralContext[];
    public genericLiteral(i: number): GenericLiteralContext | null;
    public genericLiteral(i?: number): GenericLiteralContext[] | GenericLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(GenericLiteralContext);
        }

        return this.getRuleContext(i, GenericLiteralContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_genericCollectionLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterGenericCollectionLiteral) {
             listener.enterGenericCollectionLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitGenericCollectionLiteral) {
             listener.exitGenericCollectionLiteral(this);
        }
    }
}


export class GenericLiteralVarargsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public genericLiteralExpr(): GenericLiteralExprContext | null {
        return this.getRuleContext(0, GenericLiteralExprContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_genericLiteralVarargs;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterGenericLiteralVarargs) {
             listener.enterGenericLiteralVarargs(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitGenericLiteralVarargs) {
             listener.exitGenericLiteralVarargs(this);
        }
    }
}


export class GenericLiteralExprContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public genericLiteral(): GenericLiteralContext[];
    public genericLiteral(i: number): GenericLiteralContext | null;
    public genericLiteral(i?: number): GenericLiteralContext[] | GenericLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(GenericLiteralContext);
        }

        return this.getRuleContext(i, GenericLiteralContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_genericLiteralExpr;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterGenericLiteralExpr) {
             listener.enterGenericLiteralExpr(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitGenericLiteralExpr) {
             listener.exitGenericLiteralExpr(this);
        }
    }
}


export class GenericMapNullableLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public genericMapLiteral(): GenericMapLiteralContext | null {
        return this.getRuleContext(0, GenericMapLiteralContext);
    }
    public nullLiteral(): NullLiteralContext | null {
        return this.getRuleContext(0, NullLiteralContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_genericMapNullableLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterGenericMapNullableLiteral) {
             listener.enterGenericMapNullableLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitGenericMapNullableLiteral) {
             listener.exitGenericMapNullableLiteral(this);
        }
    }
}


export class GenericRangeLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public integerLiteral(): IntegerLiteralContext[];
    public integerLiteral(i: number): IntegerLiteralContext | null;
    public integerLiteral(i?: number): IntegerLiteralContext[] | IntegerLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IntegerLiteralContext);
        }

        return this.getRuleContext(i, IntegerLiteralContext);
    }
    public DOT(): antlr.TerminalNode[];
    public DOT(i: number): antlr.TerminalNode | null;
    public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.DOT);
    	} else {
    		return this.getToken(GremlinParser.DOT, i);
    	}
    }
    public stringLiteral(): StringLiteralContext[];
    public stringLiteral(i: number): StringLiteralContext | null;
    public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLiteralContext);
        }

        return this.getRuleContext(i, StringLiteralContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_genericRangeLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterGenericRangeLiteral) {
             listener.enterGenericRangeLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitGenericRangeLiteral) {
             listener.exitGenericRangeLiteral(this);
        }
    }
}


export class GenericSetLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LBRACE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LBRACE, 0)!;
    }
    public RBRACE(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RBRACE, 0)!;
    }
    public genericLiteral(): GenericLiteralContext[];
    public genericLiteral(i: number): GenericLiteralContext | null;
    public genericLiteral(i?: number): GenericLiteralContext[] | GenericLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(GenericLiteralContext);
        }

        return this.getRuleContext(i, GenericLiteralContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_genericSetLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterGenericSetLiteral) {
             listener.enterGenericSetLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitGenericSetLiteral) {
             listener.exitGenericSetLiteral(this);
        }
    }
}


export class StringNullableLiteralVarargsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public stringNullableLiteral(): StringNullableLiteralContext[];
    public stringNullableLiteral(i: number): StringNullableLiteralContext | null;
    public stringNullableLiteral(i?: number): StringNullableLiteralContext[] | StringNullableLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringNullableLiteralContext);
        }

        return this.getRuleContext(i, StringNullableLiteralContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_stringNullableLiteralVarargs;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterStringNullableLiteralVarargs) {
             listener.enterStringNullableLiteralVarargs(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitStringNullableLiteralVarargs) {
             listener.exitStringNullableLiteralVarargs(this);
        }
    }
}


export class StringLiteralVarargsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public stringLiteral(): StringLiteralContext[];
    public stringLiteral(i: number): StringLiteralContext | null;
    public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLiteralContext);
        }

        return this.getRuleContext(i, StringLiteralContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_stringLiteralVarargs;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterStringLiteralVarargs) {
             listener.enterStringLiteralVarargs(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitStringLiteralVarargs) {
             listener.exitStringLiteralVarargs(this);
        }
    }
}


export class GenericLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public numericLiteral(): NumericLiteralContext | null {
        return this.getRuleContext(0, NumericLiteralContext);
    }
    public booleanLiteral(): BooleanLiteralContext | null {
        return this.getRuleContext(0, BooleanLiteralContext);
    }
    public stringLiteral(): StringLiteralContext | null {
        return this.getRuleContext(0, StringLiteralContext);
    }
    public dateLiteral(): DateLiteralContext | null {
        return this.getRuleContext(0, DateLiteralContext);
    }
    public nullLiteral(): NullLiteralContext | null {
        return this.getRuleContext(0, NullLiteralContext);
    }
    public traversalT(): TraversalTContext | null {
        return this.getRuleContext(0, TraversalTContext);
    }
    public traversalCardinality(): TraversalCardinalityContext | null {
        return this.getRuleContext(0, TraversalCardinalityContext);
    }
    public traversalDirection(): TraversalDirectionContext | null {
        return this.getRuleContext(0, TraversalDirectionContext);
    }
    public traversalMerge(): TraversalMergeContext | null {
        return this.getRuleContext(0, TraversalMergeContext);
    }
    public traversalPick(): TraversalPickContext | null {
        return this.getRuleContext(0, TraversalPickContext);
    }
    public traversalDT(): TraversalDTContext | null {
        return this.getRuleContext(0, TraversalDTContext);
    }
    public traversalGType(): TraversalGTypeContext | null {
        return this.getRuleContext(0, TraversalGTypeContext);
    }
    public genericSetLiteral(): GenericSetLiteralContext | null {
        return this.getRuleContext(0, GenericSetLiteralContext);
    }
    public genericCollectionLiteral(): GenericCollectionLiteralContext | null {
        return this.getRuleContext(0, GenericCollectionLiteralContext);
    }
    public genericRangeLiteral(): GenericRangeLiteralContext | null {
        return this.getRuleContext(0, GenericRangeLiteralContext);
    }
    public nestedTraversal(): NestedTraversalContext | null {
        return this.getRuleContext(0, NestedTraversalContext);
    }
    public terminatedTraversal(): TerminatedTraversalContext | null {
        return this.getRuleContext(0, TerminatedTraversalContext);
    }
    public uuidLiteral(): UuidLiteralContext | null {
        return this.getRuleContext(0, UuidLiteralContext);
    }
    public characterLiteral(): CharacterLiteralContext | null {
        return this.getRuleContext(0, CharacterLiteralContext);
    }
    public durationLiteral(): DurationLiteralContext | null {
        return this.getRuleContext(0, DurationLiteralContext);
    }
    public binaryLiteral(): BinaryLiteralContext | null {
        return this.getRuleContext(0, BinaryLiteralContext);
    }
    public pdtLiteral(): PdtLiteralContext | null {
        return this.getRuleContext(0, PdtLiteralContext);
    }
    public genericMapLiteral(): GenericMapLiteralContext | null {
        return this.getRuleContext(0, GenericMapLiteralContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_genericLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterGenericLiteral) {
             listener.enterGenericLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitGenericLiteral) {
             listener.exitGenericLiteral(this);
        }
    }
}


export class GenericMapLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LBRACK(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LBRACK, 0)!;
    }
    public COLON(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.COLON, 0);
    }
    public RBRACK(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RBRACK, 0)!;
    }
    public mapEntry(): MapEntryContext[];
    public mapEntry(i: number): MapEntryContext | null;
    public mapEntry(i?: number): MapEntryContext[] | MapEntryContext | null {
        if (i === undefined) {
            return this.getRuleContexts(MapEntryContext);
        }

        return this.getRuleContext(i, MapEntryContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_genericMapLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterGenericMapLiteral) {
             listener.enterGenericMapLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitGenericMapLiteral) {
             listener.exitGenericMapLiteral(this);
        }
    }
}


export class MapKeyContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LPAREN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.LPAREN, 0);
    }
    public traversalT(): TraversalTContext | null {
        return this.getRuleContext(0, TraversalTContext);
    }
    public RPAREN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.RPAREN, 0);
    }
    public traversalTLong(): TraversalTLongContext | null {
        return this.getRuleContext(0, TraversalTLongContext);
    }
    public traversalDirection(): TraversalDirectionContext | null {
        return this.getRuleContext(0, TraversalDirectionContext);
    }
    public traversalDirectionLong(): TraversalDirectionLongContext | null {
        return this.getRuleContext(0, TraversalDirectionLongContext);
    }
    public genericSetLiteral(): GenericSetLiteralContext | null {
        return this.getRuleContext(0, GenericSetLiteralContext);
    }
    public genericCollectionLiteral(): GenericCollectionLiteralContext | null {
        return this.getRuleContext(0, GenericCollectionLiteralContext);
    }
    public genericMapLiteral(): GenericMapLiteralContext | null {
        return this.getRuleContext(0, GenericMapLiteralContext);
    }
    public stringLiteral(): StringLiteralContext | null {
        return this.getRuleContext(0, StringLiteralContext);
    }
    public numericLiteral(): NumericLiteralContext | null {
        return this.getRuleContext(0, NumericLiteralContext);
    }
    public keyword(): KeywordContext | null {
        return this.getRuleContext(0, KeywordContext);
    }
    public nakedKey(): NakedKeyContext | null {
        return this.getRuleContext(0, NakedKeyContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_mapKey;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterMapKey) {
             listener.enterMapKey(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitMapKey) {
             listener.exitMapKey(this);
        }
    }
}


export class MapEntryContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public mapKey(): MapKeyContext {
        return this.getRuleContext(0, MapKeyContext)!;
    }
    public COLON(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COLON, 0)!;
    }
    public genericLiteral(): GenericLiteralContext {
        return this.getRuleContext(0, GenericLiteralContext)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_mapEntry;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterMapEntry) {
             listener.enterMapEntry(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitMapEntry) {
             listener.exitMapEntry(this);
        }
    }
}


export class StringLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public EmptyStringLiteral(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.EmptyStringLiteral, 0);
    }
    public NonEmptyStringLiteral(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.NonEmptyStringLiteral, 0);
    }
    public EmptyStringSuffixLiteral(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.EmptyStringSuffixLiteral, 0);
    }
    public StringSuffixLiteral(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.StringSuffixLiteral, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_stringLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterStringLiteral) {
             listener.enterStringLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitStringLiteral) {
             listener.exitStringLiteral(this);
        }
    }
}


export class StringNullableLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public stringLiteral(): StringLiteralContext | null {
        return this.getRuleContext(0, StringLiteralContext);
    }
    public K_NULL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NULL, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_stringNullableLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterStringNullableLiteral) {
             listener.enterStringNullableLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitStringNullableLiteral) {
             listener.exitStringNullableLiteral(this);
        }
    }
}


export class IntegerLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public IntegerLiteral(): antlr.TerminalNode {
        return this.getToken(GremlinParser.IntegerLiteral, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_integerLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterIntegerLiteral) {
             listener.enterIntegerLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitIntegerLiteral) {
             listener.exitIntegerLiteral(this);
        }
    }
}


export class FloatLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public FloatingPointLiteral(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.FloatingPointLiteral, 0);
    }
    public infLiteral(): InfLiteralContext | null {
        return this.getRuleContext(0, InfLiteralContext);
    }
    public nanLiteral(): NanLiteralContext | null {
        return this.getRuleContext(0, NanLiteralContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_floatLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterFloatLiteral) {
             listener.enterFloatLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitFloatLiteral) {
             listener.exitFloatLiteral(this);
        }
    }
}


export class NumericLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public integerLiteral(): IntegerLiteralContext | null {
        return this.getRuleContext(0, IntegerLiteralContext);
    }
    public floatLiteral(): FloatLiteralContext | null {
        return this.getRuleContext(0, FloatLiteralContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_numericLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterNumericLiteral) {
             listener.enterNumericLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitNumericLiteral) {
             listener.exitNumericLiteral(this);
        }
    }
}


export class BooleanLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_TRUE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TRUE, 0);
    }
    public K_FALSE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FALSE, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_booleanLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterBooleanLiteral) {
             listener.enterBooleanLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitBooleanLiteral) {
             listener.exitBooleanLiteral(this);
        }
    }
}


export class DateLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_DATETIME(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DATETIME, 0);
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext | null {
        return this.getRuleContext(0, StringLiteralContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public K_DATETIMEC(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DATETIMEC, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_dateLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterDateLiteral) {
             listener.enterDateLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitDateLiteral) {
             listener.exitDateLiteral(this);
        }
    }
}


export class NullLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_NULL(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_NULL, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_nullLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterNullLiteral) {
             listener.enterNullLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitNullLiteral) {
             listener.exitNullLiteral(this);
        }
    }
}


export class NanLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_NAN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_NAN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_nanLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterNanLiteral) {
             listener.enterNanLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitNanLiteral) {
             listener.exitNanLiteral(this);
        }
    }
}


export class InfLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_INFINITY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INFINITY, 0);
    }
    public SignedInfLiteral(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.SignedInfLiteral, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_infLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterInfLiteral) {
             listener.enterInfLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitInfLiteral) {
             listener.exitInfLiteral(this);
        }
    }
}


export class UuidLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_UUID(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_UUID, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext | null {
        return this.getRuleContext(0, StringLiteralContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_uuidLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterUuidLiteral) {
             listener.enterUuidLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitUuidLiteral) {
             listener.exitUuidLiteral(this);
        }
    }
}


export class CharacterLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public CharacterLiteral(): antlr.TerminalNode {
        return this.getToken(GremlinParser.CharacterLiteral, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_characterLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterCharacterLiteral) {
             listener.enterCharacterLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitCharacterLiteral) {
             listener.exitCharacterLiteral(this);
        }
    }
}


export class DurationLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_DURATIONC(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_DURATIONC, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public integerLiteral(): IntegerLiteralContext[];
    public integerLiteral(i: number): IntegerLiteralContext | null;
    public integerLiteral(i?: number): IntegerLiteralContext[] | IntegerLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IntegerLiteralContext);
        }

        return this.getRuleContext(i, IntegerLiteralContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(GremlinParser.COMMA);
    	} else {
    		return this.getToken(GremlinParser.COMMA, i);
    	}
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public booleanLiteral(): BooleanLiteralContext | null {
        return this.getRuleContext(0, BooleanLiteralContext);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_durationLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterDurationLiteral) {
             listener.enterDurationLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitDurationLiteral) {
             listener.exitDurationLiteral(this);
        }
    }
}


export class BinaryLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_BINARYC(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_BINARYC, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext {
        return this.getRuleContext(0, StringLiteralContext)!;
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_binaryLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterBinaryLiteral) {
             listener.enterBinaryLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitBinaryLiteral) {
             listener.exitBinaryLiteral(this);
        }
    }
}


export class PdtLiteralContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public K_PDT(): antlr.TerminalNode {
        return this.getToken(GremlinParser.K_PDT, 0)!;
    }
    public LPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.LPAREN, 0)!;
    }
    public stringLiteral(): StringLiteralContext[];
    public stringLiteral(i: number): StringLiteralContext | null;
    public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLiteralContext);
        }

        return this.getRuleContext(i, StringLiteralContext);
    }
    public COMMA(): antlr.TerminalNode {
        return this.getToken(GremlinParser.COMMA, 0)!;
    }
    public genericMapLiteral(): GenericMapLiteralContext | null {
        return this.getRuleContext(0, GenericMapLiteralContext);
    }
    public RPAREN(): antlr.TerminalNode {
        return this.getToken(GremlinParser.RPAREN, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_pdtLiteral;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterPdtLiteral) {
             listener.enterPdtLiteral(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitPdtLiteral) {
             listener.exitPdtLiteral(this);
        }
    }
}


export class NakedKeyContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public Identifier(): antlr.TerminalNode {
        return this.getToken(GremlinParser.Identifier, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_nakedKey;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterNakedKey) {
             listener.enterNakedKey(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitNakedKey) {
             listener.exitNakedKey(this);
        }
    }
}


export class ClassTypeContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public Identifier(): antlr.TerminalNode {
        return this.getToken(GremlinParser.Identifier, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_classType;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterClassType) {
             listener.enterClassType(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitClassType) {
             listener.exitClassType(this);
        }
    }
}


export class VariableContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public Identifier(): antlr.TerminalNode {
        return this.getToken(GremlinParser.Identifier, 0)!;
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_variable;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterVariable) {
             listener.enterVariable(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitVariable) {
             listener.exitVariable(this);
        }
    }
}


export class KeywordContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public TRAVERSAL_ROOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.TRAVERSAL_ROOT, 0);
    }
    public K_ADDALL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ADDALL, 0);
    }
    public K_ADDE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ADDE, 0);
    }
    public K_ADDLABEL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ADDLABEL, 0);
    }
    public K_ADDV(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ADDV, 0);
    }
    public K_AGGREGATE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_AGGREGATE, 0);
    }
    public K_ALL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ALL, 0);
    }
    public K_AND(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_AND, 0);
    }
    public K_ANY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ANY, 0);
    }
    public K_AS(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_AS, 0);
    }
    public K_ASBOOL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ASBOOL, 0);
    }
    public K_ASC(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ASC, 0);
    }
    public K_ASDATE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ASDATE, 0);
    }
    public K_ASNUMBER(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ASNUMBER, 0);
    }
    public K_ASSTRING(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ASSTRING, 0);
    }
    public K_ASSIGN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ASSIGN, 0);
    }
    public K_BARRIER(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BARRIER, 0);
    }
    public K_BARRIERU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BARRIERU, 0);
    }
    public K_BEGIN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BEGIN, 0);
    }
    public K_BETWEEN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BETWEEN, 0);
    }
    public K_BIGDECIMAL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BIGDECIMAL, 0);
    }
    public K_BIGDECIMALU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BIGDECIMALU, 0);
    }
    public K_BIGINT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BIGINT, 0);
    }
    public K_BIGINTU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BIGINTU, 0);
    }
    public K_BINARY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BINARY, 0);
    }
    public K_BINARYC(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BINARYC, 0);
    }
    public K_BINARYU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BINARYU, 0);
    }
    public K_BOTH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BOTH, 0);
    }
    public K_BOTHU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BOTHU, 0);
    }
    public K_BOTHE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BOTHE, 0);
    }
    public K_BOTHV(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BOTHV, 0);
    }
    public K_BRANCH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BRANCH, 0);
    }
    public K_BY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BY, 0);
    }
    public K_BYTE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BYTE, 0);
    }
    public K_BYTEU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BYTEU, 0);
    }
    public K_BOOLEAN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BOOLEAN, 0);
    }
    public K_BOOLEANU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_BOOLEANU, 0);
    }
    public K_CALL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CALL, 0);
    }
    public K_CAP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CAP, 0);
    }
    public K_CARDINALITY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CARDINALITY, 0);
    }
    public K_CHAR(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CHAR, 0);
    }
    public K_CHARU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CHARU, 0);
    }
    public K_CHOOSE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CHOOSE, 0);
    }
    public K_COALESCE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_COALESCE, 0);
    }
    public K_COIN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_COIN, 0);
    }
    public K_COLUMN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_COLUMN, 0);
    }
    public K_COMBINE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_COMBINE, 0);
    }
    public K_CONCAT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CONCAT, 0);
    }
    public K_COMMIT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_COMMIT, 0);
    }
    public K_COMPONENT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_COMPONENT, 0);
    }
    public K_CONJOIN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CONJOIN, 0);
    }
    public K_CONNECTEDCOMPONENT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CONNECTEDCOMPONENT, 0);
    }
    public K_CONNECTEDCOMPONENTU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CONNECTEDCOMPONENTU, 0);
    }
    public K_CONSTANT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CONSTANT, 0);
    }
    public K_CONTAINING(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CONTAINING, 0);
    }
    public K_COUNT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_COUNT, 0);
    }
    public K_CYCLICPATH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_CYCLICPATH, 0);
    }
    public K_DAY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DAY, 0);
    }
    public K_DATEADD(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DATEADD, 0);
    }
    public K_DATEDIFF(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DATEDIFF, 0);
    }
    public K_DATETIME(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DATETIME, 0);
    }
    public K_DATETIMEC(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DATETIMEC, 0);
    }
    public K_DATETIMEU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DATETIMEU, 0);
    }
    public K_DECR(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DECR, 0);
    }
    public K_DEDUP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DEDUP, 0);
    }
    public K_DESC(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DESC, 0);
    }
    public K_DIFFERENCE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DIFFERENCE, 0);
    }
    public K_DIRECTION(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DIRECTION, 0);
    }
    public K_DISCARD(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DISCARD, 0);
    }
    public K_DISJUNCT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DISJUNCT, 0);
    }
    public K_DISTANCE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DISTANCE, 0);
    }
    public K_DIV(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DIV, 0);
    }
    public K_DOUBLE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DOUBLE, 0);
    }
    public K_DOUBLEU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DOUBLEU, 0);
    }
    public K_DROP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DROP, 0);
    }
    public K_DROPLABEL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DROPLABEL, 0);
    }
    public K_DROPLABELS(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DROPLABELS, 0);
    }
    public K_DT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DT, 0);
    }
    public K_DURATION(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DURATION, 0);
    }
    public K_DURATIONC(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DURATIONC, 0);
    }
    public K_DURATIONU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_DURATIONU, 0);
    }
    public K_E(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_E, 0);
    }
    public K_EDGE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_EDGE, 0);
    }
    public K_EDGEU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_EDGEU, 0);
    }
    public K_EDGES(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_EDGES, 0);
    }
    public K_ELEMENTMAP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ELEMENTMAP, 0);
    }
    public K_ELEMENT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ELEMENT, 0);
    }
    public K_EMIT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_EMIT, 0);
    }
    public K_ENDINGWITH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ENDINGWITH, 0);
    }
    public K_EQ(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_EQ, 0);
    }
    public K_EXPLAIN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_EXPLAIN, 0);
    }
    public K_FAIL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FAIL, 0);
    }
    public K_FALSE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FALSE, 0);
    }
    public K_FILTER(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FILTER, 0);
    }
    public K_FIRST(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FIRST, 0);
    }
    public K_FLATMAP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FLATMAP, 0);
    }
    public K_FLOAT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FLOAT, 0);
    }
    public K_FLOATU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FLOATU, 0);
    }
    public K_FOLD(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FOLD, 0);
    }
    public K_FORMAT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FORMAT, 0);
    }
    public K_FROM(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_FROM, 0);
    }
    public K_GLOBAL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GLOBAL, 0);
    }
    public K_GT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GT, 0);
    }
    public K_GTE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GTE, 0);
    }
    public K_GRAPH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GRAPH, 0);
    }
    public K_GRAPHU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GRAPHU, 0);
    }
    public K_GRAPHML(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GRAPHML, 0);
    }
    public K_GRAPHSON(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GRAPHSON, 0);
    }
    public K_GROUP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GROUP, 0);
    }
    public K_GROUPCOUNT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GROUPCOUNT, 0);
    }
    public K_GRYO(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GRYO, 0);
    }
    public K_GTYPE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_GTYPE, 0);
    }
    public K_HAS(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_HAS, 0);
    }
    public K_HASID(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_HASID, 0);
    }
    public K_HASKEY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_HASKEY, 0);
    }
    public K_HASLABEL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_HASLABEL, 0);
    }
    public K_HASNEXT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_HASNEXT, 0);
    }
    public K_HASNOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_HASNOT, 0);
    }
    public K_HASVALUE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_HASVALUE, 0);
    }
    public K_HOUR(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_HOUR, 0);
    }
    public K_ID(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ID, 0);
    }
    public K_IDENTITY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_IDENTITY, 0);
    }
    public K_IDS(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_IDS, 0);
    }
    public K_IN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_IN, 0);
    }
    public K_INU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INU, 0);
    }
    public K_INCLUDEEDGES(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INCLUDEEDGES, 0);
    }
    public K_INCR(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INCR, 0);
    }
    public K_INDEXER(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INDEXER, 0);
    }
    public K_INE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INE, 0);
    }
    public K_INDEX(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INDEX, 0);
    }
    public K_INFINITY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INFINITY, 0);
    }
    public K_INJECT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INJECT, 0);
    }
    public K_INSIDE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INSIDE, 0);
    }
    public K_INT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INT, 0);
    }
    public K_INTU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INTU, 0);
    }
    public K_INTERSECT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INTERSECT, 0);
    }
    public K_INV(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_INV, 0);
    }
    public K_IO(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_IO, 0);
    }
    public K_IOU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_IOU, 0);
    }
    public K_IS(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_IS, 0);
    }
    public K_ITERATE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ITERATE, 0);
    }
    public K_KEY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_KEY, 0);
    }
    public K_KEYS(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_KEYS, 0);
    }
    public K_LABELS(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LABELS, 0);
    }
    public K_LABEL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LABEL, 0);
    }
    public K_LAST(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LAST, 0);
    }
    public K_LENGTH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LENGTH, 0);
    }
    public K_LIMIT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LIMIT, 0);
    }
    public K_LIST(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LIST, 0);
    }
    public K_LISTU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LISTU, 0);
    }
    public K_LOCAL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LOCAL, 0);
    }
    public K_LONG(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LONG, 0);
    }
    public K_LONGU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LONGU, 0);
    }
    public K_LOOPS(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LOOPS, 0);
    }
    public K_LT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LT, 0);
    }
    public K_LTE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LTE, 0);
    }
    public K_LTRIM(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_LTRIM, 0);
    }
    public K_MAP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MAP, 0);
    }
    public K_MAPU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MAPU, 0);
    }
    public K_MATCH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MATCH, 0);
    }
    public K_MATH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MATH, 0);
    }
    public K_MAX(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MAX, 0);
    }
    public K_MAXDISTANCE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MAXDISTANCE, 0);
    }
    public K_MEAN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MEAN, 0);
    }
    public K_MERGE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MERGE, 0);
    }
    public K_MERGEU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MERGEU, 0);
    }
    public K_MERGEE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MERGEE, 0);
    }
    public K_MERGEV(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MERGEV, 0);
    }
    public K_MIN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MIN, 0);
    }
    public K_MINUTE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MINUTE, 0);
    }
    public K_MINUS(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MINUS, 0);
    }
    public K_MIXED(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MIXED, 0);
    }
    public K_MULT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_MULT, 0);
    }
    public K_N(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_N, 0);
    }
    public K_NAN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NAN, 0);
    }
    public K_NEGATE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NEGATE, 0);
    }
    public K_NEW(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NEW, 0);
    }
    public K_NONE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NONE, 0);
    }
    public K_NOTCONTAINING(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NOTCONTAINING, 0);
    }
    public K_NOTENDINGWITH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NOTENDINGWITH, 0);
    }
    public K_NOTREGEX(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NOTREGEX, 0);
    }
    public K_NOTSTARTINGWITH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NOTSTARTINGWITH, 0);
    }
    public K_NOT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NOT, 0);
    }
    public K_NEQ(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NEQ, 0);
    }
    public K_NEXT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NEXT, 0);
    }
    public K_NULL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NULL, 0);
    }
    public K_NULLU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NULLU, 0);
    }
    public K_NUMBER(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NUMBER, 0);
    }
    public K_NUMBERU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NUMBERU, 0);
    }
    public K_NORMSACK(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_NORMSACK, 0);
    }
    public K_ONCREATE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ONCREATE, 0);
    }
    public K_ONMATCH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ONMATCH, 0);
    }
    public K_OPERATOR(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OPERATOR, 0);
    }
    public K_OPTION(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OPTION, 0);
    }
    public K_OPTIONAL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OPTIONAL, 0);
    }
    public K_ORDER(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ORDER, 0);
    }
    public K_ORDERU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ORDERU, 0);
    }
    public K_OR(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OR, 0);
    }
    public K_OTHERV(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OTHERV, 0);
    }
    public K_OUT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OUT, 0);
    }
    public K_OUTU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OUTU, 0);
    }
    public K_OUTE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OUTE, 0);
    }
    public K_OUTSIDE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OUTSIDE, 0);
    }
    public K_OUTV(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_OUTV, 0);
    }
    public K_P(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_P, 0);
    }
    public K_PAGERANK(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PAGERANK, 0);
    }
    public K_PAGERANKU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PAGERANKU, 0);
    }
    public K_PATH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PATH, 0);
    }
    public K_PATHU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PATHU, 0);
    }
    public K_PDT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PDT, 0);
    }
    public K_PEERPRESSURE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PEERPRESSURE, 0);
    }
    public K_PEERPRESSUREU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PEERPRESSUREU, 0);
    }
    public K_PICK(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PICK, 0);
    }
    public K_POP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_POP, 0);
    }
    public K_PROFILE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PROFILE, 0);
    }
    public K_PROJECT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PROJECT, 0);
    }
    public K_PROPERTIES(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PROPERTIES, 0);
    }
    public K_PROPERTYMAP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PROPERTYMAP, 0);
    }
    public K_PROPERTYNAME(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PROPERTYNAME, 0);
    }
    public K_PROPERTY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PROPERTY, 0);
    }
    public K_PROPERTYU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PROPERTYU, 0);
    }
    public K_PRODUCT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_PRODUCT, 0);
    }
    public K_RANGE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_RANGE, 0);
    }
    public K_READ(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_READ, 0);
    }
    public K_READER(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_READER, 0);
    }
    public K_REGEX(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_REGEX, 0);
    }
    public K_REPLACE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_REPLACE, 0);
    }
    public K_REPEAT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_REPEAT, 0);
    }
    public K_REVERSE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_REVERSE, 0);
    }
    public K_ROLLBACK(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_ROLLBACK, 0);
    }
    public K_RTRIM(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_RTRIM, 0);
    }
    public K_SACK(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SACK, 0);
    }
    public K_SAMPLE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SAMPLE, 0);
    }
    public K_SCOPE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SCOPE, 0);
    }
    public K_SECOND(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SECOND, 0);
    }
    public K_SELECT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SELECT, 0);
    }
    public K_SET(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SET, 0);
    }
    public K_SETU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SETU, 0);
    }
    public K_SHORT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SHORT, 0);
    }
    public K_SHORTU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SHORTU, 0);
    }
    public K_SHORTESTPATH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SHORTESTPATH, 0);
    }
    public K_SHORTESTPATHU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SHORTESTPATHU, 0);
    }
    public K_SHUFFLE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SHUFFLE, 0);
    }
    public K_SIDEEFFECT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SIDEEFFECT, 0);
    }
    public K_SIMPLEPATH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SIMPLEPATH, 0);
    }
    public K_SINGLE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SINGLE, 0);
    }
    public K_SKIP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SKIP, 0);
    }
    public K_SPLIT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SPLIT, 0);
    }
    public K_STARTINGWITH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_STARTINGWITH, 0);
    }
    public K_STRING(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_STRING, 0);
    }
    public K_STRINGU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_STRINGU, 0);
    }
    public K_SUBGRAPH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SUBGRAPH, 0);
    }
    public K_SUBSTRING(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SUBSTRING, 0);
    }
    public K_SUM(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SUM, 0);
    }
    public K_SUMLONG(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_SUMLONG, 0);
    }
    public K_T(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_T, 0);
    }
    public K_TAIL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TAIL, 0);
    }
    public K_TARGET(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TARGET, 0);
    }
    public K_TEXTP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TEXTP, 0);
    }
    public K_TIMELIMIT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TIMELIMIT, 0);
    }
    public K_TIMES(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TIMES, 0);
    }
    public K_TO(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TO, 0);
    }
    public K_TOBULKSET(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TOBULKSET, 0);
    }
    public K_TOKENS(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TOKENS, 0);
    }
    public K_TOLIST(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TOLIST, 0);
    }
    public K_TOLOWER(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TOLOWER, 0);
    }
    public K_TOSET(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TOSET, 0);
    }
    public K_TOSTRING(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TOSTRING, 0);
    }
    public K_TOUPPER(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TOUPPER, 0);
    }
    public K_TOE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TOE, 0);
    }
    public K_TOV(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TOV, 0);
    }
    public K_TREE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TREE, 0);
    }
    public K_TREEU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TREEU, 0);
    }
    public K_TRIM(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TRIM, 0);
    }
    public K_TRUE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TRUE, 0);
    }
    public K_TRYNEXT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TRYNEXT, 0);
    }
    public K_TYPEOF(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TYPEOF, 0);
    }
    public K_TX(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_TX, 0);
    }
    public K_UNFOLD(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_UNFOLD, 0);
    }
    public K_UNION(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_UNION, 0);
    }
    public K_UNPRODUCTIVE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_UNPRODUCTIVE, 0);
    }
    public K_UNTIL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_UNTIL, 0);
    }
    public K_UUID(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_UUID, 0);
    }
    public K_UUIDL(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_UUIDL, 0);
    }
    public K_V(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_V, 0);
    }
    public K_VALUEMAP(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_VALUEMAP, 0);
    }
    public K_VALUES(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_VALUES, 0);
    }
    public K_VALUE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_VALUE, 0);
    }
    public K_VERTEX(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_VERTEX, 0);
    }
    public K_VERTEXU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_VERTEXU, 0);
    }
    public K_VPROPERTY(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_VPROPERTY, 0);
    }
    public K_VPROPERTYU(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_VPROPERTYU, 0);
    }
    public K_WHERE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WHERE, 0);
    }
    public K_WITH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WITH, 0);
    }
    public K_WITHBULK(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WITHBULK, 0);
    }
    public K_WITHIN(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WITHIN, 0);
    }
    public K_WITHOPTOPTIONS(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WITHOPTOPTIONS, 0);
    }
    public K_WITHOUT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WITHOUT, 0);
    }
    public K_WITHOUTSTRATEGIES(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WITHOUTSTRATEGIES, 0);
    }
    public K_WITHPATH(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WITHPATH, 0);
    }
    public K_WITHSACK(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WITHSACK, 0);
    }
    public K_WITHSIDEEFFECT(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WITHSIDEEFFECT, 0);
    }
    public K_WITHSTRATEGIES(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WITHSTRATEGIES, 0);
    }
    public K_WRITE(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WRITE, 0);
    }
    public K_WRITER(): antlr.TerminalNode | null {
        return this.getToken(GremlinParser.K_WRITER, 0);
    }
    public override get ruleIndex(): number {
        return GremlinParser.RULE_keyword;
    }
    public override enterRule(listener: GremlinListener): void {
        if(listener.enterKeyword) {
             listener.enterKeyword(this);
        }
    }
    public override exitRule(listener: GremlinListener): void {
        if(listener.exitKeyword) {
             listener.exitKeyword(this);
        }
    }
}
