# Generated from GraphQL.g4 by ANTLR 4.9
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3C")
        buf.write("\u02a8\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\3\2\6\2\u0092\n\2\r\2\16\2\u0093")
        buf.write("\3\3\3\3\3\3\5\3\u0099\n\3\3\4\3\4\5\4\u009d\n\4\3\5\3")
        buf.write("\5\5\5\u00a1\n\5\3\5\5\5\u00a4\n\5\3\5\5\5\u00a7\n\5\3")
        buf.write("\5\3\5\3\5\5\5\u00ac\n\5\3\6\3\6\3\7\3\7\6\7\u00b2\n\7")
        buf.write("\r\7\16\7\u00b3\3\7\3\7\3\b\3\b\3\b\5\b\u00bb\n\b\3\t")
        buf.write("\5\t\u00be\n\t\3\t\3\t\5\t\u00c2\n\t\3\t\5\t\u00c5\n\t")
        buf.write("\3\t\5\t\u00c8\n\t\3\n\3\n\6\n\u00cc\n\n\r\n\16\n\u00cd")
        buf.write("\3\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\r\3\r\3\r\5")
        buf.write("\r\u00dc\n\r\3\16\3\16\3\16\3\16\5\16\u00e2\n\16\3\16")
        buf.write("\3\16\3\17\3\17\3\20\3\20\3\20\3\21\3\21\5\21\u00ed\n")
        buf.write("\21\3\21\5\21\u00f0\n\21\3\21\3\21\3\22\3\22\3\22\3\22")
        buf.write("\3\22\3\22\3\22\3\22\3\22\5\22\u00fd\n\22\3\23\3\23\3")
        buf.write("\24\3\24\3\25\3\25\3\26\3\26\3\27\3\27\3\30\3\30\3\31")
        buf.write("\3\31\3\31\3\31\6\31\u010f\n\31\r\31\16\31\u0110\3\31")
        buf.write("\3\31\5\31\u0115\n\31\3\32\3\32\7\32\u0119\n\32\f\32\16")
        buf.write("\32\u011c\13\32\3\32\3\32\3\33\3\33\3\33\3\33\3\34\3\34")
        buf.write("\3\34\3\35\3\35\6\35\u0129\n\35\r\35\16\35\u012a\3\35")
        buf.write("\3\35\3\36\3\36\3\36\3\36\5\36\u0133\n\36\3\37\3\37\3")
        buf.write("\37\3 \3 \5 \u013a\n \3 \3 \5 \u013e\n \5 \u0140\n \3")
        buf.write("!\3!\3\"\3\"\3\"\3\"\3#\6#\u0149\n#\r#\16#\u014a\3$\3")
        buf.write("$\3$\5$\u0150\n$\3%\3%\3%\5%\u0155\n%\3&\3&\5&\u0159\n")
        buf.write("&\3\'\3\'\5\'\u015d\n\'\3\'\3\'\6\'\u0161\n\'\r\'\16\'")
        buf.write("\u0162\3\'\3\'\3(\3(\3(\3(\3)\3)\3)\5)\u016e\n)\3)\3)")
        buf.write("\6)\u0172\n)\r)\16)\u0173\3)\3)\3)\3)\3)\5)\u017b\n)\3")
        buf.write("*\3*\3*\3*\3+\3+\3,\3,\3,\3,\3,\3,\5,\u0189\n,\3-\3-\3")
        buf.write("-\3-\3-\3-\5-\u0191\n-\3.\5.\u0194\n.\3.\3.\3.\5.\u0199")
        buf.write("\n.\3/\3/\3/\3/\3/\3\60\5\60\u01a1\n\60\3\60\3\60\3\60")
        buf.write("\5\60\u01a6\n\60\3\60\5\60\u01a9\n\60\3\60\5\60\u01ac")
        buf.write("\n\60\3\61\3\61\3\61\5\61\u01b1\n\61\3\61\3\61\3\61\3")
        buf.write("\61\3\61\7\61\u01b8\n\61\f\61\16\61\u01bb\13\61\3\62\3")
        buf.write("\62\6\62\u01bf\n\62\r\62\16\62\u01c0\3\62\3\62\3\63\5")
        buf.write("\63\u01c6\n\63\3\63\3\63\5\63\u01ca\n\63\3\63\3\63\3\63")
        buf.write("\5\63\u01cf\n\63\3\64\3\64\6\64\u01d3\n\64\r\64\16\64")
        buf.write("\u01d4\3\64\3\64\3\65\5\65\u01da\n\65\3\65\3\65\3\65\3")
        buf.write("\65\5\65\u01e0\n\65\3\65\5\65\u01e3\n\65\3\66\3\66\3\66")
        buf.write("\3\66\5\66\u01e9\n\66\3\66\5\66\u01ec\n\66\3\66\3\66\3")
        buf.write("\66\3\66\3\66\3\66\5\66\u01f4\n\66\3\66\3\66\3\66\3\66")
        buf.write("\3\66\3\66\3\66\5\66\u01fd\n\66\3\67\5\67\u0200\n\67\3")
        buf.write("\67\3\67\3\67\5\67\u0205\n\67\3\67\5\67\u0208\n\67\38")
        buf.write("\38\38\38\58\u020e\n8\38\38\38\38\38\38\38\58\u0217\n")
        buf.write("8\39\59\u021a\n9\39\39\39\59\u021f\n9\39\59\u0222\n9\3")
        buf.write(":\3:\5:\u0226\n:\3:\3:\3:\7:\u022b\n:\f:\16:\u022e\13")
        buf.write(":\3;\3;\3;\3;\5;\u0234\n;\3;\3;\3;\3;\3;\3;\3;\5;\u023d")
        buf.write("\n;\3<\5<\u0240\n<\3<\3<\3<\5<\u0245\n<\3<\5<\u0248\n")
        buf.write("<\3=\3=\6=\u024c\n=\r=\16=\u024d\3=\3=\3>\5>\u0253\n>")
        buf.write("\3>\3>\5>\u0257\n>\3?\3?\3?\3?\5?\u025d\n?\3?\3?\3?\3")
        buf.write("?\3?\3?\3?\5?\u0266\n?\3@\5@\u0269\n@\3@\3@\3@\5@\u026e")
        buf.write("\n@\3@\5@\u0271\n@\3A\3A\6A\u0275\nA\rA\16A\u0276\3A\3")
        buf.write("A\3B\3B\3B\3B\5B\u027f\nB\3B\3B\3B\3B\3B\3B\3B\5B\u0288")
        buf.write("\nB\3C\5C\u028b\nC\3C\3C\3C\3C\5C\u0291\nC\3C\3C\3C\3")
        buf.write("D\3D\3D\7D\u0299\nD\fD\16D\u029c\13D\3E\3E\5E\u02a0\n")
        buf.write("E\3F\3F\3G\3G\3H\3H\3H\2\3`I\2\4\6\b\n\f\16\20\22\24\26")
        buf.write("\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\")
        buf.write("^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a")
        buf.write("\u008c\u008e\2\7\3\2\3\5\3\2\16\17\3\2\678\3\2$*\3\2+")
        buf.write("\65\2\u02cb\2\u0091\3\2\2\2\4\u0098\3\2\2\2\6\u009c\3")
        buf.write("\2\2\2\b\u00ab\3\2\2\2\n\u00ad\3\2\2\2\f\u00af\3\2\2\2")
        buf.write("\16\u00ba\3\2\2\2\20\u00bd\3\2\2\2\22\u00c9\3\2\2\2\24")
        buf.write("\u00d1\3\2\2\2\26\u00d5\3\2\2\2\30\u00d8\3\2\2\2\32\u00dd")
        buf.write("\3\2\2\2\34\u00e5\3\2\2\2\36\u00e7\3\2\2\2 \u00ea\3\2")
        buf.write("\2\2\"\u00fc\3\2\2\2$\u00fe\3\2\2\2&\u0100\3\2\2\2(\u0102")
        buf.write("\3\2\2\2*\u0104\3\2\2\2,\u0106\3\2\2\2.\u0108\3\2\2\2")
        buf.write("\60\u0114\3\2\2\2\62\u0116\3\2\2\2\64\u011f\3\2\2\2\66")
        buf.write("\u0123\3\2\2\28\u0126\3\2\2\2:\u012e\3\2\2\2<\u0134\3")
        buf.write("\2\2\2>\u013f\3\2\2\2@\u0141\3\2\2\2B\u0143\3\2\2\2D\u0148")
        buf.write("\3\2\2\2F\u014c\3\2\2\2H\u0154\3\2\2\2J\u0158\3\2\2\2")
        buf.write("L\u015a\3\2\2\2N\u0166\3\2\2\2P\u017a\3\2\2\2R\u017c\3")
        buf.write("\2\2\2T\u0180\3\2\2\2V\u0188\3\2\2\2X\u0190\3\2\2\2Z\u0193")
        buf.write("\3\2\2\2\\\u019a\3\2\2\2^\u01a0\3\2\2\2`\u01ad\3\2\2\2")
        buf.write("b\u01bc\3\2\2\2d\u01c5\3\2\2\2f\u01d0\3\2\2\2h\u01d9\3")
        buf.write("\2\2\2j\u01fc\3\2\2\2l\u01ff\3\2\2\2n\u0216\3\2\2\2p\u0219")
        buf.write("\3\2\2\2r\u0223\3\2\2\2t\u023c\3\2\2\2v\u023f\3\2\2\2")
        buf.write("x\u0249\3\2\2\2z\u0252\3\2\2\2|\u0265\3\2\2\2~\u0268\3")
        buf.write("\2\2\2\u0080\u0272\3\2\2\2\u0082\u0287\3\2\2\2\u0084\u028a")
        buf.write("\3\2\2\2\u0086\u0295\3\2\2\2\u0088\u029f\3\2\2\2\u008a")
        buf.write("\u02a1\3\2\2\2\u008c\u02a3\3\2\2\2\u008e\u02a5\3\2\2\2")
        buf.write("\u0090\u0092\5\4\3\2\u0091\u0090\3\2\2\2\u0092\u0093\3")
        buf.write("\2\2\2\u0093\u0091\3\2\2\2\u0093\u0094\3\2\2\2\u0094\3")
        buf.write("\3\2\2\2\u0095\u0099\5\6\4\2\u0096\u0099\5H%\2\u0097\u0099")
        buf.write("\5J&\2\u0098\u0095\3\2\2\2\u0098\u0096\3\2\2\2\u0098\u0097")
        buf.write("\3\2\2\2\u0099\5\3\2\2\2\u009a\u009d\5\b\5\2\u009b\u009d")
        buf.write("\5\32\16\2\u009c\u009a\3\2\2\2\u009c\u009b\3\2\2\2\u009d")
        buf.write("\7\3\2\2\2\u009e\u00a0\5\n\6\2\u009f\u00a1\5\u008eH\2")
        buf.write("\u00a0\u009f\3\2\2\2\u00a0\u00a1\3\2\2\2\u00a1\u00a3\3")
        buf.write("\2\2\2\u00a2\u00a4\58\35\2\u00a3\u00a2\3\2\2\2\u00a3\u00a4")
        buf.write("\3\2\2\2\u00a4\u00a6\3\2\2\2\u00a5\u00a7\5D#\2\u00a6\u00a5")
        buf.write("\3\2\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00a8\3\2\2\2\u00a8")
        buf.write("\u00a9\5\f\7\2\u00a9\u00ac\3\2\2\2\u00aa\u00ac\5\f\7\2")
        buf.write("\u00ab\u009e\3\2\2\2\u00ab\u00aa\3\2\2\2\u00ac\t\3\2\2")
        buf.write("\2\u00ad\u00ae\t\2\2\2\u00ae\13\3\2\2\2\u00af\u00b1\7")
        buf.write("\6\2\2\u00b0\u00b2\5\16\b\2\u00b1\u00b0\3\2\2\2\u00b2")
        buf.write("\u00b3\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b3\u00b4\3\2\2\2")
        buf.write("\u00b4\u00b5\3\2\2\2\u00b5\u00b6\7\7\2\2\u00b6\r\3\2\2")
        buf.write("\2\u00b7\u00bb\5\20\t\2\u00b8\u00bb\5\30\r\2\u00b9\u00bb")
        buf.write("\5 \21\2\u00ba\u00b7\3\2\2\2\u00ba\u00b8\3\2\2\2\u00ba")
        buf.write("\u00b9\3\2\2\2\u00bb\17\3\2\2\2\u00bc\u00be\5\26\f\2\u00bd")
        buf.write("\u00bc\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00bf\3\2\2\2")
        buf.write("\u00bf\u00c1\5\u008eH\2\u00c0\u00c2\5\22\n\2\u00c1\u00c0")
        buf.write("\3\2\2\2\u00c1\u00c2\3\2\2\2\u00c2\u00c4\3\2\2\2\u00c3")
        buf.write("\u00c5\5D#\2\u00c4\u00c3\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5")
        buf.write("\u00c7\3\2\2\2\u00c6\u00c8\5\f\7\2\u00c7\u00c6\3\2\2\2")
        buf.write("\u00c7\u00c8\3\2\2\2\u00c8\21\3\2\2\2\u00c9\u00cb\7\b")
        buf.write("\2\2\u00ca\u00cc\5\24\13\2\u00cb\u00ca\3\2\2\2\u00cc\u00cd")
        buf.write("\3\2\2\2\u00cd\u00cb\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce")
        buf.write("\u00cf\3\2\2\2\u00cf\u00d0\7\t\2\2\u00d0\23\3\2\2\2\u00d1")
        buf.write("\u00d2\5\u008eH\2\u00d2\u00d3\7\n\2\2\u00d3\u00d4\5\"")
        buf.write("\22\2\u00d4\25\3\2\2\2\u00d5\u00d6\5\u008eH\2\u00d6\u00d7")
        buf.write("\7\n\2\2\u00d7\27\3\2\2\2\u00d8\u00d9\7\13\2\2\u00d9\u00db")
        buf.write("\5\34\17\2\u00da\u00dc\5D#\2\u00db\u00da\3\2\2\2\u00db")
        buf.write("\u00dc\3\2\2\2\u00dc\31\3\2\2\2\u00dd\u00de\7\f\2\2\u00de")
        buf.write("\u00df\5\34\17\2\u00df\u00e1\5\36\20\2\u00e0\u00e2\5D")
        buf.write("#\2\u00e1\u00e0\3\2\2\2\u00e1\u00e2\3\2\2\2\u00e2\u00e3")
        buf.write("\3\2\2\2\u00e3\u00e4\5\f\7\2\u00e4\33\3\2\2\2\u00e5\u00e6")
        buf.write("\5\u008eH\2\u00e6\35\3\2\2\2\u00e7\u00e8\7\r\2\2\u00e8")
        buf.write("\u00e9\5@!\2\u00e9\37\3\2\2\2\u00ea\u00ec\7\13\2\2\u00eb")
        buf.write("\u00ed\5\36\20\2\u00ec\u00eb\3\2\2\2\u00ec\u00ed\3\2\2")
        buf.write("\2\u00ed\u00ef\3\2\2\2\u00ee\u00f0\5D#\2\u00ef\u00ee\3")
        buf.write("\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f2")
        buf.write("\5\f\7\2\u00f2!\3\2\2\2\u00f3\u00fd\5\66\34\2\u00f4\u00fd")
        buf.write("\5$\23\2\u00f5\u00fd\5&\24\2\u00f6\u00fd\5*\26\2\u00f7")
        buf.write("\u00fd\5(\25\2\u00f8\u00fd\5,\27\2\u00f9\u00fd\5.\30\2")
        buf.write("\u00fa\u00fd\5\60\31\2\u00fb\u00fd\5\62\32\2\u00fc\u00f3")
        buf.write("\3\2\2\2\u00fc\u00f4\3\2\2\2\u00fc\u00f5\3\2\2\2\u00fc")
        buf.write("\u00f6\3\2\2\2\u00fc\u00f7\3\2\2\2\u00fc\u00f8\3\2\2\2")
        buf.write("\u00fc\u00f9\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fc\u00fb\3")
        buf.write("\2\2\2\u00fd#\3\2\2\2\u00fe\u00ff\7;\2\2\u00ff%\3\2\2")
        buf.write("\2\u0100\u0101\7:\2\2\u0101\'\3\2\2\2\u0102\u0103\t\3")
        buf.write("\2\2\u0103)\3\2\2\2\u0104\u0105\t\4\2\2\u0105+\3\2\2\2")
        buf.write("\u0106\u0107\7\20\2\2\u0107-\3\2\2\2\u0108\u0109\5\u008e")
        buf.write("H\2\u0109/\3\2\2\2\u010a\u010b\7\21\2\2\u010b\u0115\7")
        buf.write("\22\2\2\u010c\u010e\7\21\2\2\u010d\u010f\5\"\22\2\u010e")
        buf.write("\u010d\3\2\2\2\u010f\u0110\3\2\2\2\u0110\u010e\3\2\2\2")
        buf.write("\u0110\u0111\3\2\2\2\u0111\u0112\3\2\2\2\u0112\u0113\7")
        buf.write("\22\2\2\u0113\u0115\3\2\2\2\u0114\u010a\3\2\2\2\u0114")
        buf.write("\u010c\3\2\2\2\u0115\61\3\2\2\2\u0116\u011a\7\6\2\2\u0117")
        buf.write("\u0119\5\64\33\2\u0118\u0117\3\2\2\2\u0119\u011c\3\2\2")
        buf.write("\2\u011a\u0118\3\2\2\2\u011a\u011b\3\2\2\2\u011b\u011d")
        buf.write("\3\2\2\2\u011c\u011a\3\2\2\2\u011d\u011e\7\7\2\2\u011e")
        buf.write("\63\3\2\2\2\u011f\u0120\5\u008eH\2\u0120\u0121\7\n\2\2")
        buf.write("\u0121\u0122\5\"\22\2\u0122\65\3\2\2\2\u0123\u0124\7\23")
        buf.write("\2\2\u0124\u0125\5\u008eH\2\u0125\67\3\2\2\2\u0126\u0128")
        buf.write("\7\b\2\2\u0127\u0129\5:\36\2\u0128\u0127\3\2\2\2\u0129")
        buf.write("\u012a\3\2\2\2\u012a\u0128\3\2\2\2\u012a\u012b\3\2\2\2")
        buf.write("\u012b\u012c\3\2\2\2\u012c\u012d\7\t\2\2\u012d9\3\2\2")
        buf.write("\2\u012e\u012f\5\66\34\2\u012f\u0130\7\n\2\2\u0130\u0132")
        buf.write("\5> \2\u0131\u0133\5<\37\2\u0132\u0131\3\2\2\2\u0132\u0133")
        buf.write("\3\2\2\2\u0133;\3\2\2\2\u0134\u0135\7\24\2\2\u0135\u0136")
        buf.write("\5\"\22\2\u0136=\3\2\2\2\u0137\u0139\5@!\2\u0138\u013a")
        buf.write("\7\25\2\2\u0139\u0138\3\2\2\2\u0139\u013a\3\2\2\2\u013a")
        buf.write("\u0140\3\2\2\2\u013b\u013d\5B\"\2\u013c\u013e\7\25\2\2")
        buf.write("\u013d\u013c\3\2\2\2\u013d\u013e\3\2\2\2\u013e\u0140\3")
        buf.write("\2\2\2\u013f\u0137\3\2\2\2\u013f\u013b\3\2\2\2\u0140?")
        buf.write("\3\2\2\2\u0141\u0142\5\u008eH\2\u0142A\3\2\2\2\u0143\u0144")
        buf.write("\7\21\2\2\u0144\u0145\5> \2\u0145\u0146\7\22\2\2\u0146")
        buf.write("C\3\2\2\2\u0147\u0149\5F$\2\u0148\u0147\3\2\2\2\u0149")
        buf.write("\u014a\3\2\2\2\u014a\u0148\3\2\2\2\u014a\u014b\3\2\2\2")
        buf.write("\u014bE\3\2\2\2\u014c\u014d\7\26\2\2\u014d\u014f\5\u008e")
        buf.write("H\2\u014e\u0150\5\22\n\2\u014f\u014e\3\2\2\2\u014f\u0150")
        buf.write("\3\2\2\2\u0150G\3\2\2\2\u0151\u0155\5L\'\2\u0152\u0155")
        buf.write("\5V,\2\u0153\u0155\5\u0084C\2\u0154\u0151\3\2\2\2\u0154")
        buf.write("\u0152\3\2\2\2\u0154\u0153\3\2\2\2\u0155I\3\2\2\2\u0156")
        buf.write("\u0159\5P)\2\u0157\u0159\5X-\2\u0158\u0156\3\2\2\2\u0158")
        buf.write("\u0157\3\2\2\2\u0159K\3\2\2\2\u015a\u015c\7\27\2\2\u015b")
        buf.write("\u015d\5D#\2\u015c\u015b\3\2\2\2\u015c\u015d\3\2\2\2\u015d")
        buf.write("\u015e\3\2\2\2\u015e\u0160\7\6\2\2\u015f\u0161\5N(\2\u0160")
        buf.write("\u015f\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0160\3\2\2\2")
        buf.write("\u0162\u0163\3\2\2\2\u0163\u0164\3\2\2\2\u0164\u0165\7")
        buf.write("\7\2\2\u0165M\3\2\2\2\u0166\u0167\5\n\6\2\u0167\u0168")
        buf.write("\7\n\2\2\u0168\u0169\5@!\2\u0169O\3\2\2\2\u016a\u016b")
        buf.write("\7\30\2\2\u016b\u016d\7\27\2\2\u016c\u016e\5D#\2\u016d")
        buf.write("\u016c\3\2\2\2\u016d\u016e\3\2\2\2\u016e\u016f\3\2\2\2")
        buf.write("\u016f\u0171\7\6\2\2\u0170\u0172\5R*\2\u0171\u0170\3\2")
        buf.write("\2\2\u0172\u0173\3\2\2\2\u0173\u0171\3\2\2\2\u0173\u0174")
        buf.write("\3\2\2\2\u0174\u0175\3\2\2\2\u0175\u0176\7\7\2\2\u0176")
        buf.write("\u017b\3\2\2\2\u0177\u0178\7\30\2\2\u0178\u0179\7\27\2")
        buf.write("\2\u0179\u017b\5D#\2\u017a\u016a\3\2\2\2\u017a\u0177\3")
        buf.write("\2\2\2\u017bQ\3\2\2\2\u017c\u017d\5\n\6\2\u017d\u017e")
        buf.write("\7\n\2\2\u017e\u017f\5@!\2\u017fS\3\2\2\2\u0180\u0181")
        buf.write("\5*\26\2\u0181U\3\2\2\2\u0182\u0189\5Z.\2\u0183\u0189")
        buf.write("\5^\60\2\u0184\u0189\5l\67\2\u0185\u0189\5p9\2\u0186\u0189")
        buf.write("\5v<\2\u0187\u0189\5~@\2\u0188\u0182\3\2\2\2\u0188\u0183")
        buf.write("\3\2\2\2\u0188\u0184\3\2\2\2\u0188\u0185\3\2\2\2\u0188")
        buf.write("\u0186\3\2\2\2\u0188\u0187\3\2\2\2\u0189W\3\2\2\2\u018a")
        buf.write("\u0191\5\\/\2\u018b\u0191\5j\66\2\u018c\u0191\5n8\2\u018d")
        buf.write("\u0191\5t;\2\u018e\u0191\5|?\2\u018f\u0191\5\u0082B\2")
        buf.write("\u0190\u018a\3\2\2\2\u0190\u018b\3\2\2\2\u0190\u018c\3")
        buf.write("\2\2\2\u0190\u018d\3\2\2\2\u0190\u018e\3\2\2\2\u0190\u018f")
        buf.write("\3\2\2\2\u0191Y\3\2\2\2\u0192\u0194\5T+\2\u0193\u0192")
        buf.write("\3\2\2\2\u0193\u0194\3\2\2\2\u0194\u0195\3\2\2\2\u0195")
        buf.write("\u0196\7\31\2\2\u0196\u0198\5\u008eH\2\u0197\u0199\5D")
        buf.write("#\2\u0198\u0197\3\2\2\2\u0198\u0199\3\2\2\2\u0199[\3\2")
        buf.write("\2\2\u019a\u019b\7\32\2\2\u019b\u019c\7\31\2\2\u019c\u019d")
        buf.write("\5\u008eH\2\u019d\u019e\5D#\2\u019e]\3\2\2\2\u019f\u01a1")
        buf.write("\5T+\2\u01a0\u019f\3\2\2\2\u01a0\u01a1\3\2\2\2\u01a1\u01a2")
        buf.write("\3\2\2\2\u01a2\u01a3\7\33\2\2\u01a3\u01a5\5\u008eH\2\u01a4")
        buf.write("\u01a6\5`\61\2\u01a5\u01a4\3\2\2\2\u01a5\u01a6\3\2\2\2")
        buf.write("\u01a6\u01a8\3\2\2\2\u01a7\u01a9\5D#\2\u01a8\u01a7\3\2")
        buf.write("\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01ab\3\2\2\2\u01aa\u01ac")
        buf.write("\5b\62\2\u01ab\u01aa\3\2\2\2\u01ab\u01ac\3\2\2\2\u01ac")
        buf.write("_\3\2\2\2\u01ad\u01ae\b\61\1\2\u01ae\u01b0\7\34\2\2\u01af")
        buf.write("\u01b1\7\35\2\2\u01b0\u01af\3\2\2\2\u01b0\u01b1\3\2\2")
        buf.write("\2\u01b1\u01b2\3\2\2\2\u01b2\u01b3\5@!\2\u01b3\u01b9\3")
        buf.write("\2\2\2\u01b4\u01b5\f\3\2\2\u01b5\u01b6\7\35\2\2\u01b6")
        buf.write("\u01b8\5@!\2\u01b7\u01b4\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9")
        buf.write("\u01b7\3\2\2\2\u01b9\u01ba\3\2\2\2\u01baa\3\2\2\2\u01bb")
        buf.write("\u01b9\3\2\2\2\u01bc\u01be\7\6\2\2\u01bd\u01bf\5d\63\2")
        buf.write("\u01be\u01bd\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0\u01be\3")
        buf.write("\2\2\2\u01c0\u01c1\3\2\2\2\u01c1\u01c2\3\2\2\2\u01c2\u01c3")
        buf.write("\7\7\2\2\u01c3c\3\2\2\2\u01c4\u01c6\5T+\2\u01c5\u01c4")
        buf.write("\3\2\2\2\u01c5\u01c6\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7")
        buf.write("\u01c9\5\u008eH\2\u01c8\u01ca\5f\64\2\u01c9\u01c8\3\2")
        buf.write("\2\2\u01c9\u01ca\3\2\2\2\u01ca\u01cb\3\2\2\2\u01cb\u01cc")
        buf.write("\7\n\2\2\u01cc\u01ce\5> \2\u01cd\u01cf\5D#\2\u01ce\u01cd")
        buf.write("\3\2\2\2\u01ce\u01cf\3\2\2\2\u01cfe\3\2\2\2\u01d0\u01d2")
        buf.write("\7\b\2\2\u01d1\u01d3\5h\65\2\u01d2\u01d1\3\2\2\2\u01d3")
        buf.write("\u01d4\3\2\2\2\u01d4\u01d2\3\2\2\2\u01d4\u01d5\3\2\2\2")
        buf.write("\u01d5\u01d6\3\2\2\2\u01d6\u01d7\7\t\2\2\u01d7g\3\2\2")
        buf.write("\2\u01d8\u01da\5T+\2\u01d9\u01d8\3\2\2\2\u01d9\u01da\3")
        buf.write("\2\2\2\u01da\u01db\3\2\2\2\u01db\u01dc\5\u008eH\2\u01dc")
        buf.write("\u01dd\7\n\2\2\u01dd\u01df\5> \2\u01de\u01e0\5<\37\2\u01df")
        buf.write("\u01de\3\2\2\2\u01df\u01e0\3\2\2\2\u01e0\u01e2\3\2\2\2")
        buf.write("\u01e1\u01e3\5D#\2\u01e2\u01e1\3\2\2\2\u01e2\u01e3\3\2")
        buf.write("\2\2\u01e3i\3\2\2\2\u01e4\u01e5\7\30\2\2\u01e5\u01e6\7")
        buf.write("\33\2\2\u01e6\u01e8\5\u008eH\2\u01e7\u01e9\5`\61\2\u01e8")
        buf.write("\u01e7\3\2\2\2\u01e8\u01e9\3\2\2\2\u01e9\u01eb\3\2\2\2")
        buf.write("\u01ea\u01ec\5D#\2\u01eb\u01ea\3\2\2\2\u01eb\u01ec\3\2")
        buf.write("\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ee\5b\62\2\u01ee\u01fd")
        buf.write("\3\2\2\2\u01ef\u01f0\7\30\2\2\u01f0\u01f1\7\33\2\2\u01f1")
        buf.write("\u01f3\5\u008eH\2\u01f2\u01f4\5`\61\2\u01f3\u01f2\3\2")
        buf.write("\2\2\u01f3\u01f4\3\2\2\2\u01f4\u01f5\3\2\2\2\u01f5\u01f6")
        buf.write("\5D#\2\u01f6\u01fd\3\2\2\2\u01f7\u01f8\7\30\2\2\u01f8")
        buf.write("\u01f9\7\33\2\2\u01f9\u01fa\5\u008eH\2\u01fa\u01fb\5`")
        buf.write("\61\2\u01fb\u01fd\3\2\2\2\u01fc\u01e4\3\2\2\2\u01fc\u01ef")
        buf.write("\3\2\2\2\u01fc\u01f7\3\2\2\2\u01fdk\3\2\2\2\u01fe\u0200")
        buf.write("\5T+\2\u01ff\u01fe\3\2\2\2\u01ff\u0200\3\2\2\2\u0200\u0201")
        buf.write("\3\2\2\2\u0201\u0202\7\36\2\2\u0202\u0204\5\u008eH\2\u0203")
        buf.write("\u0205\5D#\2\u0204\u0203\3\2\2\2\u0204\u0205\3\2\2\2\u0205")
        buf.write("\u0207\3\2\2\2\u0206\u0208\5b\62\2\u0207\u0206\3\2\2\2")
        buf.write("\u0207\u0208\3\2\2\2\u0208m\3\2\2\2\u0209\u020a\7\30\2")
        buf.write("\2\u020a\u020b\7\36\2\2\u020b\u020d\5\u008eH\2\u020c\u020e")
        buf.write("\5D#\2\u020d\u020c\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u020f")
        buf.write("\3\2\2\2\u020f\u0210\5b\62\2\u0210\u0217\3\2\2\2\u0211")
        buf.write("\u0212\7\30\2\2\u0212\u0213\7\36\2\2\u0213\u0214\5\u008e")
        buf.write("H\2\u0214\u0215\5D#\2\u0215\u0217\3\2\2\2\u0216\u0209")
        buf.write("\3\2\2\2\u0216\u0211\3\2\2\2\u0217o\3\2\2\2\u0218\u021a")
        buf.write("\5T+\2\u0219\u0218\3\2\2\2\u0219\u021a\3\2\2\2\u021a\u021b")
        buf.write("\3\2\2\2\u021b\u021c\7\37\2\2\u021c\u021e\5\u008eH\2\u021d")
        buf.write("\u021f\5D#\2\u021e\u021d\3\2\2\2\u021e\u021f\3\2\2\2\u021f")
        buf.write("\u0221\3\2\2\2\u0220\u0222\5r:\2\u0221\u0220\3\2\2\2\u0221")
        buf.write("\u0222\3\2\2\2\u0222q\3\2\2\2\u0223\u0225\7\24\2\2\u0224")
        buf.write("\u0226\7 \2\2\u0225\u0224\3\2\2\2\u0225\u0226\3\2\2\2")
        buf.write("\u0226\u0227\3\2\2\2\u0227\u022c\5@!\2\u0228\u0229\7 ")
        buf.write("\2\2\u0229\u022b\5@!\2\u022a\u0228\3\2\2\2\u022b\u022e")
        buf.write("\3\2\2\2\u022c\u022a\3\2\2\2\u022c\u022d\3\2\2\2\u022d")
        buf.write("s\3\2\2\2\u022e\u022c\3\2\2\2\u022f\u0230\7\30\2\2\u0230")
        buf.write("\u0231\7\37\2\2\u0231\u0233\5\u008eH\2\u0232\u0234\5D")
        buf.write("#\2\u0233\u0232\3\2\2\2\u0233\u0234\3\2\2\2\u0234\u0235")
        buf.write("\3\2\2\2\u0235\u0236\5r:\2\u0236\u023d\3\2\2\2\u0237\u0238")
        buf.write("\7\30\2\2\u0238\u0239\7\37\2\2\u0239\u023a\5\u008eH\2")
        buf.write("\u023a\u023b\5D#\2\u023b\u023d\3\2\2\2\u023c\u022f\3\2")
        buf.write("\2\2\u023c\u0237\3\2\2\2\u023du\3\2\2\2\u023e\u0240\5")
        buf.write("T+\2\u023f\u023e\3\2\2\2\u023f\u0240\3\2\2\2\u0240\u0241")
        buf.write("\3\2\2\2\u0241\u0242\7!\2\2\u0242\u0244\5\u008eH\2\u0243")
        buf.write("\u0245\5D#\2\u0244\u0243\3\2\2\2\u0244\u0245\3\2\2\2\u0245")
        buf.write("\u0247\3\2\2\2\u0246\u0248\5x=\2\u0247\u0246\3\2\2\2\u0247")
        buf.write("\u0248\3\2\2\2\u0248w\3\2\2\2\u0249\u024b\7\6\2\2\u024a")
        buf.write("\u024c\5z>\2\u024b\u024a\3\2\2\2\u024c\u024d\3\2\2\2\u024d")
        buf.write("\u024b\3\2\2\2\u024d\u024e\3\2\2\2\u024e\u024f\3\2\2\2")
        buf.write("\u024f\u0250\7\7\2\2\u0250y\3\2\2\2\u0251\u0253\5T+\2")
        buf.write("\u0252\u0251\3\2\2\2\u0252\u0253\3\2\2\2\u0253\u0254\3")
        buf.write("\2\2\2\u0254\u0256\5.\30\2\u0255\u0257\5D#\2\u0256\u0255")
        buf.write("\3\2\2\2\u0256\u0257\3\2\2\2\u0257{\3\2\2\2\u0258\u0259")
        buf.write("\7\30\2\2\u0259\u025a\7!\2\2\u025a\u025c\5\u008eH\2\u025b")
        buf.write("\u025d\5D#\2\u025c\u025b\3\2\2\2\u025c\u025d\3\2\2\2\u025d")
        buf.write("\u025e\3\2\2\2\u025e\u025f\5x=\2\u025f\u0266\3\2\2\2\u0260")
        buf.write("\u0261\7\30\2\2\u0261\u0262\7!\2\2\u0262\u0263\5\u008e")
        buf.write("H\2\u0263\u0264\5D#\2\u0264\u0266\3\2\2\2\u0265\u0258")
        buf.write("\3\2\2\2\u0265\u0260\3\2\2\2\u0266}\3\2\2\2\u0267\u0269")
        buf.write("\5T+\2\u0268\u0267\3\2\2\2\u0268\u0269\3\2\2\2\u0269\u026a")
        buf.write("\3\2\2\2\u026a\u026b\7\"\2\2\u026b\u026d\5\u008eH\2\u026c")
        buf.write("\u026e\5D#\2\u026d\u026c\3\2\2\2\u026d\u026e\3\2\2\2\u026e")
        buf.write("\u0270\3\2\2\2\u026f\u0271\5\u0080A\2\u0270\u026f\3\2")
        buf.write("\2\2\u0270\u0271\3\2\2\2\u0271\177\3\2\2\2\u0272\u0274")
        buf.write("\7\6\2\2\u0273\u0275\5h\65\2\u0274\u0273\3\2\2\2\u0275")
        buf.write("\u0276\3\2\2\2\u0276\u0274\3\2\2\2\u0276\u0277\3\2\2\2")
        buf.write("\u0277\u0278\3\2\2\2\u0278\u0279\7\7\2\2\u0279\u0081\3")
        buf.write("\2\2\2\u027a\u027b\7\30\2\2\u027b\u027c\7\"\2\2\u027c")
        buf.write("\u027e\5\u008eH\2\u027d\u027f\5D#\2\u027e\u027d\3\2\2")
        buf.write("\2\u027e\u027f\3\2\2\2\u027f\u0280\3\2\2\2\u0280\u0281")
        buf.write("\5\u0080A\2\u0281\u0288\3\2\2\2\u0282\u0283\7\30\2\2\u0283")
        buf.write("\u0284\7\"\2\2\u0284\u0285\5\u008eH\2\u0285\u0286\5D#")
        buf.write("\2\u0286\u0288\3\2\2\2\u0287\u027a\3\2\2\2\u0287\u0282")
        buf.write("\3\2\2\2\u0288\u0083\3\2\2\2\u0289\u028b\5T+\2\u028a\u0289")
        buf.write("\3\2\2\2\u028a\u028b\3\2\2\2\u028b\u028c\3\2\2\2\u028c")
        buf.write("\u028d\7#\2\2\u028d\u028e\7\26\2\2\u028e\u0290\5\u008e")
        buf.write("H\2\u028f\u0291\5f\64\2\u0290\u028f\3\2\2\2\u0290\u0291")
        buf.write("\3\2\2\2\u0291\u0292\3\2\2\2\u0292\u0293\7\r\2\2\u0293")
        buf.write("\u0294\5\u0086D\2\u0294\u0085\3\2\2\2\u0295\u029a\5\u0088")
        buf.write("E\2\u0296\u0297\7 \2\2\u0297\u0299\5\u0088E\2\u0298\u0296")
        buf.write("\3\2\2\2\u0299\u029c\3\2\2\2\u029a\u0298\3\2\2\2\u029a")
        buf.write("\u029b\3\2\2\2\u029b\u0087\3\2\2\2\u029c\u029a\3\2\2\2")
        buf.write("\u029d\u02a0\5\u008aF\2\u029e\u02a0\5\u008cG\2\u029f\u029d")
        buf.write("\3\2\2\2\u029f\u029e\3\2\2\2\u02a0\u0089\3\2\2\2\u02a1")
        buf.write("\u02a2\t\5\2\2\u02a2\u008b\3\2\2\2\u02a3\u02a4\t\6\2\2")
        buf.write("\u02a4\u008d\3\2\2\2\u02a5\u02a6\7\66\2\2\u02a6\u008f")
        buf.write("\3\2\2\2Z\u0093\u0098\u009c\u00a0\u00a3\u00a6\u00ab\u00b3")
        buf.write("\u00ba\u00bd\u00c1\u00c4\u00c7\u00cd\u00db\u00e1\u00ec")
        buf.write("\u00ef\u00fc\u0110\u0114\u011a\u012a\u0132\u0139\u013d")
        buf.write("\u013f\u014a\u014f\u0154\u0158\u015c\u0162\u016d\u0173")
        buf.write("\u017a\u0188\u0190\u0193\u0198\u01a0\u01a5\u01a8\u01ab")
        buf.write("\u01b0\u01b9\u01c0\u01c5\u01c9\u01ce\u01d4\u01d9\u01df")
        buf.write("\u01e2\u01e8\u01eb\u01f3\u01fc\u01ff\u0204\u0207\u020d")
        buf.write("\u0216\u0219\u021e\u0221\u0225\u022c\u0233\u023c\u023f")
        buf.write("\u0244\u0247\u024d\u0252\u0256\u025c\u0265\u0268\u026d")
        buf.write("\u0270\u0276\u027e\u0287\u028a\u0290\u029a\u029f")
        return buf.getvalue()


class GraphQLParser ( Parser ):

    grammarFileName = "GraphQL.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'query'", "'mutation'", "'subscription'", 
                     "'{'", "'}'", "'('", "')'", "':'", "'...'", "'fragment'", 
                     "'on'", "'true'", "'false'", "'null'", "'['", "']'", 
                     "'$'", "'='", "'!'", "'@'", "'schema'", "'extend'", 
                     "'scalar'", "'extends'", "'type'", "'implements'", 
                     "'&'", "'interface'", "'union'", "'|'", "'enum'", "'input'", 
                     "'directive'", "'QUERY'", "'MUTATION'", "'SUBSCRIPTION'", 
                     "'FIELD'", "'FRAGMENT_DEFINITION'", "'FRAGMENT_SPREAD'", 
                     "'INLINE_FRAGMENT'", "'SCHEMA'", "'SCALAR'", "'OBJECT'", 
                     "'FIELD_DEFINITION'", "'ARGUMENT_DEFINITION'", "'INTERFACE'", 
                     "'UNION'", "'ENUM'", "'ENUM_VALUE'", "'INPUT_OBJECT'", 
                     "'INPUT_FIELD_DEFINITION'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "','", "<INVALID>", "<INVALID>", 
                     "'\uEFBBBF'", "'\uFEFF'", "'\u0000FEFF'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "NAME", "STRING", "BLOCK_STRING", "ID", "FLOAT", "INT", 
                      "PUNCTUATOR", "WS", "COMMA", "LineComment", "UNICODE_BOM", 
                      "UTF8_BOM", "UTF16_BOM", "UTF32_BOM" ]

    RULE_document = 0
    RULE_definition = 1
    RULE_executableDefinition = 2
    RULE_operationDefinition = 3
    RULE_operationType = 4
    RULE_selectionSet = 5
    RULE_selection = 6
    RULE_field = 7
    RULE_arguments = 8
    RULE_argument = 9
    RULE_alias = 10
    RULE_fragmentSpread = 11
    RULE_fragmentDefinition = 12
    RULE_fragmentName = 13
    RULE_typeCondition = 14
    RULE_inlineFragment = 15
    RULE_value = 16
    RULE_intValue = 17
    RULE_floatValue = 18
    RULE_booleanValue = 19
    RULE_stringValue = 20
    RULE_nullValue = 21
    RULE_enumValue = 22
    RULE_listValue = 23
    RULE_objectValue = 24
    RULE_objectField = 25
    RULE_variable = 26
    RULE_variableDefinitions = 27
    RULE_variableDefinition = 28
    RULE_defaultValue = 29
    RULE_type_ = 30
    RULE_namedType = 31
    RULE_listType = 32
    RULE_directives = 33
    RULE_directive = 34
    RULE_typeSystemDefinition = 35
    RULE_typeSystemExtension = 36
    RULE_schemaDefinition = 37
    RULE_rootOperationTypeDefinition = 38
    RULE_schemaExtension = 39
    RULE_operationTypeDefinition = 40
    RULE_description = 41
    RULE_typeDefinition = 42
    RULE_typeExtension = 43
    RULE_scalarTypeDefinition = 44
    RULE_scalarTypeExtension = 45
    RULE_objectTypeDefinition = 46
    RULE_implementsInterfaces = 47
    RULE_fieldsDefinition = 48
    RULE_fieldDefinition = 49
    RULE_argumentsDefinition = 50
    RULE_inputValueDefinition = 51
    RULE_objectTypeExtension = 52
    RULE_interfaceTypeDefinition = 53
    RULE_interfaceTypeExtension = 54
    RULE_unionTypeDefinition = 55
    RULE_unionMemberTypes = 56
    RULE_unionTypeExtension = 57
    RULE_enumTypeDefinition = 58
    RULE_enumValuesDefinition = 59
    RULE_enumValueDefinition = 60
    RULE_enumTypeExtension = 61
    RULE_inputObjectTypeDefinition = 62
    RULE_inputFieldsDefinition = 63
    RULE_inputObjectTypeExtension = 64
    RULE_directiveDefinition = 65
    RULE_directiveLocations = 66
    RULE_directiveLocation = 67
    RULE_executableDirectiveLocation = 68
    RULE_typeSystemDirectiveLocation = 69
    RULE_name = 70

    ruleNames =  [ "document", "definition", "executableDefinition", "operationDefinition", 
                   "operationType", "selectionSet", "selection", "field", 
                   "arguments", "argument", "alias", "fragmentSpread", "fragmentDefinition", 
                   "fragmentName", "typeCondition", "inlineFragment", "value", 
                   "intValue", "floatValue", "booleanValue", "stringValue", 
                   "nullValue", "enumValue", "listValue", "objectValue", 
                   "objectField", "variable", "variableDefinitions", "variableDefinition", 
                   "defaultValue", "type_", "namedType", "listType", "directives", 
                   "directive", "typeSystemDefinition", "typeSystemExtension", 
                   "schemaDefinition", "rootOperationTypeDefinition", "schemaExtension", 
                   "operationTypeDefinition", "description", "typeDefinition", 
                   "typeExtension", "scalarTypeDefinition", "scalarTypeExtension", 
                   "objectTypeDefinition", "implementsInterfaces", "fieldsDefinition", 
                   "fieldDefinition", "argumentsDefinition", "inputValueDefinition", 
                   "objectTypeExtension", "interfaceTypeDefinition", "interfaceTypeExtension", 
                   "unionTypeDefinition", "unionMemberTypes", "unionTypeExtension", 
                   "enumTypeDefinition", "enumValuesDefinition", "enumValueDefinition", 
                   "enumTypeExtension", "inputObjectTypeDefinition", "inputFieldsDefinition", 
                   "inputObjectTypeExtension", "directiveDefinition", "directiveLocations", 
                   "directiveLocation", "executableDirectiveLocation", "typeSystemDirectiveLocation", 
                   "name" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    T__26=27
    T__27=28
    T__28=29
    T__29=30
    T__30=31
    T__31=32
    T__32=33
    T__33=34
    T__34=35
    T__35=36
    T__36=37
    T__37=38
    T__38=39
    T__39=40
    T__40=41
    T__41=42
    T__42=43
    T__43=44
    T__44=45
    T__45=46
    T__46=47
    T__47=48
    T__48=49
    T__49=50
    T__50=51
    NAME=52
    STRING=53
    BLOCK_STRING=54
    ID=55
    FLOAT=56
    INT=57
    PUNCTUATOR=58
    WS=59
    COMMA=60
    LineComment=61
    UNICODE_BOM=62
    UTF8_BOM=63
    UTF16_BOM=64
    UTF32_BOM=65

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




    class DocumentContext(ParserRuleContext):

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

        def definition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.DefinitionContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.DefinitionContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_document

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

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




    def document(self):

        localctx = GraphQLParser.DocumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_document)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 143 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 142
                self.definition()
                self.state = 145 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphQLParser.T__0) | (1 << GraphQLParser.T__1) | (1 << GraphQLParser.T__2) | (1 << GraphQLParser.T__3) | (1 << GraphQLParser.T__9) | (1 << GraphQLParser.T__20) | (1 << GraphQLParser.T__21) | (1 << GraphQLParser.T__22) | (1 << GraphQLParser.T__23) | (1 << GraphQLParser.T__24) | (1 << GraphQLParser.T__27) | (1 << GraphQLParser.T__28) | (1 << GraphQLParser.T__30) | (1 << GraphQLParser.T__31) | (1 << GraphQLParser.T__32) | (1 << GraphQLParser.STRING) | (1 << GraphQLParser.BLOCK_STRING))) != 0)):
                    break

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


    class DefinitionContext(ParserRuleContext):

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

        def executableDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.ExecutableDefinitionContext,0)


        def typeSystemDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.TypeSystemDefinitionContext,0)


        def typeSystemExtension(self):
            return self.getTypedRuleContext(GraphQLParser.TypeSystemExtensionContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_definition

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

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




    def definition(self):

        localctx = GraphQLParser.DefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_definition)
        try:
            self.state = 150
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [GraphQLParser.T__0, GraphQLParser.T__1, GraphQLParser.T__2, GraphQLParser.T__3, GraphQLParser.T__9]:
                self.enterOuterAlt(localctx, 1)
                self.state = 147
                self.executableDefinition()
                pass
            elif token in [GraphQLParser.T__20, GraphQLParser.T__22, GraphQLParser.T__24, GraphQLParser.T__27, GraphQLParser.T__28, GraphQLParser.T__30, GraphQLParser.T__31, GraphQLParser.T__32, GraphQLParser.STRING, GraphQLParser.BLOCK_STRING]:
                self.enterOuterAlt(localctx, 2)
                self.state = 148
                self.typeSystemDefinition()
                pass
            elif token in [GraphQLParser.T__21, GraphQLParser.T__23]:
                self.enterOuterAlt(localctx, 3)
                self.state = 149
                self.typeSystemExtension()
                pass
            else:
                raise NoViableAltException(self)

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


    class ExecutableDefinitionContext(ParserRuleContext):

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

        def operationDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.OperationDefinitionContext,0)


        def fragmentDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.FragmentDefinitionContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_executableDefinition

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

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




    def executableDefinition(self):

        localctx = GraphQLParser.ExecutableDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_executableDefinition)
        try:
            self.state = 154
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [GraphQLParser.T__0, GraphQLParser.T__1, GraphQLParser.T__2, GraphQLParser.T__3]:
                self.enterOuterAlt(localctx, 1)
                self.state = 152
                self.operationDefinition()
                pass
            elif token in [GraphQLParser.T__9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 153
                self.fragmentDefinition()
                pass
            else:
                raise NoViableAltException(self)

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


    class OperationDefinitionContext(ParserRuleContext):

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

        def operationType(self):
            return self.getTypedRuleContext(GraphQLParser.OperationTypeContext,0)


        def selectionSet(self):
            return self.getTypedRuleContext(GraphQLParser.SelectionSetContext,0)


        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def variableDefinitions(self):
            return self.getTypedRuleContext(GraphQLParser.VariableDefinitionsContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_operationDefinition

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

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




    def operationDefinition(self):

        localctx = GraphQLParser.OperationDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_operationDefinition)
        self._la = 0 # Token type
        try:
            self.state = 169
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [GraphQLParser.T__0, GraphQLParser.T__1, GraphQLParser.T__2]:
                self.enterOuterAlt(localctx, 1)
                self.state = 156
                self.operationType()
                self.state = 158
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphQLParser.NAME:
                    self.state = 157
                    self.name()


                self.state = 161
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphQLParser.T__5:
                    self.state = 160
                    self.variableDefinitions()


                self.state = 164
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphQLParser.T__19:
                    self.state = 163
                    self.directives()


                self.state = 166
                self.selectionSet()
                pass
            elif token in [GraphQLParser.T__3]:
                self.enterOuterAlt(localctx, 2)
                self.state = 168
                self.selectionSet()
                pass
            else:
                raise NoViableAltException(self)

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


    class OperationTypeContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return GraphQLParser.RULE_operationType

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

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




    def operationType(self):

        localctx = GraphQLParser.OperationTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_operationType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 171
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphQLParser.T__0) | (1 << GraphQLParser.T__1) | (1 << GraphQLParser.T__2))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SelectionSetContext(ParserRuleContext):

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.SelectionContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.SelectionContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_selectionSet

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

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




    def selectionSet(self):

        localctx = GraphQLParser.SelectionSetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_selectionSet)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 173
            self.match(GraphQLParser.T__3)
            self.state = 175 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 174
                self.selection()
                self.state = 177 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==GraphQLParser.T__8 or _la==GraphQLParser.NAME):
                    break

            self.state = 179
            self.match(GraphQLParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SelectionContext(ParserRuleContext):

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

        def field(self):
            return self.getTypedRuleContext(GraphQLParser.FieldContext,0)


        def fragmentSpread(self):
            return self.getTypedRuleContext(GraphQLParser.FragmentSpreadContext,0)


        def inlineFragment(self):
            return self.getTypedRuleContext(GraphQLParser.InlineFragmentContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_selection

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

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




    def selection(self):

        localctx = GraphQLParser.SelectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_selection)
        try:
            self.state = 184
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 181
                self.field()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 182
                self.fragmentSpread()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 183
                self.inlineFragment()
                pass


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


    class FieldContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def alias(self):
            return self.getTypedRuleContext(GraphQLParser.AliasContext,0)


        def arguments(self):
            return self.getTypedRuleContext(GraphQLParser.ArgumentsContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def selectionSet(self):
            return self.getTypedRuleContext(GraphQLParser.SelectionSetContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_field

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

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




    def field(self):

        localctx = GraphQLParser.FieldContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_field)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 187
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.state = 186
                self.alias()


            self.state = 189
            self.name()
            self.state = 191
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__5:
                self.state = 190
                self.arguments()


            self.state = 194
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__19:
                self.state = 193
                self.directives()


            self.state = 197
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__3:
                self.state = 196
                self.selectionSet()


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


    class ArgumentsContext(ParserRuleContext):

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

        def argument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.ArgumentContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.ArgumentContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_arguments

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

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




    def arguments(self):

        localctx = GraphQLParser.ArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_arguments)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 199
            self.match(GraphQLParser.T__5)
            self.state = 201 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 200
                self.argument()
                self.state = 203 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==GraphQLParser.NAME):
                    break

            self.state = 205
            self.match(GraphQLParser.T__6)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgumentContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def value(self):
            return self.getTypedRuleContext(GraphQLParser.ValueContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_argument

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

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




    def argument(self):

        localctx = GraphQLParser.ArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_argument)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 207
            self.name()
            self.state = 208
            self.match(GraphQLParser.T__7)
            self.state = 209
            self.value()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AliasContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_alias

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

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




    def alias(self):

        localctx = GraphQLParser.AliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_alias)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 211
            self.name()
            self.state = 212
            self.match(GraphQLParser.T__7)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FragmentSpreadContext(ParserRuleContext):

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

        def fragmentName(self):
            return self.getTypedRuleContext(GraphQLParser.FragmentNameContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_fragmentSpread

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

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




    def fragmentSpread(self):

        localctx = GraphQLParser.FragmentSpreadContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_fragmentSpread)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 214
            self.match(GraphQLParser.T__8)
            self.state = 215
            self.fragmentName()
            self.state = 217
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__19:
                self.state = 216
                self.directives()


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


    class FragmentDefinitionContext(ParserRuleContext):

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

        def fragmentName(self):
            return self.getTypedRuleContext(GraphQLParser.FragmentNameContext,0)


        def typeCondition(self):
            return self.getTypedRuleContext(GraphQLParser.TypeConditionContext,0)


        def selectionSet(self):
            return self.getTypedRuleContext(GraphQLParser.SelectionSetContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_fragmentDefinition

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

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




    def fragmentDefinition(self):

        localctx = GraphQLParser.FragmentDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_fragmentDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 219
            self.match(GraphQLParser.T__9)
            self.state = 220
            self.fragmentName()
            self.state = 221
            self.typeCondition()
            self.state = 223
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__19:
                self.state = 222
                self.directives()


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


    class FragmentNameContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_fragmentName

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

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




    def fragmentName(self):

        localctx = GraphQLParser.FragmentNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_fragmentName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 227
            self.name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeConditionContext(ParserRuleContext):

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

        def namedType(self):
            return self.getTypedRuleContext(GraphQLParser.NamedTypeContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_typeCondition

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

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




    def typeCondition(self):

        localctx = GraphQLParser.TypeConditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_typeCondition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 229
            self.match(GraphQLParser.T__10)
            self.state = 230
            self.namedType()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InlineFragmentContext(ParserRuleContext):

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

        def selectionSet(self):
            return self.getTypedRuleContext(GraphQLParser.SelectionSetContext,0)


        def typeCondition(self):
            return self.getTypedRuleContext(GraphQLParser.TypeConditionContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_inlineFragment

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

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




    def inlineFragment(self):

        localctx = GraphQLParser.InlineFragmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_inlineFragment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 232
            self.match(GraphQLParser.T__8)
            self.state = 234
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__10:
                self.state = 233
                self.typeCondition()


            self.state = 237
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__19:
                self.state = 236
                self.directives()


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


    class ValueContext(ParserRuleContext):

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

        def variable(self):
            return self.getTypedRuleContext(GraphQLParser.VariableContext,0)


        def intValue(self):
            return self.getTypedRuleContext(GraphQLParser.IntValueContext,0)


        def floatValue(self):
            return self.getTypedRuleContext(GraphQLParser.FloatValueContext,0)


        def stringValue(self):
            return self.getTypedRuleContext(GraphQLParser.StringValueContext,0)


        def booleanValue(self):
            return self.getTypedRuleContext(GraphQLParser.BooleanValueContext,0)


        def nullValue(self):
            return self.getTypedRuleContext(GraphQLParser.NullValueContext,0)


        def enumValue(self):
            return self.getTypedRuleContext(GraphQLParser.EnumValueContext,0)


        def listValue(self):
            return self.getTypedRuleContext(GraphQLParser.ListValueContext,0)


        def objectValue(self):
            return self.getTypedRuleContext(GraphQLParser.ObjectValueContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_value

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

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




    def value(self):

        localctx = GraphQLParser.ValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_value)
        try:
            self.state = 250
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [GraphQLParser.T__16]:
                self.enterOuterAlt(localctx, 1)
                self.state = 241
                self.variable()
                pass
            elif token in [GraphQLParser.INT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 242
                self.intValue()
                pass
            elif token in [GraphQLParser.FLOAT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 243
                self.floatValue()
                pass
            elif token in [GraphQLParser.STRING, GraphQLParser.BLOCK_STRING]:
                self.enterOuterAlt(localctx, 4)
                self.state = 244
                self.stringValue()
                pass
            elif token in [GraphQLParser.T__11, GraphQLParser.T__12]:
                self.enterOuterAlt(localctx, 5)
                self.state = 245
                self.booleanValue()
                pass
            elif token in [GraphQLParser.T__13]:
                self.enterOuterAlt(localctx, 6)
                self.state = 246
                self.nullValue()
                pass
            elif token in [GraphQLParser.NAME]:
                self.enterOuterAlt(localctx, 7)
                self.state = 247
                self.enumValue()
                pass
            elif token in [GraphQLParser.T__14]:
                self.enterOuterAlt(localctx, 8)
                self.state = 248
                self.listValue()
                pass
            elif token in [GraphQLParser.T__3]:
                self.enterOuterAlt(localctx, 9)
                self.state = 249
                self.objectValue()
                pass
            else:
                raise NoViableAltException(self)

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


    class IntValueContext(ParserRuleContext):

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

        def INT(self):
            return self.getToken(GraphQLParser.INT, 0)

        def getRuleIndex(self):
            return GraphQLParser.RULE_intValue

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

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




    def intValue(self):

        localctx = GraphQLParser.IntValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_intValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 252
            self.match(GraphQLParser.INT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FloatValueContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return GraphQLParser.RULE_floatValue

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

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




    def floatValue(self):

        localctx = GraphQLParser.FloatValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_floatValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 254
            self.match(GraphQLParser.FLOAT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BooleanValueContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return GraphQLParser.RULE_booleanValue

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

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




    def booleanValue(self):

        localctx = GraphQLParser.BooleanValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_booleanValue)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 256
            _la = self._input.LA(1)
            if not(_la==GraphQLParser.T__11 or _la==GraphQLParser.T__12):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StringValueContext(ParserRuleContext):

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

        def STRING(self):
            return self.getToken(GraphQLParser.STRING, 0)

        def BLOCK_STRING(self):
            return self.getToken(GraphQLParser.BLOCK_STRING, 0)

        def getRuleIndex(self):
            return GraphQLParser.RULE_stringValue

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

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




    def stringValue(self):

        localctx = GraphQLParser.StringValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_stringValue)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 258
            _la = self._input.LA(1)
            if not(_la==GraphQLParser.STRING or _la==GraphQLParser.BLOCK_STRING):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NullValueContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return GraphQLParser.RULE_nullValue

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

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




    def nullValue(self):

        localctx = GraphQLParser.NullValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_nullValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 260
            self.match(GraphQLParser.T__13)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumValueContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_enumValue

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

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




    def enumValue(self):

        localctx = GraphQLParser.EnumValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_enumValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 262
            self.name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ListValueContext(ParserRuleContext):

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

        def value(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.ValueContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.ValueContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_listValue

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

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




    def listValue(self):

        localctx = GraphQLParser.ListValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_listValue)
        self._la = 0 # Token type
        try:
            self.state = 274
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 264
                self.match(GraphQLParser.T__14)
                self.state = 265
                self.match(GraphQLParser.T__15)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 266
                self.match(GraphQLParser.T__14)
                self.state = 268 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 267
                    self.value()
                    self.state = 270 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphQLParser.T__3) | (1 << GraphQLParser.T__11) | (1 << GraphQLParser.T__12) | (1 << GraphQLParser.T__13) | (1 << GraphQLParser.T__14) | (1 << GraphQLParser.T__16) | (1 << GraphQLParser.NAME) | (1 << GraphQLParser.STRING) | (1 << GraphQLParser.BLOCK_STRING) | (1 << GraphQLParser.FLOAT) | (1 << GraphQLParser.INT))) != 0)):
                        break

                self.state = 272
                self.match(GraphQLParser.T__15)
                pass


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


    class ObjectValueContext(ParserRuleContext):

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

        def objectField(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.ObjectFieldContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.ObjectFieldContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_objectValue

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

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




    def objectValue(self):

        localctx = GraphQLParser.ObjectValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_objectValue)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 276
            self.match(GraphQLParser.T__3)
            self.state = 280
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GraphQLParser.NAME:
                self.state = 277
                self.objectField()
                self.state = 282
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 283
            self.match(GraphQLParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ObjectFieldContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def value(self):
            return self.getTypedRuleContext(GraphQLParser.ValueContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_objectField

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

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




    def objectField(self):

        localctx = GraphQLParser.ObjectFieldContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_objectField)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 285
            self.name()
            self.state = 286
            self.match(GraphQLParser.T__7)
            self.state = 287
            self.value()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_variable

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

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




    def variable(self):

        localctx = GraphQLParser.VariableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_variable)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 289
            self.match(GraphQLParser.T__16)
            self.state = 290
            self.name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDefinitionsContext(ParserRuleContext):

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

        def variableDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.VariableDefinitionContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.VariableDefinitionContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_variableDefinitions

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

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




    def variableDefinitions(self):

        localctx = GraphQLParser.VariableDefinitionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_variableDefinitions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 292
            self.match(GraphQLParser.T__5)
            self.state = 294 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 293
                self.variableDefinition()
                self.state = 296 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==GraphQLParser.T__16):
                    break

            self.state = 298
            self.match(GraphQLParser.T__6)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDefinitionContext(ParserRuleContext):

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

        def variable(self):
            return self.getTypedRuleContext(GraphQLParser.VariableContext,0)


        def type_(self):
            return self.getTypedRuleContext(GraphQLParser.Type_Context,0)


        def defaultValue(self):
            return self.getTypedRuleContext(GraphQLParser.DefaultValueContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_variableDefinition

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

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




    def variableDefinition(self):

        localctx = GraphQLParser.VariableDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_variableDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 300
            self.variable()
            self.state = 301
            self.match(GraphQLParser.T__7)
            self.state = 302
            self.type_()
            self.state = 304
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__17:
                self.state = 303
                self.defaultValue()


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


    class DefaultValueContext(ParserRuleContext):

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

        def value(self):
            return self.getTypedRuleContext(GraphQLParser.ValueContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_defaultValue

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

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




    def defaultValue(self):

        localctx = GraphQLParser.DefaultValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_defaultValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 306
            self.match(GraphQLParser.T__17)
            self.state = 307
            self.value()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_Context(ParserRuleContext):

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

        def namedType(self):
            return self.getTypedRuleContext(GraphQLParser.NamedTypeContext,0)


        def listType(self):
            return self.getTypedRuleContext(GraphQLParser.ListTypeContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_type_

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

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




    def type_(self):

        localctx = GraphQLParser.Type_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_type_)
        self._la = 0 # Token type
        try:
            self.state = 317
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [GraphQLParser.NAME]:
                self.enterOuterAlt(localctx, 1)
                self.state = 309
                self.namedType()
                self.state = 311
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphQLParser.T__18:
                    self.state = 310
                    self.match(GraphQLParser.T__18)


                pass
            elif token in [GraphQLParser.T__14]:
                self.enterOuterAlt(localctx, 2)
                self.state = 313
                self.listType()
                self.state = 315
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphQLParser.T__18:
                    self.state = 314
                    self.match(GraphQLParser.T__18)


                pass
            else:
                raise NoViableAltException(self)

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


    class NamedTypeContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_namedType

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

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




    def namedType(self):

        localctx = GraphQLParser.NamedTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_namedType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 319
            self.name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ListTypeContext(ParserRuleContext):

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

        def type_(self):
            return self.getTypedRuleContext(GraphQLParser.Type_Context,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_listType

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

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




    def listType(self):

        localctx = GraphQLParser.ListTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_listType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 321
            self.match(GraphQLParser.T__14)
            self.state = 322
            self.type_()
            self.state = 323
            self.match(GraphQLParser.T__15)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DirectivesContext(ParserRuleContext):

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

        def directive(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.DirectiveContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.DirectiveContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_directives

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

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




    def directives(self):

        localctx = GraphQLParser.DirectivesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_directives)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 326 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 325
                self.directive()
                self.state = 328 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==GraphQLParser.T__19):
                    break

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


    class DirectiveContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def arguments(self):
            return self.getTypedRuleContext(GraphQLParser.ArgumentsContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_directive

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

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




    def directive(self):

        localctx = GraphQLParser.DirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_directive)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 330
            self.match(GraphQLParser.T__19)
            self.state = 331
            self.name()
            self.state = 333
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__5:
                self.state = 332
                self.arguments()


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


    class TypeSystemDefinitionContext(ParserRuleContext):

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

        def schemaDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.SchemaDefinitionContext,0)


        def typeDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.TypeDefinitionContext,0)


        def directiveDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.DirectiveDefinitionContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_typeSystemDefinition

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

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




    def typeSystemDefinition(self):

        localctx = GraphQLParser.TypeSystemDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_typeSystemDefinition)
        try:
            self.state = 338
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 335
                self.schemaDefinition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 336
                self.typeDefinition()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 337
                self.directiveDefinition()
                pass


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


    class TypeSystemExtensionContext(ParserRuleContext):

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

        def schemaExtension(self):
            return self.getTypedRuleContext(GraphQLParser.SchemaExtensionContext,0)


        def typeExtension(self):
            return self.getTypedRuleContext(GraphQLParser.TypeExtensionContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_typeSystemExtension

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

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




    def typeSystemExtension(self):

        localctx = GraphQLParser.TypeSystemExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_typeSystemExtension)
        try:
            self.state = 342
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 340
                self.schemaExtension()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 341
                self.typeExtension()
                pass


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


    class SchemaDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._rootOperationTypeDefinition = None # RootOperationTypeDefinitionContext
            self.fields = list() # of RootOperationTypeDefinitionContexts

        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def rootOperationTypeDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.RootOperationTypeDefinitionContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.RootOperationTypeDefinitionContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_schemaDefinition

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

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




    def schemaDefinition(self):

        localctx = GraphQLParser.SchemaDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_schemaDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 344
            self.match(GraphQLParser.T__20)
            self.state = 346
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__19:
                self.state = 345
                self.directives()


            self.state = 348
            self.match(GraphQLParser.T__3)
            self.state = 350 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 349
                localctx._rootOperationTypeDefinition = self.rootOperationTypeDefinition()
                localctx.fields.append(localctx._rootOperationTypeDefinition)
                self.state = 352 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphQLParser.T__0) | (1 << GraphQLParser.T__1) | (1 << GraphQLParser.T__2))) != 0)):
                    break

            self.state = 354
            self.match(GraphQLParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RootOperationTypeDefinitionContext(ParserRuleContext):

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

        def operationType(self):
            return self.getTypedRuleContext(GraphQLParser.OperationTypeContext,0)


        def namedType(self):
            return self.getTypedRuleContext(GraphQLParser.NamedTypeContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_rootOperationTypeDefinition

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

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




    def rootOperationTypeDefinition(self):

        localctx = GraphQLParser.RootOperationTypeDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_rootOperationTypeDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 356
            self.operationType()
            self.state = 357
            self.match(GraphQLParser.T__7)
            self.state = 358
            self.namedType()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SchemaExtensionContext(ParserRuleContext):

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

        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def operationTypeDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.OperationTypeDefinitionContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.OperationTypeDefinitionContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_schemaExtension

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

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




    def schemaExtension(self):

        localctx = GraphQLParser.SchemaExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_schemaExtension)
        self._la = 0 # Token type
        try:
            self.state = 376
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 360
                self.match(GraphQLParser.T__21)
                self.state = 361
                self.match(GraphQLParser.T__20)
                self.state = 363
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphQLParser.T__19:
                    self.state = 362
                    self.directives()


                self.state = 365
                self.match(GraphQLParser.T__3)
                self.state = 367 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 366
                    self.operationTypeDefinition()
                    self.state = 369 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphQLParser.T__0) | (1 << GraphQLParser.T__1) | (1 << GraphQLParser.T__2))) != 0)):
                        break

                self.state = 371
                self.match(GraphQLParser.T__4)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 373
                self.match(GraphQLParser.T__21)
                self.state = 374
                self.match(GraphQLParser.T__20)
                self.state = 375
                self.directives()
                pass


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


    class OperationTypeDefinitionContext(ParserRuleContext):

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

        def operationType(self):
            return self.getTypedRuleContext(GraphQLParser.OperationTypeContext,0)


        def namedType(self):
            return self.getTypedRuleContext(GraphQLParser.NamedTypeContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_operationTypeDefinition

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

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




    def operationTypeDefinition(self):

        localctx = GraphQLParser.OperationTypeDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_operationTypeDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 378
            self.operationType()
            self.state = 379
            self.match(GraphQLParser.T__7)
            self.state = 380
            self.namedType()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DescriptionContext(ParserRuleContext):

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

        def stringValue(self):
            return self.getTypedRuleContext(GraphQLParser.StringValueContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_description

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

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




    def description(self):

        localctx = GraphQLParser.DescriptionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_description)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 382
            self.stringValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeDefinitionContext(ParserRuleContext):

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

        def scalarTypeDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.ScalarTypeDefinitionContext,0)


        def objectTypeDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.ObjectTypeDefinitionContext,0)


        def interfaceTypeDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.InterfaceTypeDefinitionContext,0)


        def unionTypeDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.UnionTypeDefinitionContext,0)


        def enumTypeDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.EnumTypeDefinitionContext,0)


        def inputObjectTypeDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.InputObjectTypeDefinitionContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_typeDefinition

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

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




    def typeDefinition(self):

        localctx = GraphQLParser.TypeDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_typeDefinition)
        try:
            self.state = 390
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 384
                self.scalarTypeDefinition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 385
                self.objectTypeDefinition()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 386
                self.interfaceTypeDefinition()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 387
                self.unionTypeDefinition()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 388
                self.enumTypeDefinition()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 389
                self.inputObjectTypeDefinition()
                pass


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


    class TypeExtensionContext(ParserRuleContext):

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

        def scalarTypeExtension(self):
            return self.getTypedRuleContext(GraphQLParser.ScalarTypeExtensionContext,0)


        def objectTypeExtension(self):
            return self.getTypedRuleContext(GraphQLParser.ObjectTypeExtensionContext,0)


        def interfaceTypeExtension(self):
            return self.getTypedRuleContext(GraphQLParser.InterfaceTypeExtensionContext,0)


        def unionTypeExtension(self):
            return self.getTypedRuleContext(GraphQLParser.UnionTypeExtensionContext,0)


        def enumTypeExtension(self):
            return self.getTypedRuleContext(GraphQLParser.EnumTypeExtensionContext,0)


        def inputObjectTypeExtension(self):
            return self.getTypedRuleContext(GraphQLParser.InputObjectTypeExtensionContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_typeExtension

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

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




    def typeExtension(self):

        localctx = GraphQLParser.TypeExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_typeExtension)
        try:
            self.state = 398
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 392
                self.scalarTypeExtension()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 393
                self.objectTypeExtension()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 394
                self.interfaceTypeExtension()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 395
                self.unionTypeExtension()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 396
                self.enumTypeExtension()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 397
                self.inputObjectTypeExtension()
                pass


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


    class ScalarTypeDefinitionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def description(self):
            return self.getTypedRuleContext(GraphQLParser.DescriptionContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_scalarTypeDefinition

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

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




    def scalarTypeDefinition(self):

        localctx = GraphQLParser.ScalarTypeDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_scalarTypeDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 401
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.STRING or _la==GraphQLParser.BLOCK_STRING:
                self.state = 400
                self.description()


            self.state = 403
            self.match(GraphQLParser.T__22)
            self.state = 404
            self.name()
            self.state = 406
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__19:
                self.state = 405
                self.directives()


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


    class ScalarTypeExtensionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_scalarTypeExtension

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

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




    def scalarTypeExtension(self):

        localctx = GraphQLParser.ScalarTypeExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_scalarTypeExtension)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 408
            self.match(GraphQLParser.T__23)
            self.state = 409
            self.match(GraphQLParser.T__22)
            self.state = 410
            self.name()
            self.state = 411
            self.directives()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ObjectTypeDefinitionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def description(self):
            return self.getTypedRuleContext(GraphQLParser.DescriptionContext,0)


        def implementsInterfaces(self):
            return self.getTypedRuleContext(GraphQLParser.ImplementsInterfacesContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def fieldsDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.FieldsDefinitionContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_objectTypeDefinition

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

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




    def objectTypeDefinition(self):

        localctx = GraphQLParser.ObjectTypeDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_objectTypeDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 414
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.STRING or _la==GraphQLParser.BLOCK_STRING:
                self.state = 413
                self.description()


            self.state = 416
            self.match(GraphQLParser.T__24)
            self.state = 417
            self.name()
            self.state = 419
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__25:
                self.state = 418
                self.implementsInterfaces(0)


            self.state = 422
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__19:
                self.state = 421
                self.directives()


            self.state = 425
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
            if la_ == 1:
                self.state = 424
                self.fieldsDefinition()


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


    class ImplementsInterfacesContext(ParserRuleContext):

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

        def namedType(self):
            return self.getTypedRuleContext(GraphQLParser.NamedTypeContext,0)


        def implementsInterfaces(self):
            return self.getTypedRuleContext(GraphQLParser.ImplementsInterfacesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_implementsInterfaces

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

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



    def implementsInterfaces(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = GraphQLParser.ImplementsInterfacesContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 94
        self.enterRecursionRule(localctx, 94, self.RULE_implementsInterfaces, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 428
            self.match(GraphQLParser.T__25)
            self.state = 430
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__26:
                self.state = 429
                self.match(GraphQLParser.T__26)


            self.state = 432
            self.namedType()
            self._ctx.stop = self._input.LT(-1)
            self.state = 439
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,45,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = GraphQLParser.ImplementsInterfacesContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_implementsInterfaces)
                    self.state = 434
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 435
                    self.match(GraphQLParser.T__26)
                    self.state = 436
                    self.namedType() 
                self.state = 441
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,45,self._ctx)

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


    class FieldsDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._fieldDefinition = None # FieldDefinitionContext
            self.fields = list() # of FieldDefinitionContexts

        def fieldDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.FieldDefinitionContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.FieldDefinitionContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_fieldsDefinition

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

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




    def fieldsDefinition(self):

        localctx = GraphQLParser.FieldsDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_fieldsDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 442
            self.match(GraphQLParser.T__3)
            self.state = 444 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 443
                localctx._fieldDefinition = self.fieldDefinition()
                localctx.fields.append(localctx._fieldDefinition)
                self.state = 446 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphQLParser.NAME) | (1 << GraphQLParser.STRING) | (1 << GraphQLParser.BLOCK_STRING))) != 0)):
                    break

            self.state = 448
            self.match(GraphQLParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FieldDefinitionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def type_(self):
            return self.getTypedRuleContext(GraphQLParser.Type_Context,0)


        def description(self):
            return self.getTypedRuleContext(GraphQLParser.DescriptionContext,0)


        def argumentsDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.ArgumentsDefinitionContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_fieldDefinition

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

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




    def fieldDefinition(self):

        localctx = GraphQLParser.FieldDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_fieldDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 451
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.STRING or _la==GraphQLParser.BLOCK_STRING:
                self.state = 450
                self.description()


            self.state = 453
            self.name()
            self.state = 455
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__5:
                self.state = 454
                self.argumentsDefinition()


            self.state = 457
            self.match(GraphQLParser.T__7)
            self.state = 458
            self.type_()
            self.state = 460
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__19:
                self.state = 459
                self.directives()


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


    class ArgumentsDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._inputValueDefinition = None # InputValueDefinitionContext
            self.args = list() # of InputValueDefinitionContexts

        def inputValueDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.InputValueDefinitionContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.InputValueDefinitionContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_argumentsDefinition

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

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




    def argumentsDefinition(self):

        localctx = GraphQLParser.ArgumentsDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_argumentsDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 462
            self.match(GraphQLParser.T__5)
            self.state = 464 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 463
                localctx._inputValueDefinition = self.inputValueDefinition()
                localctx.args.append(localctx._inputValueDefinition)
                self.state = 466 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphQLParser.NAME) | (1 << GraphQLParser.STRING) | (1 << GraphQLParser.BLOCK_STRING))) != 0)):
                    break

            self.state = 468
            self.match(GraphQLParser.T__6)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InputValueDefinitionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def type_(self):
            return self.getTypedRuleContext(GraphQLParser.Type_Context,0)


        def description(self):
            return self.getTypedRuleContext(GraphQLParser.DescriptionContext,0)


        def defaultValue(self):
            return self.getTypedRuleContext(GraphQLParser.DefaultValueContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_inputValueDefinition

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

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




    def inputValueDefinition(self):

        localctx = GraphQLParser.InputValueDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_inputValueDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 471
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.STRING or _la==GraphQLParser.BLOCK_STRING:
                self.state = 470
                self.description()


            self.state = 473
            self.name()
            self.state = 474
            self.match(GraphQLParser.T__7)
            self.state = 475
            self.type_()
            self.state = 477
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__17:
                self.state = 476
                self.defaultValue()


            self.state = 480
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__19:
                self.state = 479
                self.directives()


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


    class ObjectTypeExtensionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def fieldsDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.FieldsDefinitionContext,0)


        def implementsInterfaces(self):
            return self.getTypedRuleContext(GraphQLParser.ImplementsInterfacesContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_objectTypeExtension

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

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




    def objectTypeExtension(self):

        localctx = GraphQLParser.ObjectTypeExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_objectTypeExtension)
        self._la = 0 # Token type
        try:
            self.state = 506
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 482
                self.match(GraphQLParser.T__21)
                self.state = 483
                self.match(GraphQLParser.T__24)
                self.state = 484
                self.name()
                self.state = 486
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphQLParser.T__25:
                    self.state = 485
                    self.implementsInterfaces(0)


                self.state = 489
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphQLParser.T__19:
                    self.state = 488
                    self.directives()


                self.state = 491
                self.fieldsDefinition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 493
                self.match(GraphQLParser.T__21)
                self.state = 494
                self.match(GraphQLParser.T__24)
                self.state = 495
                self.name()
                self.state = 497
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphQLParser.T__25:
                    self.state = 496
                    self.implementsInterfaces(0)


                self.state = 499
                self.directives()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 501
                self.match(GraphQLParser.T__21)
                self.state = 502
                self.match(GraphQLParser.T__24)
                self.state = 503
                self.name()
                self.state = 504
                self.implementsInterfaces(0)
                pass


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


    class InterfaceTypeDefinitionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def description(self):
            return self.getTypedRuleContext(GraphQLParser.DescriptionContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def fieldsDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.FieldsDefinitionContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_interfaceTypeDefinition

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

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




    def interfaceTypeDefinition(self):

        localctx = GraphQLParser.InterfaceTypeDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_interfaceTypeDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 509
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.STRING or _la==GraphQLParser.BLOCK_STRING:
                self.state = 508
                self.description()


            self.state = 511
            self.match(GraphQLParser.T__27)
            self.state = 512
            self.name()
            self.state = 514
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__19:
                self.state = 513
                self.directives()


            self.state = 517
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,60,self._ctx)
            if la_ == 1:
                self.state = 516
                self.fieldsDefinition()


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


    class InterfaceTypeExtensionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def fieldsDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.FieldsDefinitionContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_interfaceTypeExtension

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

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




    def interfaceTypeExtension(self):

        localctx = GraphQLParser.InterfaceTypeExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_interfaceTypeExtension)
        self._la = 0 # Token type
        try:
            self.state = 532
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,62,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 519
                self.match(GraphQLParser.T__21)
                self.state = 520
                self.match(GraphQLParser.T__27)
                self.state = 521
                self.name()
                self.state = 523
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphQLParser.T__19:
                    self.state = 522
                    self.directives()


                self.state = 525
                self.fieldsDefinition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 527
                self.match(GraphQLParser.T__21)
                self.state = 528
                self.match(GraphQLParser.T__27)
                self.state = 529
                self.name()
                self.state = 530
                self.directives()
                pass


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


    class UnionTypeDefinitionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def description(self):
            return self.getTypedRuleContext(GraphQLParser.DescriptionContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def unionMemberTypes(self):
            return self.getTypedRuleContext(GraphQLParser.UnionMemberTypesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_unionTypeDefinition

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

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




    def unionTypeDefinition(self):

        localctx = GraphQLParser.UnionTypeDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_unionTypeDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 535
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.STRING or _la==GraphQLParser.BLOCK_STRING:
                self.state = 534
                self.description()


            self.state = 537
            self.match(GraphQLParser.T__28)
            self.state = 538
            self.name()
            self.state = 540
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__19:
                self.state = 539
                self.directives()


            self.state = 543
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__17:
                self.state = 542
                self.unionMemberTypes()


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


    class UnionMemberTypesContext(ParserRuleContext):

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

        def namedType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.NamedTypeContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.NamedTypeContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_unionMemberTypes

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

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




    def unionMemberTypes(self):

        localctx = GraphQLParser.UnionMemberTypesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_unionMemberTypes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 545
            self.match(GraphQLParser.T__17)
            self.state = 547
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__29:
                self.state = 546
                self.match(GraphQLParser.T__29)


            self.state = 549
            self.namedType()
            self.state = 554
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GraphQLParser.T__29:
                self.state = 550
                self.match(GraphQLParser.T__29)
                self.state = 551
                self.namedType()
                self.state = 556
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class UnionTypeExtensionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def unionMemberTypes(self):
            return self.getTypedRuleContext(GraphQLParser.UnionMemberTypesContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_unionTypeExtension

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

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




    def unionTypeExtension(self):

        localctx = GraphQLParser.UnionTypeExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_unionTypeExtension)
        self._la = 0 # Token type
        try:
            self.state = 570
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 557
                self.match(GraphQLParser.T__21)
                self.state = 558
                self.match(GraphQLParser.T__28)
                self.state = 559
                self.name()
                self.state = 561
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphQLParser.T__19:
                    self.state = 560
                    self.directives()


                self.state = 563
                self.unionMemberTypes()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 565
                self.match(GraphQLParser.T__21)
                self.state = 566
                self.match(GraphQLParser.T__28)
                self.state = 567
                self.name()
                self.state = 568
                self.directives()
                pass


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


    class EnumTypeDefinitionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def description(self):
            return self.getTypedRuleContext(GraphQLParser.DescriptionContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def enumValuesDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.EnumValuesDefinitionContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_enumTypeDefinition

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

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




    def enumTypeDefinition(self):

        localctx = GraphQLParser.EnumTypeDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_enumTypeDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 573
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.STRING or _la==GraphQLParser.BLOCK_STRING:
                self.state = 572
                self.description()


            self.state = 575
            self.match(GraphQLParser.T__30)
            self.state = 576
            self.name()
            self.state = 578
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__19:
                self.state = 577
                self.directives()


            self.state = 581
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
            if la_ == 1:
                self.state = 580
                self.enumValuesDefinition()


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


    class EnumValuesDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._enumValueDefinition = None # EnumValueDefinitionContext
            self.fields = list() # of EnumValueDefinitionContexts

        def enumValueDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.EnumValueDefinitionContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.EnumValueDefinitionContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_enumValuesDefinition

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

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




    def enumValuesDefinition(self):

        localctx = GraphQLParser.EnumValuesDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_enumValuesDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 583
            self.match(GraphQLParser.T__3)
            self.state = 585 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 584
                localctx._enumValueDefinition = self.enumValueDefinition()
                localctx.fields.append(localctx._enumValueDefinition)
                self.state = 587 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphQLParser.NAME) | (1 << GraphQLParser.STRING) | (1 << GraphQLParser.BLOCK_STRING))) != 0)):
                    break

            self.state = 589
            self.match(GraphQLParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumValueDefinitionContext(ParserRuleContext):

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

        def enumValue(self):
            return self.getTypedRuleContext(GraphQLParser.EnumValueContext,0)


        def description(self):
            return self.getTypedRuleContext(GraphQLParser.DescriptionContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_enumValueDefinition

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

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




    def enumValueDefinition(self):

        localctx = GraphQLParser.EnumValueDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_enumValueDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 592
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.STRING or _la==GraphQLParser.BLOCK_STRING:
                self.state = 591
                self.description()


            self.state = 594
            self.enumValue()
            self.state = 596
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__19:
                self.state = 595
                self.directives()


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


    class EnumTypeExtensionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def enumValuesDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.EnumValuesDefinitionContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_enumTypeExtension

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

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




    def enumTypeExtension(self):

        localctx = GraphQLParser.EnumTypeExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_enumTypeExtension)
        self._la = 0 # Token type
        try:
            self.state = 611
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,77,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 598
                self.match(GraphQLParser.T__21)
                self.state = 599
                self.match(GraphQLParser.T__30)
                self.state = 600
                self.name()
                self.state = 602
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphQLParser.T__19:
                    self.state = 601
                    self.directives()


                self.state = 604
                self.enumValuesDefinition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 606
                self.match(GraphQLParser.T__21)
                self.state = 607
                self.match(GraphQLParser.T__30)
                self.state = 608
                self.name()
                self.state = 609
                self.directives()
                pass


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


    class InputObjectTypeDefinitionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def description(self):
            return self.getTypedRuleContext(GraphQLParser.DescriptionContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def inputFieldsDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.InputFieldsDefinitionContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_inputObjectTypeDefinition

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

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




    def inputObjectTypeDefinition(self):

        localctx = GraphQLParser.InputObjectTypeDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_inputObjectTypeDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 614
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.STRING or _la==GraphQLParser.BLOCK_STRING:
                self.state = 613
                self.description()


            self.state = 616
            self.match(GraphQLParser.T__31)
            self.state = 617
            self.name()
            self.state = 619
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__19:
                self.state = 618
                self.directives()


            self.state = 622
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,80,self._ctx)
            if la_ == 1:
                self.state = 621
                self.inputFieldsDefinition()


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


    class InputFieldsDefinitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._inputValueDefinition = None # InputValueDefinitionContext
            self.fields = list() # of InputValueDefinitionContexts

        def inputValueDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.InputValueDefinitionContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.InputValueDefinitionContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_inputFieldsDefinition

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

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




    def inputFieldsDefinition(self):

        localctx = GraphQLParser.InputFieldsDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_inputFieldsDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 624
            self.match(GraphQLParser.T__3)
            self.state = 626 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 625
                localctx._inputValueDefinition = self.inputValueDefinition()
                localctx.fields.append(localctx._inputValueDefinition)
                self.state = 628 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphQLParser.NAME) | (1 << GraphQLParser.STRING) | (1 << GraphQLParser.BLOCK_STRING))) != 0)):
                    break

            self.state = 630
            self.match(GraphQLParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InputObjectTypeExtensionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def inputFieldsDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.InputFieldsDefinitionContext,0)


        def directives(self):
            return self.getTypedRuleContext(GraphQLParser.DirectivesContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_inputObjectTypeExtension

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

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




    def inputObjectTypeExtension(self):

        localctx = GraphQLParser.InputObjectTypeExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_inputObjectTypeExtension)
        self._la = 0 # Token type
        try:
            self.state = 645
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 632
                self.match(GraphQLParser.T__21)
                self.state = 633
                self.match(GraphQLParser.T__31)
                self.state = 634
                self.name()
                self.state = 636
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphQLParser.T__19:
                    self.state = 635
                    self.directives()


                self.state = 638
                self.inputFieldsDefinition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 640
                self.match(GraphQLParser.T__21)
                self.state = 641
                self.match(GraphQLParser.T__31)
                self.state = 642
                self.name()
                self.state = 643
                self.directives()
                pass


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


    class DirectiveDefinitionContext(ParserRuleContext):

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

        def name(self):
            return self.getTypedRuleContext(GraphQLParser.NameContext,0)


        def directiveLocations(self):
            return self.getTypedRuleContext(GraphQLParser.DirectiveLocationsContext,0)


        def description(self):
            return self.getTypedRuleContext(GraphQLParser.DescriptionContext,0)


        def argumentsDefinition(self):
            return self.getTypedRuleContext(GraphQLParser.ArgumentsDefinitionContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_directiveDefinition

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

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




    def directiveDefinition(self):

        localctx = GraphQLParser.DirectiveDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_directiveDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 648
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.STRING or _la==GraphQLParser.BLOCK_STRING:
                self.state = 647
                self.description()


            self.state = 650
            self.match(GraphQLParser.T__32)
            self.state = 651
            self.match(GraphQLParser.T__19)
            self.state = 652
            self.name()
            self.state = 654
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphQLParser.T__5:
                self.state = 653
                self.argumentsDefinition()


            self.state = 656
            self.match(GraphQLParser.T__10)
            self.state = 657
            self.directiveLocations()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DirectiveLocationsContext(ParserRuleContext):

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

        def directiveLocation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GraphQLParser.DirectiveLocationContext)
            else:
                return self.getTypedRuleContext(GraphQLParser.DirectiveLocationContext,i)


        def getRuleIndex(self):
            return GraphQLParser.RULE_directiveLocations

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

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




    def directiveLocations(self):

        localctx = GraphQLParser.DirectiveLocationsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_directiveLocations)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 659
            self.directiveLocation()
            self.state = 664
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GraphQLParser.T__29:
                self.state = 660
                self.match(GraphQLParser.T__29)
                self.state = 661
                self.directiveLocation()
                self.state = 666
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class DirectiveLocationContext(ParserRuleContext):

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

        def executableDirectiveLocation(self):
            return self.getTypedRuleContext(GraphQLParser.ExecutableDirectiveLocationContext,0)


        def typeSystemDirectiveLocation(self):
            return self.getTypedRuleContext(GraphQLParser.TypeSystemDirectiveLocationContext,0)


        def getRuleIndex(self):
            return GraphQLParser.RULE_directiveLocation

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

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




    def directiveLocation(self):

        localctx = GraphQLParser.DirectiveLocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_directiveLocation)
        try:
            self.state = 669
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [GraphQLParser.T__33, GraphQLParser.T__34, GraphQLParser.T__35, GraphQLParser.T__36, GraphQLParser.T__37, GraphQLParser.T__38, GraphQLParser.T__39]:
                self.enterOuterAlt(localctx, 1)
                self.state = 667
                self.executableDirectiveLocation()
                pass
            elif token in [GraphQLParser.T__40, GraphQLParser.T__41, GraphQLParser.T__42, GraphQLParser.T__43, GraphQLParser.T__44, GraphQLParser.T__45, GraphQLParser.T__46, GraphQLParser.T__47, GraphQLParser.T__48, GraphQLParser.T__49, GraphQLParser.T__50]:
                self.enterOuterAlt(localctx, 2)
                self.state = 668
                self.typeSystemDirectiveLocation()
                pass
            else:
                raise NoViableAltException(self)

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


    class ExecutableDirectiveLocationContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return GraphQLParser.RULE_executableDirectiveLocation

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

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




    def executableDirectiveLocation(self):

        localctx = GraphQLParser.ExecutableDirectiveLocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_executableDirectiveLocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 671
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphQLParser.T__33) | (1 << GraphQLParser.T__34) | (1 << GraphQLParser.T__35) | (1 << GraphQLParser.T__36) | (1 << GraphQLParser.T__37) | (1 << GraphQLParser.T__38) | (1 << GraphQLParser.T__39))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeSystemDirectiveLocationContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return GraphQLParser.RULE_typeSystemDirectiveLocation

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

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




    def typeSystemDirectiveLocation(self):

        localctx = GraphQLParser.TypeSystemDirectiveLocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_typeSystemDirectiveLocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 673
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphQLParser.T__40) | (1 << GraphQLParser.T__41) | (1 << GraphQLParser.T__42) | (1 << GraphQLParser.T__43) | (1 << GraphQLParser.T__44) | (1 << GraphQLParser.T__45) | (1 << GraphQLParser.T__46) | (1 << GraphQLParser.T__47) | (1 << GraphQLParser.T__48) | (1 << GraphQLParser.T__49) | (1 << GraphQLParser.T__50))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NameContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return GraphQLParser.RULE_name

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

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




    def name(self):

        localctx = GraphQLParser.NameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 675
            self.match(GraphQLParser.NAME)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



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

    def implementsInterfaces_sempred(self, localctx:ImplementsInterfacesContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 1)
         




