# flake8: noqa
# type: ignore
# Generated from Graphql.g4 by ANTLR 4.8
# encoding: utf-8
from ..._vendor.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("\u02ab\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\3\32\3\32\7\32\u011b\n")
        buf.write("\32\f\32\16\32\u011e\13\32\3\32\5\32\u0121\n\32\3\33\3")
        buf.write("\33\3\33\3\33\3\34\3\34\3\34\3\35\3\35\6\35\u012c\n\35")
        buf.write("\r\35\16\35\u012d\3\35\3\35\3\36\3\36\3\36\3\36\5\36\u0136")
        buf.write("\n\36\3\37\3\37\3\37\3 \3 \5 \u013d\n \3 \3 \5 \u0141")
        buf.write("\n \5 \u0143\n \3!\3!\3\"\3\"\3\"\3\"\3#\6#\u014c\n#\r")
        buf.write("#\16#\u014d\3$\3$\3$\5$\u0153\n$\3%\3%\3%\5%\u0158\n%")
        buf.write("\3&\3&\5&\u015c\n&\3\'\3\'\5\'\u0160\n\'\3\'\3\'\6\'\u0164")
        buf.write("\n\'\r\'\16\'\u0165\3\'\3\'\3(\3(\3(\3(\3)\3)\3)\5)\u0171")
        buf.write("\n)\3)\3)\6)\u0175\n)\r)\16)\u0176\3)\3)\3)\3)\3)\5)\u017e")
        buf.write("\n)\3*\3*\3*\3*\3+\3+\3,\3,\3,\3,\3,\3,\5,\u018c\n,\3")
        buf.write("-\3-\3-\3-\3-\3-\5-\u0194\n-\3.\5.\u0197\n.\3.\3.\3.\5")
        buf.write(".\u019c\n.\3/\3/\3/\3/\3/\3\60\5\60\u01a4\n\60\3\60\3")
        buf.write("\60\3\60\5\60\u01a9\n\60\3\60\5\60\u01ac\n\60\3\60\5\60")
        buf.write("\u01af\n\60\3\61\3\61\3\61\5\61\u01b4\n\61\3\61\3\61\3")
        buf.write("\61\3\61\3\61\7\61\u01bb\n\61\f\61\16\61\u01be\13\61\3")
        buf.write("\62\3\62\6\62\u01c2\n\62\r\62\16\62\u01c3\3\62\3\62\3")
        buf.write("\63\5\63\u01c9\n\63\3\63\3\63\5\63\u01cd\n\63\3\63\3\63")
        buf.write("\3\63\5\63\u01d2\n\63\3\64\3\64\6\64\u01d6\n\64\r\64\16")
        buf.write("\64\u01d7\3\64\3\64\3\65\5\65\u01dd\n\65\3\65\3\65\3\65")
        buf.write("\3\65\5\65\u01e3\n\65\3\65\5\65\u01e6\n\65\3\66\3\66\3")
        buf.write("\66\3\66\5\66\u01ec\n\66\3\66\5\66\u01ef\n\66\3\66\3\66")
        buf.write("\3\66\3\66\3\66\3\66\5\66\u01f7\n\66\3\66\3\66\3\66\3")
        buf.write("\66\3\66\3\66\3\66\5\66\u0200\n\66\3\67\5\67\u0203\n\67")
        buf.write("\3\67\3\67\3\67\5\67\u0208\n\67\3\67\5\67\u020b\n\67\3")
        buf.write("8\38\38\38\58\u0211\n8\38\38\38\38\38\38\38\58\u021a\n")
        buf.write("8\39\59\u021d\n9\39\39\39\59\u0222\n9\39\59\u0225\n9\3")
        buf.write(":\3:\5:\u0229\n:\3:\3:\3:\7:\u022e\n:\f:\16:\u0231\13")
        buf.write(":\3;\3;\3;\3;\5;\u0237\n;\3;\3;\3;\3;\3;\3;\3;\5;\u0240")
        buf.write("\n;\3<\5<\u0243\n<\3<\3<\3<\5<\u0248\n<\3<\5<\u024b\n")
        buf.write("<\3=\3=\6=\u024f\n=\r=\16=\u0250\3=\3=\3>\5>\u0256\n>")
        buf.write("\3>\3>\5>\u025a\n>\3?\3?\3?\3?\5?\u0260\n?\3?\3?\3?\3")
        buf.write("?\3?\3?\3?\5?\u0269\n?\3@\5@\u026c\n@\3@\3@\3@\5@\u0271")
        buf.write("\n@\3@\5@\u0274\n@\3A\3A\6A\u0278\nA\rA\16A\u0279\3A\3")
        buf.write("A\3B\3B\3B\3B\5B\u0282\nB\3B\3B\3B\3B\3B\3B\3B\5B\u028b")
        buf.write("\nB\3C\5C\u028e\nC\3C\3C\3C\3C\5C\u0294\nC\3C\3C\3C\3")
        buf.write("D\3D\3D\7D\u029c\nD\fD\16D\u029f\13D\3E\3E\5E\u02a3\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\b\5\2&&++\61\61\4\2\30\30\62\62\3\2\67")
        buf.write("8\b\2\31\31\34\35\37\37%%**\60\60\13\2\21\21\23\23\25")
        buf.write("\25\32\32!#((,,..\64\64\3\2\21\66\2\u02cf\2\u0091\3\2")
        buf.write("\2\2\4\u0098\3\2\2\2\6\u009c\3\2\2\2\b\u00ab\3\2\2\2\n")
        buf.write("\u00ad\3\2\2\2\f\u00af\3\2\2\2\16\u00ba\3\2\2\2\20\u00bd")
        buf.write("\3\2\2\2\22\u00c9\3\2\2\2\24\u00d1\3\2\2\2\26\u00d5\3")
        buf.write("\2\2\2\30\u00d8\3\2\2\2\32\u00dd\3\2\2\2\34\u00e5\3\2")
        buf.write("\2\2\36\u00e7\3\2\2\2 \u00ea\3\2\2\2\"\u00fc\3\2\2\2$")
        buf.write("\u00fe\3\2\2\2&\u0100\3\2\2\2(\u0102\3\2\2\2*\u0104\3")
        buf.write("\2\2\2,\u0106\3\2\2\2.\u0108\3\2\2\2\60\u0114\3\2\2\2")
        buf.write("\62\u0120\3\2\2\2\64\u0122\3\2\2\2\66\u0126\3\2\2\28\u0129")
        buf.write("\3\2\2\2:\u0131\3\2\2\2<\u0137\3\2\2\2>\u0142\3\2\2\2")
        buf.write("@\u0144\3\2\2\2B\u0146\3\2\2\2D\u014b\3\2\2\2F\u014f\3")
        buf.write("\2\2\2H\u0157\3\2\2\2J\u015b\3\2\2\2L\u015d\3\2\2\2N\u0169")
        buf.write("\3\2\2\2P\u017d\3\2\2\2R\u017f\3\2\2\2T\u0183\3\2\2\2")
        buf.write("V\u018b\3\2\2\2X\u0193\3\2\2\2Z\u0196\3\2\2\2\\\u019d")
        buf.write("\3\2\2\2^\u01a3\3\2\2\2`\u01b0\3\2\2\2b\u01bf\3\2\2\2")
        buf.write("d\u01c8\3\2\2\2f\u01d3\3\2\2\2h\u01dc\3\2\2\2j\u01ff\3")
        buf.write("\2\2\2l\u0202\3\2\2\2n\u0219\3\2\2\2p\u021c\3\2\2\2r\u0226")
        buf.write("\3\2\2\2t\u023f\3\2\2\2v\u0242\3\2\2\2x\u024c\3\2\2\2")
        buf.write("z\u0255\3\2\2\2|\u0268\3\2\2\2~\u026b\3\2\2\2\u0080\u0275")
        buf.write("\3\2\2\2\u0082\u028a\3\2\2\2\u0084\u028d\3\2\2\2\u0086")
        buf.write("\u0298\3\2\2\2\u0088\u02a2\3\2\2\2\u008a\u02a4\3\2\2\2")
        buf.write("\u008c\u02a6\3\2\2\2\u008e\u02a8\3\2\2\2\u0090\u0092\5")
        buf.write("\4\3\2\u0091\u0090\3\2\2\2\u0092\u0093\3\2\2\2\u0093\u0091")
        buf.write("\3\2\2\2\u0093\u0094\3\2\2\2\u0094\3\3\2\2\2\u0095\u0099")
        buf.write("\5\6\4\2\u0096\u0099\5H%\2\u0097\u0099\5J&\2\u0098\u0095")
        buf.write("\3\2\2\2\u0098\u0096\3\2\2\2\u0098\u0097\3\2\2\2\u0099")
        buf.write("\5\3\2\2\2\u009a\u009d\5\b\5\2\u009b\u009d\5\32\16\2\u009c")
        buf.write("\u009a\3\2\2\2\u009c\u009b\3\2\2\2\u009d\7\3\2\2\2\u009e")
        buf.write("\u00a0\5\n\6\2\u009f\u00a1\5\u008eH\2\u00a0\u009f\3\2")
        buf.write("\2\2\u00a0\u00a1\3\2\2\2\u00a1\u00a3\3\2\2\2\u00a2\u00a4")
        buf.write("\58\35\2\u00a3\u00a2\3\2\2\2\u00a3\u00a4\3\2\2\2\u00a4")
        buf.write("\u00a6\3\2\2\2\u00a5\u00a7\5D#\2\u00a6\u00a5\3\2\2\2\u00a6")
        buf.write("\u00a7\3\2\2\2\u00a7\u00a8\3\2\2\2\u00a8\u00a9\5\f\7\2")
        buf.write("\u00a9\u00ac\3\2\2\2\u00aa\u00ac\5\f\7\2\u00ab\u009e\3")
        buf.write("\2\2\2\u00ab\u00aa\3\2\2\2\u00ac\t\3\2\2\2\u00ad\u00ae")
        buf.write("\t\2\2\2\u00ae\13\3\2\2\2\u00af\u00b1\7\3\2\2\u00b0\u00b2")
        buf.write("\5\16\b\2\u00b1\u00b0\3\2\2\2\u00b2\u00b3\3\2\2\2\u00b3")
        buf.write("\u00b1\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4\u00b5\3\2\2\2")
        buf.write("\u00b5\u00b6\7\4\2\2\u00b6\r\3\2\2\2\u00b7\u00bb\5\20")
        buf.write("\t\2\u00b8\u00bb\5\30\r\2\u00b9\u00bb\5 \21\2\u00ba\u00b7")
        buf.write("\3\2\2\2\u00ba\u00b8\3\2\2\2\u00ba\u00b9\3\2\2\2\u00bb")
        buf.write("\17\3\2\2\2\u00bc\u00be\5\26\f\2\u00bd\u00bc\3\2\2\2\u00bd")
        buf.write("\u00be\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf\u00c1\5\u008e")
        buf.write("H\2\u00c0\u00c2\5\22\n\2\u00c1\u00c0\3\2\2\2\u00c1\u00c2")
        buf.write("\3\2\2\2\u00c2\u00c4\3\2\2\2\u00c3\u00c5\5D#\2\u00c4\u00c3")
        buf.write("\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\u00c7\3\2\2\2\u00c6")
        buf.write("\u00c8\5\f\7\2\u00c7\u00c6\3\2\2\2\u00c7\u00c8\3\2\2\2")
        buf.write("\u00c8\21\3\2\2\2\u00c9\u00cb\7\5\2\2\u00ca\u00cc\5\24")
        buf.write("\13\2\u00cb\u00ca\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd\u00cb")
        buf.write("\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf")
        buf.write("\u00d0\7\6\2\2\u00d0\23\3\2\2\2\u00d1\u00d2\5\u008eH\2")
        buf.write("\u00d2\u00d3\7\7\2\2\u00d3\u00d4\5\"\22\2\u00d4\25\3\2")
        buf.write("\2\2\u00d5\u00d6\5\u008eH\2\u00d6\u00d7\7\7\2\2\u00d7")
        buf.write("\27\3\2\2\2\u00d8\u00d9\7\b\2\2\u00d9\u00db\5\34\17\2")
        buf.write("\u00da\u00dc\5D#\2\u00db\u00da\3\2\2\2\u00db\u00dc\3\2")
        buf.write("\2\2\u00dc\31\3\2\2\2\u00dd\u00de\7\33\2\2\u00de\u00df")
        buf.write("\5\34\17\2\u00df\u00e1\5\36\20\2\u00e0\u00e2\5D#\2\u00e1")
        buf.write("\u00e0\3\2\2\2\u00e1\u00e2\3\2\2\2\u00e2\u00e3\3\2\2\2")
        buf.write("\u00e3\u00e4\5\f\7\2\u00e4\33\3\2\2\2\u00e5\u00e6\5\u008e")
        buf.write("H\2\u00e6\35\3\2\2\2\u00e7\u00e8\7)\2\2\u00e8\u00e9\5")
        buf.write("@!\2\u00e9\37\3\2\2\2\u00ea\u00ec\7\b\2\2\u00eb\u00ed")
        buf.write("\5\36\20\2\u00ec\u00eb\3\2\2\2\u00ec\u00ed\3\2\2\2\u00ed")
        buf.write("\u00ef\3\2\2\2\u00ee\u00f0\5D#\2\u00ef\u00ee\3\2\2\2\u00ef")
        buf.write("\u00f0\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f2\5\f\7\2")
        buf.write("\u00f2!\3\2\2\2\u00f3\u00fd\5\66\34\2\u00f4\u00fd\5$\23")
        buf.write("\2\u00f5\u00fd\5&\24\2\u00f6\u00fd\5*\26\2\u00f7\u00fd")
        buf.write("\5(\25\2\u00f8\u00fd\5,\27\2\u00f9\u00fd\5.\30\2\u00fa")
        buf.write("\u00fd\5\60\31\2\u00fb\u00fd\5\62\32\2\u00fc\u00f3\3\2")
        buf.write("\2\2\u00fc\u00f4\3\2\2\2\u00fc\u00f5\3\2\2\2\u00fc\u00f6")
        buf.write("\3\2\2\2\u00fc\u00f7\3\2\2\2\u00fc\u00f8\3\2\2\2\u00fc")
        buf.write("\u00f9\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fc\u00fb\3\2\2\2")
        buf.write("\u00fd#\3\2\2\2\u00fe\u00ff\7;\2\2\u00ff%\3\2\2\2\u0100")
        buf.write("\u0101\7:\2\2\u0101\'\3\2\2\2\u0102\u0103\t\3\2\2\u0103")
        buf.write(")\3\2\2\2\u0104\u0105\t\4\2\2\u0105+\3\2\2\2\u0106\u0107")
        buf.write("\7\'\2\2\u0107-\3\2\2\2\u0108\u0109\5\u008eH\2\u0109/")
        buf.write("\3\2\2\2\u010a\u010b\7\t\2\2\u010b\u0115\7\n\2\2\u010c")
        buf.write("\u010e\7\t\2\2\u010d\u010f\5\"\22\2\u010e\u010d\3\2\2")
        buf.write("\2\u010f\u0110\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u0111")
        buf.write("\3\2\2\2\u0111\u0112\3\2\2\2\u0112\u0113\7\n\2\2\u0113")
        buf.write("\u0115\3\2\2\2\u0114\u010a\3\2\2\2\u0114\u010c\3\2\2\2")
        buf.write("\u0115\61\3\2\2\2\u0116\u0117\7\3\2\2\u0117\u0121\7\4")
        buf.write("\2\2\u0118\u011c\7\3\2\2\u0119\u011b\5\64\33\2\u011a\u0119")
        buf.write("\3\2\2\2\u011b\u011e\3\2\2\2\u011c\u011a\3\2\2\2\u011c")
        buf.write("\u011d\3\2\2\2\u011d\u011f\3\2\2\2\u011e\u011c\3\2\2\2")
        buf.write("\u011f\u0121\7\4\2\2\u0120\u0116\3\2\2\2\u0120\u0118\3")
        buf.write("\2\2\2\u0121\63\3\2\2\2\u0122\u0123\5\u008eH\2\u0123\u0124")
        buf.write("\7\7\2\2\u0124\u0125\5\"\22\2\u0125\65\3\2\2\2\u0126\u0127")
        buf.write("\7\13\2\2\u0127\u0128\5\u008eH\2\u0128\67\3\2\2\2\u0129")
        buf.write("\u012b\7\5\2\2\u012a\u012c\5:\36\2\u012b\u012a\3\2\2\2")
        buf.write("\u012c\u012d\3\2\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3")
        buf.write("\2\2\2\u012e\u012f\3\2\2\2\u012f\u0130\7\6\2\2\u01309")
        buf.write("\3\2\2\2\u0131\u0132\5\66\34\2\u0132\u0133\7\7\2\2\u0133")
        buf.write("\u0135\5> \2\u0134\u0136\5<\37\2\u0135\u0134\3\2\2\2\u0135")
        buf.write("\u0136\3\2\2\2\u0136;\3\2\2\2\u0137\u0138\7\f\2\2\u0138")
        buf.write("\u0139\5\"\22\2\u0139=\3\2\2\2\u013a\u013c\5@!\2\u013b")
        buf.write("\u013d\7\r\2\2\u013c\u013b\3\2\2\2\u013c\u013d\3\2\2\2")
        buf.write("\u013d\u0143\3\2\2\2\u013e\u0140\5B\"\2\u013f\u0141\7")
        buf.write("\r\2\2\u0140\u013f\3\2\2\2\u0140\u0141\3\2\2\2\u0141\u0143")
        buf.write("\3\2\2\2\u0142\u013a\3\2\2\2\u0142\u013e\3\2\2\2\u0143")
        buf.write("?\3\2\2\2\u0144\u0145\5\u008eH\2\u0145A\3\2\2\2\u0146")
        buf.write("\u0147\7\t\2\2\u0147\u0148\5> \2\u0148\u0149\7\n\2\2\u0149")
        buf.write("C\3\2\2\2\u014a\u014c\5F$\2\u014b\u014a\3\2\2\2\u014c")
        buf.write("\u014d\3\2\2\2\u014d\u014b\3\2\2\2\u014d\u014e\3\2\2\2")
        buf.write("\u014eE\3\2\2\2\u014f\u0150\7\16\2\2\u0150\u0152\5\u008e")
        buf.write("H\2\u0151\u0153\5\22\n\2\u0152\u0151\3\2\2\2\u0152\u0153")
        buf.write("\3\2\2\2\u0153G\3\2\2\2\u0154\u0158\5L\'\2\u0155\u0158")
        buf.write("\5V,\2\u0156\u0158\5\u0084C\2\u0157\u0154\3\2\2\2\u0157")
        buf.write("\u0155\3\2\2\2\u0157\u0156\3\2\2\2\u0158I\3\2\2\2\u0159")
        buf.write("\u015c\5P)\2\u015a\u015c\5X-\2\u015b\u0159\3\2\2\2\u015b")
        buf.write("\u015a\3\2\2\2\u015cK\3\2\2\2\u015d\u015f\7/\2\2\u015e")
        buf.write("\u0160\5D#\2\u015f\u015e\3\2\2\2\u015f\u0160\3\2\2\2\u0160")
        buf.write("\u0161\3\2\2\2\u0161\u0163\7\3\2\2\u0162\u0164\5N(\2\u0163")
        buf.write("\u0162\3\2\2\2\u0164\u0165\3\2\2\2\u0165\u0163\3\2\2\2")
        buf.write("\u0165\u0166\3\2\2\2\u0166\u0167\3\2\2\2\u0167\u0168\7")
        buf.write("\4\2\2\u0168M\3\2\2\2\u0169\u016a\5\n\6\2\u016a\u016b")
        buf.write("\7\7\2\2\u016b\u016c\5@!\2\u016cO\3\2\2\2\u016d\u016e")
        buf.write("\7\26\2\2\u016e\u0170\7/\2\2\u016f\u0171\5D#\2\u0170\u016f")
        buf.write("\3\2\2\2\u0170\u0171\3\2\2\2\u0171\u0172\3\2\2\2\u0172")
        buf.write("\u0174\7\3\2\2\u0173\u0175\5R*\2\u0174\u0173\3\2\2\2\u0175")
        buf.write("\u0176\3\2\2\2\u0176\u0174\3\2\2\2\u0176\u0177\3\2\2\2")
        buf.write("\u0177\u0178\3\2\2\2\u0178\u0179\7\4\2\2\u0179\u017e\3")
        buf.write("\2\2\2\u017a\u017b\7\26\2\2\u017b\u017c\7/\2\2\u017c\u017e")
        buf.write("\5D#\2\u017d\u016d\3\2\2\2\u017d\u017a\3\2\2\2\u017eQ")
        buf.write("\3\2\2\2\u017f\u0180\5\n\6\2\u0180\u0181\7\7\2\2\u0181")
        buf.write("\u0182\5@!\2\u0182S\3\2\2\2\u0183\u0184\5*\26\2\u0184")
        buf.write("U\3\2\2\2\u0185\u018c\5Z.\2\u0186\u018c\5^\60\2\u0187")
        buf.write("\u018c\5l\67\2\u0188\u018c\5p9\2\u0189\u018c\5v<\2\u018a")
        buf.write("\u018c\5~@\2\u018b\u0185\3\2\2\2\u018b\u0186\3\2\2\2\u018b")
        buf.write("\u0187\3\2\2\2\u018b\u0188\3\2\2\2\u018b\u0189\3\2\2\2")
        buf.write("\u018b\u018a\3\2\2\2\u018cW\3\2\2\2\u018d\u0194\5\\/\2")
        buf.write("\u018e\u0194\5j\66\2\u018f\u0194\5n8\2\u0190\u0194\5t")
        buf.write(";\2\u0191\u0194\5|?\2\u0192\u0194\5\u0082B\2\u0193\u018d")
        buf.write("\3\2\2\2\u0193\u018e\3\2\2\2\u0193\u018f\3\2\2\2\u0193")
        buf.write("\u0190\3\2\2\2\u0193\u0191\3\2\2\2\u0193\u0192\3\2\2\2")
        buf.write("\u0194Y\3\2\2\2\u0195\u0197\5T+\2\u0196\u0195\3\2\2\2")
        buf.write("\u0196\u0197\3\2\2\2\u0197\u0198\3\2\2\2\u0198\u0199\7")
        buf.write("-\2\2\u0199\u019b\5\u008eH\2\u019a\u019c\5D#\2\u019b\u019a")
        buf.write("\3\2\2\2\u019b\u019c\3\2\2\2\u019c[\3\2\2\2\u019d\u019e")
        buf.write("\7\27\2\2\u019e\u019f\7-\2\2\u019f\u01a0\5\u008eH\2\u01a0")
        buf.write("\u01a1\5D#\2\u01a1]\3\2\2\2\u01a2\u01a4\5T+\2\u01a3\u01a2")
        buf.write("\3\2\2\2\u01a3\u01a4\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5")
        buf.write("\u01a6\7\63\2\2\u01a6\u01a8\5\u008eH\2\u01a7\u01a9\5`")
        buf.write("\61\2\u01a8\u01a7\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01ab")
        buf.write("\3\2\2\2\u01aa\u01ac\5D#\2\u01ab\u01aa\3\2\2\2\u01ab\u01ac")
        buf.write("\3\2\2\2\u01ac\u01ae\3\2\2\2\u01ad\u01af\5b\62\2\u01ae")
        buf.write("\u01ad\3\2\2\2\u01ae\u01af\3\2\2\2\u01af_\3\2\2\2\u01b0")
        buf.write("\u01b1\b\61\1\2\u01b1\u01b3\7\36\2\2\u01b2\u01b4\7\17")
        buf.write("\2\2\u01b3\u01b2\3\2\2\2\u01b3\u01b4\3\2\2\2\u01b4\u01b5")
        buf.write("\3\2\2\2\u01b5\u01b6\5@!\2\u01b6\u01bc\3\2\2\2\u01b7\u01b8")
        buf.write("\f\3\2\2\u01b8\u01b9\7\17\2\2\u01b9\u01bb\5@!\2\u01ba")
        buf.write("\u01b7\3\2\2\2\u01bb\u01be\3\2\2\2\u01bc\u01ba\3\2\2\2")
        buf.write("\u01bc\u01bd\3\2\2\2\u01bda\3\2\2\2\u01be\u01bc\3\2\2")
        buf.write("\2\u01bf\u01c1\7\3\2\2\u01c0\u01c2\5d\63\2\u01c1\u01c0")
        buf.write("\3\2\2\2\u01c2\u01c3\3\2\2\2\u01c3\u01c1\3\2\2\2\u01c3")
        buf.write("\u01c4\3\2\2\2\u01c4\u01c5\3\2\2\2\u01c5\u01c6\7\4\2\2")
        buf.write("\u01c6c\3\2\2\2\u01c7\u01c9\5T+\2\u01c8\u01c7\3\2\2\2")
        buf.write("\u01c8\u01c9\3\2\2\2\u01c9\u01ca\3\2\2\2\u01ca\u01cc\5")
        buf.write("\u008eH\2\u01cb\u01cd\5f\64\2\u01cc\u01cb\3\2\2\2\u01cc")
        buf.write("\u01cd\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce\u01cf\7\7\2\2")
        buf.write("\u01cf\u01d1\5> \2\u01d0\u01d2\5D#\2\u01d1\u01d0\3\2\2")
        buf.write("\2\u01d1\u01d2\3\2\2\2\u01d2e\3\2\2\2\u01d3\u01d5\7\5")
        buf.write("\2\2\u01d4\u01d6\5h\65\2\u01d5\u01d4\3\2\2\2\u01d6\u01d7")
        buf.write("\3\2\2\2\u01d7\u01d5\3\2\2\2\u01d7\u01d8\3\2\2\2\u01d8")
        buf.write("\u01d9\3\2\2\2\u01d9\u01da\7\6\2\2\u01dag\3\2\2\2\u01db")
        buf.write("\u01dd\5T+\2\u01dc\u01db\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd")
        buf.write("\u01de\3\2\2\2\u01de\u01df\5\u008eH\2\u01df\u01e0\7\7")
        buf.write("\2\2\u01e0\u01e2\5> \2\u01e1\u01e3\5<\37\2\u01e2\u01e1")
        buf.write("\3\2\2\2\u01e2\u01e3\3\2\2\2\u01e3\u01e5\3\2\2\2\u01e4")
        buf.write("\u01e6\5D#\2\u01e5\u01e4\3\2\2\2\u01e5\u01e6\3\2\2\2\u01e6")
        buf.write("i\3\2\2\2\u01e7\u01e8\7\26\2\2\u01e8\u01e9\7\63\2\2\u01e9")
        buf.write("\u01eb\5\u008eH\2\u01ea\u01ec\5`\61\2\u01eb\u01ea\3\2")
        buf.write("\2\2\u01eb\u01ec\3\2\2\2\u01ec\u01ee\3\2\2\2\u01ed\u01ef")
        buf.write("\5D#\2\u01ee\u01ed\3\2\2\2\u01ee\u01ef\3\2\2\2\u01ef\u01f0")
        buf.write("\3\2\2\2\u01f0\u01f1\5b\62\2\u01f1\u0200\3\2\2\2\u01f2")
        buf.write("\u01f3\7\26\2\2\u01f3\u01f4\7\63\2\2\u01f4\u01f6\5\u008e")
        buf.write("H\2\u01f5\u01f7\5`\61\2\u01f6\u01f5\3\2\2\2\u01f6\u01f7")
        buf.write("\3\2\2\2\u01f7\u01f8\3\2\2\2\u01f8\u01f9\5D#\2\u01f9\u0200")
        buf.write("\3\2\2\2\u01fa\u01fb\7\26\2\2\u01fb\u01fc\7\63\2\2\u01fc")
        buf.write("\u01fd\5\u008eH\2\u01fd\u01fe\5`\61\2\u01fe\u0200\3\2")
        buf.write("\2\2\u01ff\u01e7\3\2\2\2\u01ff\u01f2\3\2\2\2\u01ff\u01fa")
        buf.write("\3\2\2\2\u0200k\3\2\2\2\u0201\u0203\5T+\2\u0202\u0201")
        buf.write("\3\2\2\2\u0202\u0203\3\2\2\2\u0203\u0204\3\2\2\2\u0204")
        buf.write("\u0205\7$\2\2\u0205\u0207\5\u008eH\2\u0206\u0208\5D#\2")
        buf.write("\u0207\u0206\3\2\2\2\u0207\u0208\3\2\2\2\u0208\u020a\3")
        buf.write("\2\2\2\u0209\u020b\5b\62\2\u020a\u0209\3\2\2\2\u020a\u020b")
        buf.write("\3\2\2\2\u020bm\3\2\2\2\u020c\u020d\7\26\2\2\u020d\u020e")
        buf.write("\7$\2\2\u020e\u0210\5\u008eH\2\u020f\u0211\5D#\2\u0210")
        buf.write("\u020f\3\2\2\2\u0210\u0211\3\2\2\2\u0211\u0212\3\2\2\2")
        buf.write("\u0212\u0213\5b\62\2\u0213\u021a\3\2\2\2\u0214\u0215\7")
        buf.write("\26\2\2\u0215\u0216\7$\2\2\u0216\u0217\5\u008eH\2\u0217")
        buf.write("\u0218\5D#\2\u0218\u021a\3\2\2\2\u0219\u020c\3\2\2\2\u0219")
        buf.write("\u0214\3\2\2\2\u021ao\3\2\2\2\u021b\u021d\5T+\2\u021c")
        buf.write("\u021b\3\2\2\2\u021c\u021d\3\2\2\2\u021d\u021e\3\2\2\2")
        buf.write("\u021e\u021f\7\65\2\2\u021f\u0221\5\u008eH\2\u0220\u0222")
        buf.write("\5D#\2\u0221\u0220\3\2\2\2\u0221\u0222\3\2\2\2\u0222\u0224")
        buf.write("\3\2\2\2\u0223\u0225\5r:\2\u0224\u0223\3\2\2\2\u0224\u0225")
        buf.write("\3\2\2\2\u0225q\3\2\2\2\u0226\u0228\7\f\2\2\u0227\u0229")
        buf.write("\7\20\2\2\u0228\u0227\3\2\2\2\u0228\u0229\3\2\2\2\u0229")
        buf.write("\u022a\3\2\2\2\u022a\u022f\5@!\2\u022b\u022c\7\20\2\2")
        buf.write("\u022c\u022e\5@!\2\u022d\u022b\3\2\2\2\u022e\u0231\3\2")
        buf.write("\2\2\u022f\u022d\3\2\2\2\u022f\u0230\3\2\2\2\u0230s\3")
        buf.write("\2\2\2\u0231\u022f\3\2\2\2\u0232\u0233\7\26\2\2\u0233")
        buf.write("\u0234\7\65\2\2\u0234\u0236\5\u008eH\2\u0235\u0237\5D")
        buf.write("#\2\u0236\u0235\3\2\2\2\u0236\u0237\3\2\2\2\u0237\u0238")
        buf.write("\3\2\2\2\u0238\u0239\5r:\2\u0239\u0240\3\2\2\2\u023a\u023b")
        buf.write("\7\26\2\2\u023b\u023c\7\65\2\2\u023c\u023d\5\u008eH\2")
        buf.write("\u023d\u023e\5D#\2\u023e\u0240\3\2\2\2\u023f\u0232\3\2")
        buf.write("\2\2\u023f\u023a\3\2\2\2\u0240u\3\2\2\2\u0241\u0243\5")
        buf.write("T+\2\u0242\u0241\3\2\2\2\u0242\u0243\3\2\2\2\u0243\u0244")
        buf.write("\3\2\2\2\u0244\u0245\7\24\2\2\u0245\u0247\5\u008eH\2\u0246")
        buf.write("\u0248\5D#\2\u0247\u0246\3\2\2\2\u0247\u0248\3\2\2\2\u0248")
        buf.write("\u024a\3\2\2\2\u0249\u024b\5x=\2\u024a\u0249\3\2\2\2\u024a")
        buf.write("\u024b\3\2\2\2\u024bw\3\2\2\2\u024c\u024e\7\3\2\2\u024d")
        buf.write("\u024f\5z>\2\u024e\u024d\3\2\2\2\u024f\u0250\3\2\2\2\u0250")
        buf.write("\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251\u0252\3\2\2\2")
        buf.write("\u0252\u0253\7\4\2\2\u0253y\3\2\2\2\u0254\u0256\5T+\2")
        buf.write("\u0255\u0254\3\2\2\2\u0255\u0256\3\2\2\2\u0256\u0257\3")
        buf.write("\2\2\2\u0257\u0259\5.\30\2\u0258\u025a\5D#\2\u0259\u0258")
        buf.write("\3\2\2\2\u0259\u025a\3\2\2\2\u025a{\3\2\2\2\u025b\u025c")
        buf.write("\7\26\2\2\u025c\u025d\7\24\2\2\u025d\u025f\5\u008eH\2")
        buf.write("\u025e\u0260\5D#\2\u025f\u025e\3\2\2\2\u025f\u0260\3\2")
        buf.write("\2\2\u0260\u0261\3\2\2\2\u0261\u0262\5x=\2\u0262\u0269")
        buf.write("\3\2\2\2\u0263\u0264\7\26\2\2\u0264\u0265\7\24\2\2\u0265")
        buf.write("\u0266\5\u008eH\2\u0266\u0267\5D#\2\u0267\u0269\3\2\2")
        buf.write("\2\u0268\u025b\3\2\2\2\u0268\u0263\3\2\2\2\u0269}\3\2")
        buf.write("\2\2\u026a\u026c\5T+\2\u026b\u026a\3\2\2\2\u026b\u026c")
        buf.write("\3\2\2\2\u026c\u026d\3\2\2\2\u026d\u026e\7 \2\2\u026e")
        buf.write("\u0270\5\u008eH\2\u026f\u0271\5D#\2\u0270\u026f\3\2\2")
        buf.write("\2\u0270\u0271\3\2\2\2\u0271\u0273\3\2\2\2\u0272\u0274")
        buf.write("\5\u0080A\2\u0273\u0272\3\2\2\2\u0273\u0274\3\2\2\2\u0274")
        buf.write("\177\3\2\2\2\u0275\u0277\7\3\2\2\u0276\u0278\5h\65\2\u0277")
        buf.write("\u0276\3\2\2\2\u0278\u0279\3\2\2\2\u0279\u0277\3\2\2\2")
        buf.write("\u0279\u027a\3\2\2\2\u027a\u027b\3\2\2\2\u027b\u027c\7")
        buf.write("\4\2\2\u027c\u0081\3\2\2\2\u027d\u027e\7\26\2\2\u027e")
        buf.write("\u027f\7 \2\2\u027f\u0281\5\u008eH\2\u0280\u0282\5D#\2")
        buf.write("\u0281\u0280\3\2\2\2\u0281\u0282\3\2\2\2\u0282\u0283\3")
        buf.write("\2\2\2\u0283\u0284\5\u0080A\2\u0284\u028b\3\2\2\2\u0285")
        buf.write("\u0286\7\26\2\2\u0286\u0287\7 \2\2\u0287\u0288\5\u008e")
        buf.write("H\2\u0288\u0289\5D#\2\u0289\u028b\3\2\2\2\u028a\u027d")
        buf.write("\3\2\2\2\u028a\u0285\3\2\2\2\u028b\u0083\3\2\2\2\u028c")
        buf.write("\u028e\5T+\2\u028d\u028c\3\2\2\2\u028d\u028e\3\2\2\2\u028e")
        buf.write("\u028f\3\2\2\2\u028f\u0290\7\22\2\2\u0290\u0291\7\16\2")
        buf.write("\2\u0291\u0293\5\u008eH\2\u0292\u0294\5f\64\2\u0293\u0292")
        buf.write("\3\2\2\2\u0293\u0294\3\2\2\2\u0294\u0295\3\2\2\2\u0295")
        buf.write("\u0296\7)\2\2\u0296\u0297\5\u0086D\2\u0297\u0085\3\2\2")
        buf.write("\2\u0298\u029d\5\u0088E\2\u0299\u029a\7\20\2\2\u029a\u029c")
        buf.write("\5\u0088E\2\u029b\u0299\3\2\2\2\u029c\u029f\3\2\2\2\u029d")
        buf.write("\u029b\3\2\2\2\u029d\u029e\3\2\2\2\u029e\u0087\3\2\2\2")
        buf.write("\u029f\u029d\3\2\2\2\u02a0\u02a3\5\u008aF\2\u02a1\u02a3")
        buf.write("\5\u008cG\2\u02a2\u02a0\3\2\2\2\u02a2\u02a1\3\2\2\2\u02a3")
        buf.write("\u0089\3\2\2\2\u02a4\u02a5\t\5\2\2\u02a5\u008b\3\2\2\2")
        buf.write("\u02a6\u02a7\t\6\2\2\u02a7\u008d\3\2\2\2\u02a8\u02a9\t")
        buf.write("\7\2\2\u02a9\u008f\3\2\2\2[\u0093\u0098\u009c\u00a0\u00a3")
        buf.write("\u00a6\u00ab\u00b3\u00ba\u00bd\u00c1\u00c4\u00c7\u00cd")
        buf.write("\u00db\u00e1\u00ec\u00ef\u00fc\u0110\u0114\u011c\u0120")
        buf.write("\u012d\u0135\u013c\u0140\u0142\u014d\u0152\u0157\u015b")
        buf.write("\u015f\u0165\u0170\u0176\u017d\u018b\u0193\u0196\u019b")
        buf.write("\u01a3\u01a8\u01ab\u01ae\u01b3\u01bc\u01c3\u01c8\u01cc")
        buf.write("\u01d1\u01d7\u01dc\u01e2\u01e5\u01eb\u01ee\u01f6\u01ff")
        buf.write("\u0202\u0207\u020a\u0210\u0219\u021c\u0221\u0224\u0228")
        buf.write("\u022f\u0236\u023f\u0242\u0247\u024a\u0250\u0255\u0259")
        buf.write("\u025f\u0268\u026b\u0270\u0273\u0279\u0281\u028a\u028d")
        buf.write("\u0293\u029d\u02a2")
        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>", "'{'", "'}'", "'('", "')'", "':'", "'...'", 
                     "'['", "']'", "'$'", "'='", "'!'", "'@'", "'&'", "'|'", 
                     "'ARGUMENT_DEFINITION'", "'directive'", "'ENUM'", "'enum'", 
                     "'ENUM_VALUE'", "'extend'", "'extends'", "'false'", 
                     "'FIELD'", "'FIELD_DEFINITION'", "'fragment'", "'FRAGMENT_DEFINITION'", 
                     "'FRAGMENT_SPREAD'", "'implements'", "'INLINE_FRAGMENT'", 
                     "'input'", "'INPUT_FIELD_DEFINITION'", "'INPUT_OBJECT'", 
                     "'INTERFACE'", "'interface'", "'MUTATION'", "'mutation'", 
                     "'null'", "'OBJECT'", "'on'", "'QUERY'", "'query'", 
                     "'SCALAR'", "'scalar'", "'SCHEMA'", "'schema'", "'SUBSCRIPTION'", 
                     "'subscription'", "'true'", "'type'", "'UNION'", "'union'", 
                     "<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>", "ARGUMENT_DEFINITION", 
                      "DIRECTIVE_", "ENUM", "ENUM_", "ENUM_VALUE", "EXTEND_", 
                      "EXTENDS_", "FALSE_", "FIELD", "FIELD_DEFINITION", 
                      "FRAGMENT_", "FRAGMENT_DEFINITION", "FRAGMENT_SPREAD", 
                      "IMPLEMENTS_", "INLINE_FRAGMENT", "INPUT_", "INPUT_FIELD_DEFINITION", 
                      "INPUT_OBJECT", "INTERFACE", "INTERFACE_", "MUTATION", 
                      "MUTATION_", "NULL_", "OBJECT", "ON_", "QUERY", "QUERY_", 
                      "SCALAR", "SCALAR_", "SCHEMA", "SCHEMA_", "SUBSCRIPTION", 
                      "SUBSCRIPTION_", "TRUE_", "TYPE_", "UNION", "UNION_", 
                      "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
    ARGUMENT_DEFINITION=15
    DIRECTIVE_=16
    ENUM=17
    ENUM_=18
    ENUM_VALUE=19
    EXTEND_=20
    EXTENDS_=21
    FALSE_=22
    FIELD=23
    FIELD_DEFINITION=24
    FRAGMENT_=25
    FRAGMENT_DEFINITION=26
    FRAGMENT_SPREAD=27
    IMPLEMENTS_=28
    INLINE_FRAGMENT=29
    INPUT_=30
    INPUT_FIELD_DEFINITION=31
    INPUT_OBJECT=32
    INTERFACE=33
    INTERFACE_=34
    MUTATION=35
    MUTATION_=36
    NULL_=37
    OBJECT=38
    ON_=39
    QUERY=40
    QUERY_=41
    SCALAR=42
    SCALAR_=43
    SCHEMA=44
    SCHEMA_=45
    SUBSCRIPTION=46
    SUBSCRIPTION_=47
    TRUE_=48
    TYPE_=49
    UNION=50
    UNION_=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.8")
        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDocument" ):
                return visitor.visitDocument(self)
            else:
                return visitor.visitChildren(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.DIRECTIVE_) | (1 << GraphqlParser.ENUM_) | (1 << GraphqlParser.EXTEND_) | (1 << GraphqlParser.EXTENDS_) | (1 << GraphqlParser.FRAGMENT_) | (1 << GraphqlParser.INPUT_) | (1 << GraphqlParser.INTERFACE_) | (1 << GraphqlParser.MUTATION_) | (1 << GraphqlParser.QUERY_) | (1 << GraphqlParser.SCALAR_) | (1 << GraphqlParser.SCHEMA_) | (1 << GraphqlParser.SUBSCRIPTION_) | (1 << GraphqlParser.TYPE_) | (1 << GraphqlParser.UNION_) | (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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDefinition" ):
                return visitor.visitDefinition(self)
            else:
                return visitor.visitChildren(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.FRAGMENT_, GraphqlParser.MUTATION_, GraphqlParser.QUERY_, GraphqlParser.SUBSCRIPTION_]:
                self.enterOuterAlt(localctx, 1)
                self.state = 147
                self.executableDefinition()
                pass
            elif token in [GraphqlParser.DIRECTIVE_, GraphqlParser.ENUM_, GraphqlParser.INPUT_, GraphqlParser.INTERFACE_, GraphqlParser.SCALAR_, GraphqlParser.SCHEMA_, GraphqlParser.TYPE_, GraphqlParser.UNION_, GraphqlParser.STRING, GraphqlParser.BLOCK_STRING]:
                self.enterOuterAlt(localctx, 2)
                self.state = 148
                self.typeSystemDefinition()
                pass
            elif token in [GraphqlParser.EXTEND_, GraphqlParser.EXTENDS_]:
                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExecutableDefinition" ):
                return visitor.visitExecutableDefinition(self)
            else:
                return visitor.visitChildren(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.MUTATION_, GraphqlParser.QUERY_, GraphqlParser.SUBSCRIPTION_]:
                self.enterOuterAlt(localctx, 1)
                self.state = 152
                self.operationDefinition()
                pass
            elif token in [GraphqlParser.FRAGMENT_]:
                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOperationDefinition" ):
                return visitor.visitOperationDefinition(self)
            else:
                return visitor.visitChildren(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.MUTATION_, GraphqlParser.QUERY_, GraphqlParser.SUBSCRIPTION_]:
                self.enterOuterAlt(localctx, 1)
                self.state = 156
                self.operationType()
                self.state = 158
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphqlParser.ARGUMENT_DEFINITION) | (1 << GraphqlParser.DIRECTIVE_) | (1 << GraphqlParser.ENUM) | (1 << GraphqlParser.ENUM_) | (1 << GraphqlParser.ENUM_VALUE) | (1 << GraphqlParser.EXTEND_) | (1 << GraphqlParser.EXTENDS_) | (1 << GraphqlParser.FALSE_) | (1 << GraphqlParser.FIELD) | (1 << GraphqlParser.FIELD_DEFINITION) | (1 << GraphqlParser.FRAGMENT_) | (1 << GraphqlParser.FRAGMENT_DEFINITION) | (1 << GraphqlParser.FRAGMENT_SPREAD) | (1 << GraphqlParser.IMPLEMENTS_) | (1 << GraphqlParser.INLINE_FRAGMENT) | (1 << GraphqlParser.INPUT_) | (1 << GraphqlParser.INPUT_FIELD_DEFINITION) | (1 << GraphqlParser.INPUT_OBJECT) | (1 << GraphqlParser.INTERFACE) | (1 << GraphqlParser.INTERFACE_) | (1 << GraphqlParser.MUTATION) | (1 << GraphqlParser.MUTATION_) | (1 << GraphqlParser.NULL_) | (1 << GraphqlParser.OBJECT) | (1 << GraphqlParser.ON_) | (1 << GraphqlParser.QUERY) | (1 << GraphqlParser.QUERY_) | (1 << GraphqlParser.SCALAR) | (1 << GraphqlParser.SCALAR_) | (1 << GraphqlParser.SCHEMA) | (1 << GraphqlParser.SCHEMA_) | (1 << GraphqlParser.SUBSCRIPTION) | (1 << GraphqlParser.SUBSCRIPTION_) | (1 << GraphqlParser.TRUE_) | (1 << GraphqlParser.TYPE_) | (1 << GraphqlParser.UNION) | (1 << GraphqlParser.UNION_) | (1 << GraphqlParser.NAME))) != 0):
                    self.state = 157
                    self.name()


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


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


                self.state = 166
                self.selectionSet()
                pass
            elif token in [GraphqlParser.T__0]:
                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 QUERY_(self):
            return self.getToken(GraphqlParser.QUERY_, 0)

        def MUTATION_(self):
            return self.getToken(GraphqlParser.MUTATION_, 0)

        def SUBSCRIPTION_(self):
            return self.getToken(GraphqlParser.SUBSCRIPTION_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOperationType" ):
                return visitor.visitOperationType(self)
            else:
                return visitor.visitChildren(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.MUTATION_) | (1 << GraphqlParser.QUERY_) | (1 << GraphqlParser.SUBSCRIPTION_))) != 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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSelectionSet" ):
                return visitor.visitSelectionSet(self)
            else:
                return visitor.visitChildren(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__0)
            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) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphqlParser.T__5) | (1 << GraphqlParser.ARGUMENT_DEFINITION) | (1 << GraphqlParser.DIRECTIVE_) | (1 << GraphqlParser.ENUM) | (1 << GraphqlParser.ENUM_) | (1 << GraphqlParser.ENUM_VALUE) | (1 << GraphqlParser.EXTEND_) | (1 << GraphqlParser.EXTENDS_) | (1 << GraphqlParser.FALSE_) | (1 << GraphqlParser.FIELD) | (1 << GraphqlParser.FIELD_DEFINITION) | (1 << GraphqlParser.FRAGMENT_) | (1 << GraphqlParser.FRAGMENT_DEFINITION) | (1 << GraphqlParser.FRAGMENT_SPREAD) | (1 << GraphqlParser.IMPLEMENTS_) | (1 << GraphqlParser.INLINE_FRAGMENT) | (1 << GraphqlParser.INPUT_) | (1 << GraphqlParser.INPUT_FIELD_DEFINITION) | (1 << GraphqlParser.INPUT_OBJECT) | (1 << GraphqlParser.INTERFACE) | (1 << GraphqlParser.INTERFACE_) | (1 << GraphqlParser.MUTATION) | (1 << GraphqlParser.MUTATION_) | (1 << GraphqlParser.NULL_) | (1 << GraphqlParser.OBJECT) | (1 << GraphqlParser.ON_) | (1 << GraphqlParser.QUERY) | (1 << GraphqlParser.QUERY_) | (1 << GraphqlParser.SCALAR) | (1 << GraphqlParser.SCALAR_) | (1 << GraphqlParser.SCHEMA) | (1 << GraphqlParser.SCHEMA_) | (1 << GraphqlParser.SUBSCRIPTION) | (1 << GraphqlParser.SUBSCRIPTION_) | (1 << GraphqlParser.TRUE_) | (1 << GraphqlParser.TYPE_) | (1 << GraphqlParser.UNION) | (1 << GraphqlParser.UNION_) | (1 << GraphqlParser.NAME))) != 0)):
                    break

            self.state = 179
            self.match(GraphqlParser.T__1)
        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSelection" ):
                return visitor.visitSelection(self)
            else:
                return visitor.visitChildren(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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitField" ):
                return visitor.visitField(self)
            else:
                return visitor.visitChildren(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__2:
                self.state = 190
                self.arguments()


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


            self.state = 197
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__0:
                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArguments" ):
                return visitor.visitArguments(self)
            else:
                return visitor.visitChildren(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__2)
            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) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphqlParser.ARGUMENT_DEFINITION) | (1 << GraphqlParser.DIRECTIVE_) | (1 << GraphqlParser.ENUM) | (1 << GraphqlParser.ENUM_) | (1 << GraphqlParser.ENUM_VALUE) | (1 << GraphqlParser.EXTEND_) | (1 << GraphqlParser.EXTENDS_) | (1 << GraphqlParser.FALSE_) | (1 << GraphqlParser.FIELD) | (1 << GraphqlParser.FIELD_DEFINITION) | (1 << GraphqlParser.FRAGMENT_) | (1 << GraphqlParser.FRAGMENT_DEFINITION) | (1 << GraphqlParser.FRAGMENT_SPREAD) | (1 << GraphqlParser.IMPLEMENTS_) | (1 << GraphqlParser.INLINE_FRAGMENT) | (1 << GraphqlParser.INPUT_) | (1 << GraphqlParser.INPUT_FIELD_DEFINITION) | (1 << GraphqlParser.INPUT_OBJECT) | (1 << GraphqlParser.INTERFACE) | (1 << GraphqlParser.INTERFACE_) | (1 << GraphqlParser.MUTATION) | (1 << GraphqlParser.MUTATION_) | (1 << GraphqlParser.NULL_) | (1 << GraphqlParser.OBJECT) | (1 << GraphqlParser.ON_) | (1 << GraphqlParser.QUERY) | (1 << GraphqlParser.QUERY_) | (1 << GraphqlParser.SCALAR) | (1 << GraphqlParser.SCALAR_) | (1 << GraphqlParser.SCHEMA) | (1 << GraphqlParser.SCHEMA_) | (1 << GraphqlParser.SUBSCRIPTION) | (1 << GraphqlParser.SUBSCRIPTION_) | (1 << GraphqlParser.TRUE_) | (1 << GraphqlParser.TYPE_) | (1 << GraphqlParser.UNION) | (1 << GraphqlParser.UNION_) | (1 << GraphqlParser.NAME))) != 0)):
                    break

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


    class 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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArgument" ):
                return visitor.visitArgument(self)
            else:
                return visitor.visitChildren(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__4)
            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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAlias" ):
                return visitor.visitAlias(self)
            else:
                return visitor.visitChildren(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__4)
        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFragmentSpread" ):
                return visitor.visitFragmentSpread(self)
            else:
                return visitor.visitChildren(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__5)
            self.state = 215
            self.fragmentName()
            self.state = 217
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__11:
                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 FRAGMENT_(self):
            return self.getToken(GraphqlParser.FRAGMENT_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFragmentDefinition" ):
                return visitor.visitFragmentDefinition(self)
            else:
                return visitor.visitChildren(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.FRAGMENT_)
            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__11:
                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFragmentName" ):
                return visitor.visitFragmentName(self)
            else:
                return visitor.visitChildren(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 ON_(self):
            return self.getToken(GraphqlParser.ON_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeCondition" ):
                return visitor.visitTypeCondition(self)
            else:
                return visitor.visitChildren(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.ON_)
            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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInlineFragment" ):
                return visitor.visitInlineFragment(self)
            else:
                return visitor.visitChildren(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__5)
            self.state = 234
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.ON_:
                self.state = 233
                self.typeCondition()


            self.state = 237
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__11:
                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitValue" ):
                return visitor.visitValue(self)
            else:
                return visitor.visitChildren(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)
            la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 241
                self.variable()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 242
                self.intValue()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 243
                self.floatValue()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 244
                self.stringValue()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 245
                self.booleanValue()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 246
                self.nullValue()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 247
                self.enumValue()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 248
                self.listValue()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 249
                self.objectValue()
                pass


        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIntValue" ):
                return visitor.visitIntValue(self)
            else:
                return visitor.visitChildren(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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFloatValue" ):
                return visitor.visitFloatValue(self)
            else:
                return visitor.visitChildren(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 TRUE_(self):
            return self.getToken(GraphqlParser.TRUE_, 0)

        def FALSE_(self):
            return self.getToken(GraphqlParser.FALSE_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBooleanValue" ):
                return visitor.visitBooleanValue(self)
            else:
                return visitor.visitChildren(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.FALSE_ or _la==GraphqlParser.TRUE_):
                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStringValue" ):
                return visitor.visitStringValue(self)
            else:
                return visitor.visitChildren(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 NULL_(self):
            return self.getToken(GraphqlParser.NULL_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNullValue" ):
                return visitor.visitNullValue(self)
            else:
                return visitor.visitChildren(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.NULL_)
        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumValue" ):
                return visitor.visitEnumValue(self)
            else:
                return visitor.visitChildren(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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitListValue" ):
                return visitor.visitListValue(self)
            else:
                return visitor.visitChildren(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__6)
                self.state = 265
                self.match(GraphqlParser.T__7)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 266
                self.match(GraphqlParser.T__6)
                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__0) | (1 << GraphqlParser.T__6) | (1 << GraphqlParser.T__8) | (1 << GraphqlParser.ARGUMENT_DEFINITION) | (1 << GraphqlParser.DIRECTIVE_) | (1 << GraphqlParser.ENUM) | (1 << GraphqlParser.ENUM_) | (1 << GraphqlParser.ENUM_VALUE) | (1 << GraphqlParser.EXTEND_) | (1 << GraphqlParser.EXTENDS_) | (1 << GraphqlParser.FALSE_) | (1 << GraphqlParser.FIELD) | (1 << GraphqlParser.FIELD_DEFINITION) | (1 << GraphqlParser.FRAGMENT_) | (1 << GraphqlParser.FRAGMENT_DEFINITION) | (1 << GraphqlParser.FRAGMENT_SPREAD) | (1 << GraphqlParser.IMPLEMENTS_) | (1 << GraphqlParser.INLINE_FRAGMENT) | (1 << GraphqlParser.INPUT_) | (1 << GraphqlParser.INPUT_FIELD_DEFINITION) | (1 << GraphqlParser.INPUT_OBJECT) | (1 << GraphqlParser.INTERFACE) | (1 << GraphqlParser.INTERFACE_) | (1 << GraphqlParser.MUTATION) | (1 << GraphqlParser.MUTATION_) | (1 << GraphqlParser.NULL_) | (1 << GraphqlParser.OBJECT) | (1 << GraphqlParser.ON_) | (1 << GraphqlParser.QUERY) | (1 << GraphqlParser.QUERY_) | (1 << GraphqlParser.SCALAR) | (1 << GraphqlParser.SCALAR_) | (1 << GraphqlParser.SCHEMA) | (1 << GraphqlParser.SCHEMA_) | (1 << GraphqlParser.SUBSCRIPTION) | (1 << GraphqlParser.SUBSCRIPTION_) | (1 << GraphqlParser.TRUE_) | (1 << GraphqlParser.TYPE_) | (1 << GraphqlParser.UNION) | (1 << GraphqlParser.UNION_) | (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__7)
                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitObjectValue" ):
                return visitor.visitObjectValue(self)
            else:
                return visitor.visitChildren(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.state = 286
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 276
                self.match(GraphqlParser.T__0)
                self.state = 277
                self.match(GraphqlParser.T__1)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 278
                self.match(GraphqlParser.T__0)
                self.state = 282
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphqlParser.ARGUMENT_DEFINITION) | (1 << GraphqlParser.DIRECTIVE_) | (1 << GraphqlParser.ENUM) | (1 << GraphqlParser.ENUM_) | (1 << GraphqlParser.ENUM_VALUE) | (1 << GraphqlParser.EXTEND_) | (1 << GraphqlParser.EXTENDS_) | (1 << GraphqlParser.FALSE_) | (1 << GraphqlParser.FIELD) | (1 << GraphqlParser.FIELD_DEFINITION) | (1 << GraphqlParser.FRAGMENT_) | (1 << GraphqlParser.FRAGMENT_DEFINITION) | (1 << GraphqlParser.FRAGMENT_SPREAD) | (1 << GraphqlParser.IMPLEMENTS_) | (1 << GraphqlParser.INLINE_FRAGMENT) | (1 << GraphqlParser.INPUT_) | (1 << GraphqlParser.INPUT_FIELD_DEFINITION) | (1 << GraphqlParser.INPUT_OBJECT) | (1 << GraphqlParser.INTERFACE) | (1 << GraphqlParser.INTERFACE_) | (1 << GraphqlParser.MUTATION) | (1 << GraphqlParser.MUTATION_) | (1 << GraphqlParser.NULL_) | (1 << GraphqlParser.OBJECT) | (1 << GraphqlParser.ON_) | (1 << GraphqlParser.QUERY) | (1 << GraphqlParser.QUERY_) | (1 << GraphqlParser.SCALAR) | (1 << GraphqlParser.SCALAR_) | (1 << GraphqlParser.SCHEMA) | (1 << GraphqlParser.SCHEMA_) | (1 << GraphqlParser.SUBSCRIPTION) | (1 << GraphqlParser.SUBSCRIPTION_) | (1 << GraphqlParser.TRUE_) | (1 << GraphqlParser.TYPE_) | (1 << GraphqlParser.UNION) | (1 << GraphqlParser.UNION_) | (1 << GraphqlParser.NAME))) != 0):
                    self.state = 279
                    self.objectField()
                    self.state = 284
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 285
                self.match(GraphqlParser.T__1)
                pass


        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitObjectField" ):
                return visitor.visitObjectField(self)
            else:
                return visitor.visitChildren(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 = 288
            self.name()
            self.state = 289
            self.match(GraphqlParser.T__4)
            self.state = 290
            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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariable" ):
                return visitor.visitVariable(self)
            else:
                return visitor.visitChildren(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 = 292
            self.match(GraphqlParser.T__8)
            self.state = 293
            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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariableDefinitions" ):
                return visitor.visitVariableDefinitions(self)
            else:
                return visitor.visitChildren(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 = 295
            self.match(GraphqlParser.T__2)
            self.state = 297 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 296
                self.variableDefinition()
                self.state = 299 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==GraphqlParser.T__8):
                    break

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


    class 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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVariableDefinition" ):
                return visitor.visitVariableDefinition(self)
            else:
                return visitor.visitChildren(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 = 303
            self.variable()
            self.state = 304
            self.match(GraphqlParser.T__4)
            self.state = 305
            self.type_()
            self.state = 307
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__9:
                self.state = 306
                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDefaultValue" ):
                return visitor.visitDefaultValue(self)
            else:
                return visitor.visitChildren(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 = 309
            self.match(GraphqlParser.T__9)
            self.state = 310
            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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitType_" ):
                return visitor.visitType_(self)
            else:
                return visitor.visitChildren(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 = 320
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [GraphqlParser.ARGUMENT_DEFINITION, GraphqlParser.DIRECTIVE_, GraphqlParser.ENUM, GraphqlParser.ENUM_, GraphqlParser.ENUM_VALUE, GraphqlParser.EXTEND_, GraphqlParser.EXTENDS_, GraphqlParser.FALSE_, GraphqlParser.FIELD, GraphqlParser.FIELD_DEFINITION, GraphqlParser.FRAGMENT_, GraphqlParser.FRAGMENT_DEFINITION, GraphqlParser.FRAGMENT_SPREAD, GraphqlParser.IMPLEMENTS_, GraphqlParser.INLINE_FRAGMENT, GraphqlParser.INPUT_, GraphqlParser.INPUT_FIELD_DEFINITION, GraphqlParser.INPUT_OBJECT, GraphqlParser.INTERFACE, GraphqlParser.INTERFACE_, GraphqlParser.MUTATION, GraphqlParser.MUTATION_, GraphqlParser.NULL_, GraphqlParser.OBJECT, GraphqlParser.ON_, GraphqlParser.QUERY, GraphqlParser.QUERY_, GraphqlParser.SCALAR, GraphqlParser.SCALAR_, GraphqlParser.SCHEMA, GraphqlParser.SCHEMA_, GraphqlParser.SUBSCRIPTION, GraphqlParser.SUBSCRIPTION_, GraphqlParser.TRUE_, GraphqlParser.TYPE_, GraphqlParser.UNION, GraphqlParser.UNION_, GraphqlParser.NAME]:
                self.enterOuterAlt(localctx, 1)
                self.state = 312
                self.namedType()
                self.state = 314
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphqlParser.T__10:
                    self.state = 313
                    self.match(GraphqlParser.T__10)


                pass
            elif token in [GraphqlParser.T__6]:
                self.enterOuterAlt(localctx, 2)
                self.state = 316
                self.listType()
                self.state = 318
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphqlParser.T__10:
                    self.state = 317
                    self.match(GraphqlParser.T__10)


                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamedType" ):
                return visitor.visitNamedType(self)
            else:
                return visitor.visitChildren(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 = 322
            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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitListType" ):
                return visitor.visitListType(self)
            else:
                return visitor.visitChildren(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 = 324
            self.match(GraphqlParser.T__6)
            self.state = 325
            self.type_()
            self.state = 326
            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 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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDirectives" ):
                return visitor.visitDirectives(self)
            else:
                return visitor.visitChildren(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 = 329 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 328
                self.directive()
                self.state = 331 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==GraphqlParser.T__11):
                    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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDirective" ):
                return visitor.visitDirective(self)
            else:
                return visitor.visitChildren(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 = 333
            self.match(GraphqlParser.T__11)
            self.state = 334
            self.name()
            self.state = 336
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__2:
                self.state = 335
                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeSystemDefinition" ):
                return visitor.visitTypeSystemDefinition(self)
            else:
                return visitor.visitChildren(self)




    def typeSystemDefinition(self):

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

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 340
                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeSystemExtension" ):
                return visitor.visitTypeSystemExtension(self)
            else:
                return visitor.visitChildren(self)




    def typeSystemExtension(self):

        localctx = GraphqlParser.TypeSystemExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_typeSystemExtension)
        try:
            self.state = 345
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 343
                self.schemaExtension()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 344
                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

        def SCHEMA_(self):
            return self.getToken(GraphqlParser.SCHEMA_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSchemaDefinition" ):
                return visitor.visitSchemaDefinition(self)
            else:
                return visitor.visitChildren(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 = 347
            self.match(GraphqlParser.SCHEMA_)
            self.state = 349
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__11:
                self.state = 348
                self.directives()


            self.state = 351
            self.match(GraphqlParser.T__0)
            self.state = 353 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 352
                self.rootOperationTypeDefinition()
                self.state = 355 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphqlParser.MUTATION_) | (1 << GraphqlParser.QUERY_) | (1 << GraphqlParser.SUBSCRIPTION_))) != 0)):
                    break

            self.state = 357
            self.match(GraphqlParser.T__1)
        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRootOperationTypeDefinition" ):
                return visitor.visitRootOperationTypeDefinition(self)
            else:
                return visitor.visitChildren(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 = 359
            self.operationType()
            self.state = 360
            self.match(GraphqlParser.T__4)
            self.state = 361
            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 EXTEND_(self):
            return self.getToken(GraphqlParser.EXTEND_, 0)

        def SCHEMA_(self):
            return self.getToken(GraphqlParser.SCHEMA_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSchemaExtension" ):
                return visitor.visitSchemaExtension(self)
            else:
                return visitor.visitChildren(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 = 379
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 363
                self.match(GraphqlParser.EXTEND_)
                self.state = 364
                self.match(GraphqlParser.SCHEMA_)
                self.state = 366
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphqlParser.T__11:
                    self.state = 365
                    self.directives()


                self.state = 368
                self.match(GraphqlParser.T__0)
                self.state = 370 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 369
                    self.operationTypeDefinition()
                    self.state = 372 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphqlParser.MUTATION_) | (1 << GraphqlParser.QUERY_) | (1 << GraphqlParser.SUBSCRIPTION_))) != 0)):
                        break

                self.state = 374
                self.match(GraphqlParser.T__1)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 376
                self.match(GraphqlParser.EXTEND_)
                self.state = 377
                self.match(GraphqlParser.SCHEMA_)
                self.state = 378
                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOperationTypeDefinition" ):
                return visitor.visitOperationTypeDefinition(self)
            else:
                return visitor.visitChildren(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 = 381
            self.operationType()
            self.state = 382
            self.match(GraphqlParser.T__4)
            self.state = 383
            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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDescription" ):
                return visitor.visitDescription(self)
            else:
                return visitor.visitChildren(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 = 385
            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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeDefinition" ):
                return visitor.visitTypeDefinition(self)
            else:
                return visitor.visitChildren(self)




    def typeDefinition(self):

        localctx = GraphqlParser.TypeDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_typeDefinition)
        try:
            self.state = 393
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 387
                self.scalarTypeDefinition()
                pass

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

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

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

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

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 392
                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeExtension" ):
                return visitor.visitTypeExtension(self)
            else:
                return visitor.visitChildren(self)




    def typeExtension(self):

        localctx = GraphqlParser.TypeExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_typeExtension)
        try:
            self.state = 401
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 395
                self.scalarTypeExtension()
                pass

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

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

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

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

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 400
                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 SCALAR_(self):
            return self.getToken(GraphqlParser.SCALAR_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitScalarTypeDefinition" ):
                return visitor.visitScalarTypeDefinition(self)
            else:
                return visitor.visitChildren(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 = 404
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.STRING or _la==GraphqlParser.BLOCK_STRING:
                self.state = 403
                self.description()


            self.state = 406
            self.match(GraphqlParser.SCALAR_)
            self.state = 407
            self.name()
            self.state = 409
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__11:
                self.state = 408
                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 EXTENDS_(self):
            return self.getToken(GraphqlParser.EXTENDS_, 0)

        def SCALAR_(self):
            return self.getToken(GraphqlParser.SCALAR_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitScalarTypeExtension" ):
                return visitor.visitScalarTypeExtension(self)
            else:
                return visitor.visitChildren(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 = 411
            self.match(GraphqlParser.EXTENDS_)
            self.state = 412
            self.match(GraphqlParser.SCALAR_)
            self.state = 413
            self.name()
            self.state = 414
            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 TYPE_(self):
            return self.getToken(GraphqlParser.TYPE_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitObjectTypeDefinition" ):
                return visitor.visitObjectTypeDefinition(self)
            else:
                return visitor.visitChildren(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 = 417
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.STRING or _la==GraphqlParser.BLOCK_STRING:
                self.state = 416
                self.description()


            self.state = 419
            self.match(GraphqlParser.TYPE_)
            self.state = 420
            self.name()
            self.state = 422
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.IMPLEMENTS_:
                self.state = 421
                self.implementsInterfaces(0)


            self.state = 425
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__11:
                self.state = 424
                self.directives()


            self.state = 428
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
            if la_ == 1:
                self.state = 427
                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 IMPLEMENTS_(self):
            return self.getToken(GraphqlParser.IMPLEMENTS_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitImplementsInterfaces" ):
                return visitor.visitImplementsInterfaces(self)
            else:
                return visitor.visitChildren(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 = 431
            self.match(GraphqlParser.IMPLEMENTS_)
            self.state = 433
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__12:
                self.state = 432
                self.match(GraphqlParser.T__12)


            self.state = 435
            self.namedType()
            self._ctx.stop = self._input.LT(-1)
            self.state = 442
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,46,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 = 437
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 438
                    self.match(GraphqlParser.T__12)
                    self.state = 439
                    self.namedType() 
                self.state = 444
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,46,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

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFieldsDefinition" ):
                return visitor.visitFieldsDefinition(self)
            else:
                return visitor.visitChildren(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 = 445
            self.match(GraphqlParser.T__0)
            self.state = 447 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 446
                self.fieldDefinition()
                self.state = 449 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphqlParser.ARGUMENT_DEFINITION) | (1 << GraphqlParser.DIRECTIVE_) | (1 << GraphqlParser.ENUM) | (1 << GraphqlParser.ENUM_) | (1 << GraphqlParser.ENUM_VALUE) | (1 << GraphqlParser.EXTEND_) | (1 << GraphqlParser.EXTENDS_) | (1 << GraphqlParser.FALSE_) | (1 << GraphqlParser.FIELD) | (1 << GraphqlParser.FIELD_DEFINITION) | (1 << GraphqlParser.FRAGMENT_) | (1 << GraphqlParser.FRAGMENT_DEFINITION) | (1 << GraphqlParser.FRAGMENT_SPREAD) | (1 << GraphqlParser.IMPLEMENTS_) | (1 << GraphqlParser.INLINE_FRAGMENT) | (1 << GraphqlParser.INPUT_) | (1 << GraphqlParser.INPUT_FIELD_DEFINITION) | (1 << GraphqlParser.INPUT_OBJECT) | (1 << GraphqlParser.INTERFACE) | (1 << GraphqlParser.INTERFACE_) | (1 << GraphqlParser.MUTATION) | (1 << GraphqlParser.MUTATION_) | (1 << GraphqlParser.NULL_) | (1 << GraphqlParser.OBJECT) | (1 << GraphqlParser.ON_) | (1 << GraphqlParser.QUERY) | (1 << GraphqlParser.QUERY_) | (1 << GraphqlParser.SCALAR) | (1 << GraphqlParser.SCALAR_) | (1 << GraphqlParser.SCHEMA) | (1 << GraphqlParser.SCHEMA_) | (1 << GraphqlParser.SUBSCRIPTION) | (1 << GraphqlParser.SUBSCRIPTION_) | (1 << GraphqlParser.TRUE_) | (1 << GraphqlParser.TYPE_) | (1 << GraphqlParser.UNION) | (1 << GraphqlParser.UNION_) | (1 << GraphqlParser.NAME) | (1 << GraphqlParser.STRING) | (1 << GraphqlParser.BLOCK_STRING))) != 0)):
                    break

            self.state = 451
            self.match(GraphqlParser.T__1)
        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFieldDefinition" ):
                return visitor.visitFieldDefinition(self)
            else:
                return visitor.visitChildren(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 = 454
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.STRING or _la==GraphqlParser.BLOCK_STRING:
                self.state = 453
                self.description()


            self.state = 456
            self.name()
            self.state = 458
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__2:
                self.state = 457
                self.argumentsDefinition()


            self.state = 460
            self.match(GraphqlParser.T__4)
            self.state = 461
            self.type_()
            self.state = 463
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__11:
                self.state = 462
                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

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArgumentsDefinition" ):
                return visitor.visitArgumentsDefinition(self)
            else:
                return visitor.visitChildren(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 = 465
            self.match(GraphqlParser.T__2)
            self.state = 467 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 466
                self.inputValueDefinition()
                self.state = 469 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphqlParser.ARGUMENT_DEFINITION) | (1 << GraphqlParser.DIRECTIVE_) | (1 << GraphqlParser.ENUM) | (1 << GraphqlParser.ENUM_) | (1 << GraphqlParser.ENUM_VALUE) | (1 << GraphqlParser.EXTEND_) | (1 << GraphqlParser.EXTENDS_) | (1 << GraphqlParser.FALSE_) | (1 << GraphqlParser.FIELD) | (1 << GraphqlParser.FIELD_DEFINITION) | (1 << GraphqlParser.FRAGMENT_) | (1 << GraphqlParser.FRAGMENT_DEFINITION) | (1 << GraphqlParser.FRAGMENT_SPREAD) | (1 << GraphqlParser.IMPLEMENTS_) | (1 << GraphqlParser.INLINE_FRAGMENT) | (1 << GraphqlParser.INPUT_) | (1 << GraphqlParser.INPUT_FIELD_DEFINITION) | (1 << GraphqlParser.INPUT_OBJECT) | (1 << GraphqlParser.INTERFACE) | (1 << GraphqlParser.INTERFACE_) | (1 << GraphqlParser.MUTATION) | (1 << GraphqlParser.MUTATION_) | (1 << GraphqlParser.NULL_) | (1 << GraphqlParser.OBJECT) | (1 << GraphqlParser.ON_) | (1 << GraphqlParser.QUERY) | (1 << GraphqlParser.QUERY_) | (1 << GraphqlParser.SCALAR) | (1 << GraphqlParser.SCALAR_) | (1 << GraphqlParser.SCHEMA) | (1 << GraphqlParser.SCHEMA_) | (1 << GraphqlParser.SUBSCRIPTION) | (1 << GraphqlParser.SUBSCRIPTION_) | (1 << GraphqlParser.TRUE_) | (1 << GraphqlParser.TYPE_) | (1 << GraphqlParser.UNION) | (1 << GraphqlParser.UNION_) | (1 << GraphqlParser.NAME) | (1 << GraphqlParser.STRING) | (1 << GraphqlParser.BLOCK_STRING))) != 0)):
                    break

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


    class 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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInputValueDefinition" ):
                return visitor.visitInputValueDefinition(self)
            else:
                return visitor.visitChildren(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 = 474
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.STRING or _la==GraphqlParser.BLOCK_STRING:
                self.state = 473
                self.description()


            self.state = 476
            self.name()
            self.state = 477
            self.match(GraphqlParser.T__4)
            self.state = 478
            self.type_()
            self.state = 480
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__9:
                self.state = 479
                self.defaultValue()


            self.state = 483
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__11:
                self.state = 482
                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 EXTEND_(self):
            return self.getToken(GraphqlParser.EXTEND_, 0)

        def TYPE_(self):
            return self.getToken(GraphqlParser.TYPE_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitObjectTypeExtension" ):
                return visitor.visitObjectTypeExtension(self)
            else:
                return visitor.visitChildren(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 = 509
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 485
                self.match(GraphqlParser.EXTEND_)
                self.state = 486
                self.match(GraphqlParser.TYPE_)
                self.state = 487
                self.name()
                self.state = 489
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphqlParser.IMPLEMENTS_:
                    self.state = 488
                    self.implementsInterfaces(0)


                self.state = 492
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphqlParser.T__11:
                    self.state = 491
                    self.directives()


                self.state = 494
                self.fieldsDefinition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 496
                self.match(GraphqlParser.EXTEND_)
                self.state = 497
                self.match(GraphqlParser.TYPE_)
                self.state = 498
                self.name()
                self.state = 500
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphqlParser.IMPLEMENTS_:
                    self.state = 499
                    self.implementsInterfaces(0)


                self.state = 502
                self.directives()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 504
                self.match(GraphqlParser.EXTEND_)
                self.state = 505
                self.match(GraphqlParser.TYPE_)
                self.state = 506
                self.name()
                self.state = 507
                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 INTERFACE_(self):
            return self.getToken(GraphqlParser.INTERFACE_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInterfaceTypeDefinition" ):
                return visitor.visitInterfaceTypeDefinition(self)
            else:
                return visitor.visitChildren(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 = 512
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.STRING or _la==GraphqlParser.BLOCK_STRING:
                self.state = 511
                self.description()


            self.state = 514
            self.match(GraphqlParser.INTERFACE_)
            self.state = 515
            self.name()
            self.state = 517
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__11:
                self.state = 516
                self.directives()


            self.state = 520
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
            if la_ == 1:
                self.state = 519
                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 EXTEND_(self):
            return self.getToken(GraphqlParser.EXTEND_, 0)

        def INTERFACE_(self):
            return self.getToken(GraphqlParser.INTERFACE_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInterfaceTypeExtension" ):
                return visitor.visitInterfaceTypeExtension(self)
            else:
                return visitor.visitChildren(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 = 535
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,63,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 522
                self.match(GraphqlParser.EXTEND_)
                self.state = 523
                self.match(GraphqlParser.INTERFACE_)
                self.state = 524
                self.name()
                self.state = 526
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphqlParser.T__11:
                    self.state = 525
                    self.directives()


                self.state = 528
                self.fieldsDefinition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 530
                self.match(GraphqlParser.EXTEND_)
                self.state = 531
                self.match(GraphqlParser.INTERFACE_)
                self.state = 532
                self.name()
                self.state = 533
                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 UNION_(self):
            return self.getToken(GraphqlParser.UNION_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnionTypeDefinition" ):
                return visitor.visitUnionTypeDefinition(self)
            else:
                return visitor.visitChildren(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 = 538
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.STRING or _la==GraphqlParser.BLOCK_STRING:
                self.state = 537
                self.description()


            self.state = 540
            self.match(GraphqlParser.UNION_)
            self.state = 541
            self.name()
            self.state = 543
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__11:
                self.state = 542
                self.directives()


            self.state = 546
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__9:
                self.state = 545
                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnionMemberTypes" ):
                return visitor.visitUnionMemberTypes(self)
            else:
                return visitor.visitChildren(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 = 548
            self.match(GraphqlParser.T__9)
            self.state = 550
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__13:
                self.state = 549
                self.match(GraphqlParser.T__13)


            self.state = 552
            self.namedType()
            self.state = 557
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GraphqlParser.T__13:
                self.state = 553
                self.match(GraphqlParser.T__13)
                self.state = 554
                self.namedType()
                self.state = 559
                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 EXTEND_(self):
            return self.getToken(GraphqlParser.EXTEND_, 0)

        def UNION_(self):
            return self.getToken(GraphqlParser.UNION_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnionTypeExtension" ):
                return visitor.visitUnionTypeExtension(self)
            else:
                return visitor.visitChildren(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 = 573
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 560
                self.match(GraphqlParser.EXTEND_)
                self.state = 561
                self.match(GraphqlParser.UNION_)
                self.state = 562
                self.name()
                self.state = 564
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphqlParser.T__11:
                    self.state = 563
                    self.directives()


                self.state = 566
                self.unionMemberTypes()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 568
                self.match(GraphqlParser.EXTEND_)
                self.state = 569
                self.match(GraphqlParser.UNION_)
                self.state = 570
                self.name()
                self.state = 571
                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 ENUM_(self):
            return self.getToken(GraphqlParser.ENUM_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumTypeDefinition" ):
                return visitor.visitEnumTypeDefinition(self)
            else:
                return visitor.visitChildren(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 = 576
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.STRING or _la==GraphqlParser.BLOCK_STRING:
                self.state = 575
                self.description()


            self.state = 578
            self.match(GraphqlParser.ENUM_)
            self.state = 579
            self.name()
            self.state = 581
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__11:
                self.state = 580
                self.directives()


            self.state = 584
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
            if la_ == 1:
                self.state = 583
                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

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumValuesDefinition" ):
                return visitor.visitEnumValuesDefinition(self)
            else:
                return visitor.visitChildren(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 = 586
            self.match(GraphqlParser.T__0)
            self.state = 588 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 587
                self.enumValueDefinition()
                self.state = 590 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphqlParser.ARGUMENT_DEFINITION) | (1 << GraphqlParser.DIRECTIVE_) | (1 << GraphqlParser.ENUM) | (1 << GraphqlParser.ENUM_) | (1 << GraphqlParser.ENUM_VALUE) | (1 << GraphqlParser.EXTEND_) | (1 << GraphqlParser.EXTENDS_) | (1 << GraphqlParser.FALSE_) | (1 << GraphqlParser.FIELD) | (1 << GraphqlParser.FIELD_DEFINITION) | (1 << GraphqlParser.FRAGMENT_) | (1 << GraphqlParser.FRAGMENT_DEFINITION) | (1 << GraphqlParser.FRAGMENT_SPREAD) | (1 << GraphqlParser.IMPLEMENTS_) | (1 << GraphqlParser.INLINE_FRAGMENT) | (1 << GraphqlParser.INPUT_) | (1 << GraphqlParser.INPUT_FIELD_DEFINITION) | (1 << GraphqlParser.INPUT_OBJECT) | (1 << GraphqlParser.INTERFACE) | (1 << GraphqlParser.INTERFACE_) | (1 << GraphqlParser.MUTATION) | (1 << GraphqlParser.MUTATION_) | (1 << GraphqlParser.NULL_) | (1 << GraphqlParser.OBJECT) | (1 << GraphqlParser.ON_) | (1 << GraphqlParser.QUERY) | (1 << GraphqlParser.QUERY_) | (1 << GraphqlParser.SCALAR) | (1 << GraphqlParser.SCALAR_) | (1 << GraphqlParser.SCHEMA) | (1 << GraphqlParser.SCHEMA_) | (1 << GraphqlParser.SUBSCRIPTION) | (1 << GraphqlParser.SUBSCRIPTION_) | (1 << GraphqlParser.TRUE_) | (1 << GraphqlParser.TYPE_) | (1 << GraphqlParser.UNION) | (1 << GraphqlParser.UNION_) | (1 << GraphqlParser.NAME) | (1 << GraphqlParser.STRING) | (1 << GraphqlParser.BLOCK_STRING))) != 0)):
                    break

            self.state = 592
            self.match(GraphqlParser.T__1)
        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumValueDefinition" ):
                return visitor.visitEnumValueDefinition(self)
            else:
                return visitor.visitChildren(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 = 595
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.STRING or _la==GraphqlParser.BLOCK_STRING:
                self.state = 594
                self.description()


            self.state = 597
            self.enumValue()
            self.state = 599
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__11:
                self.state = 598
                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 EXTEND_(self):
            return self.getToken(GraphqlParser.EXTEND_, 0)

        def ENUM_(self):
            return self.getToken(GraphqlParser.ENUM_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumTypeExtension" ):
                return visitor.visitEnumTypeExtension(self)
            else:
                return visitor.visitChildren(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 = 614
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 601
                self.match(GraphqlParser.EXTEND_)
                self.state = 602
                self.match(GraphqlParser.ENUM_)
                self.state = 603
                self.name()
                self.state = 605
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphqlParser.T__11:
                    self.state = 604
                    self.directives()


                self.state = 607
                self.enumValuesDefinition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 609
                self.match(GraphqlParser.EXTEND_)
                self.state = 610
                self.match(GraphqlParser.ENUM_)
                self.state = 611
                self.name()
                self.state = 612
                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 INPUT_(self):
            return self.getToken(GraphqlParser.INPUT_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInputObjectTypeDefinition" ):
                return visitor.visitInputObjectTypeDefinition(self)
            else:
                return visitor.visitChildren(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 = 617
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.STRING or _la==GraphqlParser.BLOCK_STRING:
                self.state = 616
                self.description()


            self.state = 619
            self.match(GraphqlParser.INPUT_)
            self.state = 620
            self.name()
            self.state = 622
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__11:
                self.state = 621
                self.directives()


            self.state = 625
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
            if la_ == 1:
                self.state = 624
                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

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInputFieldsDefinition" ):
                return visitor.visitInputFieldsDefinition(self)
            else:
                return visitor.visitChildren(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 = 627
            self.match(GraphqlParser.T__0)
            self.state = 629 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 628
                self.inputValueDefinition()
                self.state = 631 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphqlParser.ARGUMENT_DEFINITION) | (1 << GraphqlParser.DIRECTIVE_) | (1 << GraphqlParser.ENUM) | (1 << GraphqlParser.ENUM_) | (1 << GraphqlParser.ENUM_VALUE) | (1 << GraphqlParser.EXTEND_) | (1 << GraphqlParser.EXTENDS_) | (1 << GraphqlParser.FALSE_) | (1 << GraphqlParser.FIELD) | (1 << GraphqlParser.FIELD_DEFINITION) | (1 << GraphqlParser.FRAGMENT_) | (1 << GraphqlParser.FRAGMENT_DEFINITION) | (1 << GraphqlParser.FRAGMENT_SPREAD) | (1 << GraphqlParser.IMPLEMENTS_) | (1 << GraphqlParser.INLINE_FRAGMENT) | (1 << GraphqlParser.INPUT_) | (1 << GraphqlParser.INPUT_FIELD_DEFINITION) | (1 << GraphqlParser.INPUT_OBJECT) | (1 << GraphqlParser.INTERFACE) | (1 << GraphqlParser.INTERFACE_) | (1 << GraphqlParser.MUTATION) | (1 << GraphqlParser.MUTATION_) | (1 << GraphqlParser.NULL_) | (1 << GraphqlParser.OBJECT) | (1 << GraphqlParser.ON_) | (1 << GraphqlParser.QUERY) | (1 << GraphqlParser.QUERY_) | (1 << GraphqlParser.SCALAR) | (1 << GraphqlParser.SCALAR_) | (1 << GraphqlParser.SCHEMA) | (1 << GraphqlParser.SCHEMA_) | (1 << GraphqlParser.SUBSCRIPTION) | (1 << GraphqlParser.SUBSCRIPTION_) | (1 << GraphqlParser.TRUE_) | (1 << GraphqlParser.TYPE_) | (1 << GraphqlParser.UNION) | (1 << GraphqlParser.UNION_) | (1 << GraphqlParser.NAME) | (1 << GraphqlParser.STRING) | (1 << GraphqlParser.BLOCK_STRING))) != 0)):
                    break

            self.state = 633
            self.match(GraphqlParser.T__1)
        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 EXTEND_(self):
            return self.getToken(GraphqlParser.EXTEND_, 0)

        def INPUT_(self):
            return self.getToken(GraphqlParser.INPUT_, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInputObjectTypeExtension" ):
                return visitor.visitInputObjectTypeExtension(self)
            else:
                return visitor.visitChildren(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 = 648
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 635
                self.match(GraphqlParser.EXTEND_)
                self.state = 636
                self.match(GraphqlParser.INPUT_)
                self.state = 637
                self.name()
                self.state = 639
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GraphqlParser.T__11:
                    self.state = 638
                    self.directives()


                self.state = 641
                self.inputFieldsDefinition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 643
                self.match(GraphqlParser.EXTEND_)
                self.state = 644
                self.match(GraphqlParser.INPUT_)
                self.state = 645
                self.name()
                self.state = 646
                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 DIRECTIVE_(self):
            return self.getToken(GraphqlParser.DIRECTIVE_, 0)

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


        def ON_(self):
            return self.getToken(GraphqlParser.ON_, 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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDirectiveDefinition" ):
                return visitor.visitDirectiveDefinition(self)
            else:
                return visitor.visitChildren(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 = 651
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.STRING or _la==GraphqlParser.BLOCK_STRING:
                self.state = 650
                self.description()


            self.state = 653
            self.match(GraphqlParser.DIRECTIVE_)
            self.state = 654
            self.match(GraphqlParser.T__11)
            self.state = 655
            self.name()
            self.state = 657
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==GraphqlParser.T__2:
                self.state = 656
                self.argumentsDefinition()


            self.state = 659
            self.match(GraphqlParser.ON_)
            self.state = 660
            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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDirectiveLocations" ):
                return visitor.visitDirectiveLocations(self)
            else:
                return visitor.visitChildren(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 = 662
            self.directiveLocation()
            self.state = 667
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GraphqlParser.T__13:
                self.state = 663
                self.match(GraphqlParser.T__13)
                self.state = 664
                self.directiveLocation()
                self.state = 669
                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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDirectiveLocation" ):
                return visitor.visitDirectiveLocation(self)
            else:
                return visitor.visitChildren(self)




    def directiveLocation(self):

        localctx = GraphqlParser.DirectiveLocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_directiveLocation)
        try:
            self.state = 672
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [GraphqlParser.FIELD, GraphqlParser.FRAGMENT_DEFINITION, GraphqlParser.FRAGMENT_SPREAD, GraphqlParser.INLINE_FRAGMENT, GraphqlParser.MUTATION, GraphqlParser.QUERY, GraphqlParser.SUBSCRIPTION]:
                self.enterOuterAlt(localctx, 1)
                self.state = 670
                self.executableDirectiveLocation()
                pass
            elif token in [GraphqlParser.ARGUMENT_DEFINITION, GraphqlParser.ENUM, GraphqlParser.ENUM_VALUE, GraphqlParser.FIELD_DEFINITION, GraphqlParser.INPUT_FIELD_DEFINITION, GraphqlParser.INPUT_OBJECT, GraphqlParser.INTERFACE, GraphqlParser.OBJECT, GraphqlParser.SCALAR, GraphqlParser.SCHEMA, GraphqlParser.UNION]:
                self.enterOuterAlt(localctx, 2)
                self.state = 671
                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 QUERY(self):
            return self.getToken(GraphqlParser.QUERY, 0)

        def MUTATION(self):
            return self.getToken(GraphqlParser.MUTATION, 0)

        def SUBSCRIPTION(self):
            return self.getToken(GraphqlParser.SUBSCRIPTION, 0)

        def FIELD(self):
            return self.getToken(GraphqlParser.FIELD, 0)

        def FRAGMENT_DEFINITION(self):
            return self.getToken(GraphqlParser.FRAGMENT_DEFINITION, 0)

        def FRAGMENT_SPREAD(self):
            return self.getToken(GraphqlParser.FRAGMENT_SPREAD, 0)

        def INLINE_FRAGMENT(self):
            return self.getToken(GraphqlParser.INLINE_FRAGMENT, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExecutableDirectiveLocation" ):
                return visitor.visitExecutableDirectiveLocation(self)
            else:
                return visitor.visitChildren(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 = 674
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphqlParser.FIELD) | (1 << GraphqlParser.FRAGMENT_DEFINITION) | (1 << GraphqlParser.FRAGMENT_SPREAD) | (1 << GraphqlParser.INLINE_FRAGMENT) | (1 << GraphqlParser.MUTATION) | (1 << GraphqlParser.QUERY) | (1 << GraphqlParser.SUBSCRIPTION))) != 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 SCHEMA(self):
            return self.getToken(GraphqlParser.SCHEMA, 0)

        def SCALAR(self):
            return self.getToken(GraphqlParser.SCALAR, 0)

        def OBJECT(self):
            return self.getToken(GraphqlParser.OBJECT, 0)

        def FIELD_DEFINITION(self):
            return self.getToken(GraphqlParser.FIELD_DEFINITION, 0)

        def ARGUMENT_DEFINITION(self):
            return self.getToken(GraphqlParser.ARGUMENT_DEFINITION, 0)

        def INTERFACE(self):
            return self.getToken(GraphqlParser.INTERFACE, 0)

        def UNION(self):
            return self.getToken(GraphqlParser.UNION, 0)

        def ENUM(self):
            return self.getToken(GraphqlParser.ENUM, 0)

        def ENUM_VALUE(self):
            return self.getToken(GraphqlParser.ENUM_VALUE, 0)

        def INPUT_OBJECT(self):
            return self.getToken(GraphqlParser.INPUT_OBJECT, 0)

        def INPUT_FIELD_DEFINITION(self):
            return self.getToken(GraphqlParser.INPUT_FIELD_DEFINITION, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeSystemDirectiveLocation" ):
                return visitor.visitTypeSystemDirectiveLocation(self)
            else:
                return visitor.visitChildren(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 = 676
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphqlParser.ARGUMENT_DEFINITION) | (1 << GraphqlParser.ENUM) | (1 << GraphqlParser.ENUM_VALUE) | (1 << GraphqlParser.FIELD_DEFINITION) | (1 << GraphqlParser.INPUT_FIELD_DEFINITION) | (1 << GraphqlParser.INPUT_OBJECT) | (1 << GraphqlParser.INTERFACE) | (1 << GraphqlParser.OBJECT) | (1 << GraphqlParser.SCALAR) | (1 << GraphqlParser.SCHEMA) | (1 << GraphqlParser.UNION))) != 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 ARGUMENT_DEFINITION(self):
            return self.getToken(GraphqlParser.ARGUMENT_DEFINITION, 0)

        def DIRECTIVE_(self):
            return self.getToken(GraphqlParser.DIRECTIVE_, 0)

        def ENUM(self):
            return self.getToken(GraphqlParser.ENUM, 0)

        def ENUM_(self):
            return self.getToken(GraphqlParser.ENUM_, 0)

        def ENUM_VALUE(self):
            return self.getToken(GraphqlParser.ENUM_VALUE, 0)

        def EXTEND_(self):
            return self.getToken(GraphqlParser.EXTEND_, 0)

        def EXTENDS_(self):
            return self.getToken(GraphqlParser.EXTENDS_, 0)

        def FALSE_(self):
            return self.getToken(GraphqlParser.FALSE_, 0)

        def FIELD(self):
            return self.getToken(GraphqlParser.FIELD, 0)

        def FIELD_DEFINITION(self):
            return self.getToken(GraphqlParser.FIELD_DEFINITION, 0)

        def FRAGMENT_(self):
            return self.getToken(GraphqlParser.FRAGMENT_, 0)

        def FRAGMENT_DEFINITION(self):
            return self.getToken(GraphqlParser.FRAGMENT_DEFINITION, 0)

        def FRAGMENT_SPREAD(self):
            return self.getToken(GraphqlParser.FRAGMENT_SPREAD, 0)

        def IMPLEMENTS_(self):
            return self.getToken(GraphqlParser.IMPLEMENTS_, 0)

        def INLINE_FRAGMENT(self):
            return self.getToken(GraphqlParser.INLINE_FRAGMENT, 0)

        def INPUT_(self):
            return self.getToken(GraphqlParser.INPUT_, 0)

        def INPUT_FIELD_DEFINITION(self):
            return self.getToken(GraphqlParser.INPUT_FIELD_DEFINITION, 0)

        def INPUT_OBJECT(self):
            return self.getToken(GraphqlParser.INPUT_OBJECT, 0)

        def INTERFACE(self):
            return self.getToken(GraphqlParser.INTERFACE, 0)

        def INTERFACE_(self):
            return self.getToken(GraphqlParser.INTERFACE_, 0)

        def MUTATION(self):
            return self.getToken(GraphqlParser.MUTATION, 0)

        def MUTATION_(self):
            return self.getToken(GraphqlParser.MUTATION_, 0)

        def NULL_(self):
            return self.getToken(GraphqlParser.NULL_, 0)

        def OBJECT(self):
            return self.getToken(GraphqlParser.OBJECT, 0)

        def ON_(self):
            return self.getToken(GraphqlParser.ON_, 0)

        def QUERY(self):
            return self.getToken(GraphqlParser.QUERY, 0)

        def QUERY_(self):
            return self.getToken(GraphqlParser.QUERY_, 0)

        def SCALAR(self):
            return self.getToken(GraphqlParser.SCALAR, 0)

        def SCALAR_(self):
            return self.getToken(GraphqlParser.SCALAR_, 0)

        def SCHEMA(self):
            return self.getToken(GraphqlParser.SCHEMA, 0)

        def SCHEMA_(self):
            return self.getToken(GraphqlParser.SCHEMA_, 0)

        def SUBSCRIPTION(self):
            return self.getToken(GraphqlParser.SUBSCRIPTION, 0)

        def SUBSCRIPTION_(self):
            return self.getToken(GraphqlParser.SUBSCRIPTION_, 0)

        def TRUE_(self):
            return self.getToken(GraphqlParser.TRUE_, 0)

        def TYPE_(self):
            return self.getToken(GraphqlParser.TYPE_, 0)

        def UNION(self):
            return self.getToken(GraphqlParser.UNION, 0)

        def UNION_(self):
            return self.getToken(GraphqlParser.UNION_, 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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitName" ):
                return visitor.visitName(self)
            else:
                return visitor.visitChildren(self)




    def name(self):

        localctx = GraphqlParser.NameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 678
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << GraphqlParser.ARGUMENT_DEFINITION) | (1 << GraphqlParser.DIRECTIVE_) | (1 << GraphqlParser.ENUM) | (1 << GraphqlParser.ENUM_) | (1 << GraphqlParser.ENUM_VALUE) | (1 << GraphqlParser.EXTEND_) | (1 << GraphqlParser.EXTENDS_) | (1 << GraphqlParser.FALSE_) | (1 << GraphqlParser.FIELD) | (1 << GraphqlParser.FIELD_DEFINITION) | (1 << GraphqlParser.FRAGMENT_) | (1 << GraphqlParser.FRAGMENT_DEFINITION) | (1 << GraphqlParser.FRAGMENT_SPREAD) | (1 << GraphqlParser.IMPLEMENTS_) | (1 << GraphqlParser.INLINE_FRAGMENT) | (1 << GraphqlParser.INPUT_) | (1 << GraphqlParser.INPUT_FIELD_DEFINITION) | (1 << GraphqlParser.INPUT_OBJECT) | (1 << GraphqlParser.INTERFACE) | (1 << GraphqlParser.INTERFACE_) | (1 << GraphqlParser.MUTATION) | (1 << GraphqlParser.MUTATION_) | (1 << GraphqlParser.NULL_) | (1 << GraphqlParser.OBJECT) | (1 << GraphqlParser.ON_) | (1 << GraphqlParser.QUERY) | (1 << GraphqlParser.QUERY_) | (1 << GraphqlParser.SCALAR) | (1 << GraphqlParser.SCALAR_) | (1 << GraphqlParser.SCHEMA) | (1 << GraphqlParser.SCHEMA_) | (1 << GraphqlParser.SUBSCRIPTION) | (1 << GraphqlParser.SUBSCRIPTION_) | (1 << GraphqlParser.TRUE_) | (1 << GraphqlParser.TYPE_) | (1 << GraphqlParser.UNION) | (1 << GraphqlParser.UNION_) | (1 << GraphqlParser.NAME))) != 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



    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)
         
