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


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3q")
        buf.write("\u0568\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\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
        buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
        buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4")
        buf.write("h\th\4i\ti\3\2\5\2\u00d4\n\2\3\2\7\2\u00d7\n\2\f\2\16")
        buf.write("\2\u00da\13\2\3\2\7\2\u00dd\n\2\f\2\16\2\u00e0\13\2\3")
        buf.write("\2\3\2\3\3\7\3\u00e5\n\3\f\3\16\3\u00e8\13\3\3\3\3\3\3")
        buf.write("\3\3\3\3\4\3\4\5\4\u00f0\n\4\3\4\3\4\3\4\5\4\u00f5\n\4")
        buf.write("\3\4\3\4\3\5\7\5\u00fa\n\5\f\5\16\5\u00fd\13\5\3\5\3\5")
        buf.write("\3\5\3\5\5\5\u0103\n\5\3\5\5\5\u0106\n\5\3\6\3\6\3\6\3")
        buf.write("\6\3\6\5\6\u010d\n\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5")
        buf.write("\7\u0117\n\7\3\b\3\b\5\b\u011b\n\b\3\t\3\t\3\t\5\t\u0120")
        buf.write("\n\t\3\t\3\t\5\t\u0124\n\t\3\t\3\t\5\t\u0128\n\t\3\t\3")
        buf.write("\t\3\n\3\n\3\n\3\n\7\n\u0130\n\n\f\n\16\n\u0133\13\n\3")
        buf.write("\n\3\n\3\13\7\13\u0138\n\13\f\13\16\13\u013b\13\13\3\13")
        buf.write("\3\13\3\13\5\13\u0140\n\13\3\f\3\f\3\f\7\f\u0145\n\f\f")
        buf.write("\f\16\f\u0148\13\f\3\r\3\r\3\r\3\r\5\r\u014e\n\r\3\r\3")
        buf.write("\r\5\r\u0152\n\r\3\r\5\r\u0155\n\r\3\r\5\r\u0158\n\r\3")
        buf.write("\r\3\r\3\16\3\16\3\16\7\16\u015f\n\16\f\16\16\16\u0162")
        buf.write("\13\16\3\17\7\17\u0165\n\17\f\17\16\17\u0168\13\17\3\17")
        buf.write("\3\17\5\17\u016c\n\17\3\17\5\17\u016f\n\17\3\20\3\20\7")
        buf.write("\20\u0173\n\20\f\20\16\20\u0176\13\20\3\21\3\21\3\21\5")
        buf.write("\21\u017b\n\21\3\21\3\21\5\21\u017f\n\21\3\21\3\21\3\22")
        buf.write("\3\22\7\22\u0185\n\22\f\22\16\22\u0188\13\22\3\22\3\22")
        buf.write("\3\23\3\23\7\23\u018e\n\23\f\23\16\23\u0191\13\23\3\23")
        buf.write("\3\23\3\24\3\24\5\24\u0197\n\24\3\24\3\24\7\24\u019b\n")
        buf.write("\24\f\24\16\24\u019e\13\24\3\24\5\24\u01a1\n\24\3\25\3")
        buf.write("\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u01ac\n\25")
        buf.write("\3\26\3\26\3\26\3\26\3\26\7\26\u01b3\n\26\f\26\16\26\u01b6")
        buf.write("\13\26\3\26\3\26\5\26\u01ba\n\26\3\26\3\26\3\27\3\27\5")
        buf.write("\27\u01c0\n\27\3\30\3\30\5\30\u01c4\n\30\3\31\3\31\3\31")
        buf.write("\3\32\3\32\3\32\3\33\3\33\3\33\3\33\5\33\u01d0\n\33\3")
        buf.write("\33\3\33\3\34\3\34\3\34\3\34\3\35\7\35\u01d9\n\35\f\35")
        buf.write("\16\35\u01dc\13\35\3\35\3\35\5\35\u01e0\n\35\3\36\3\36")
        buf.write("\3\36\3\36\3\36\3\36\3\36\5\36\u01e9\n\36\3\37\3\37\3")
        buf.write("\37\3\37\7\37\u01ef\n\37\f\37\16\37\u01f2\13\37\3\37\3")
        buf.write("\37\3 \3 \3 \7 \u01f9\n \f \16 \u01fc\13 \3 \3 \3 \3!")
        buf.write("\7!\u0202\n!\f!\16!\u0205\13!\3!\3!\3!\7!\u020a\n!\f!")
        buf.write("\16!\u020d\13!\3!\3!\5!\u0211\n!\3!\3!\3!\3!\7!\u0217")
        buf.write("\n!\f!\16!\u021a\13!\3!\3!\5!\u021e\n!\3!\3!\3\"\3\"\3")
        buf.write("\"\3\"\3\"\3\"\5\"\u0228\n\"\3#\3#\3#\3$\3$\3$\7$\u0230")
        buf.write("\n$\f$\16$\u0233\13$\3%\3%\3%\5%\u0238\n%\3&\3&\3&\7&")
        buf.write("\u023d\n&\f&\16&\u0240\13&\3\'\3\'\5\'\u0244\n\'\3(\3")
        buf.write("(\3(\3(\7(\u024a\n(\f(\16(\u024d\13(\3(\5(\u0250\n(\5")
        buf.write("(\u0252\n(\3(\3(\3)\3)\5)\u0258\n)\3)\3)\3)\5)\u025d\n")
        buf.write(")\7)\u025f\n)\f)\16)\u0262\13)\3*\3*\3*\3*\5*\u0268\n")
        buf.write("*\5*\u026a\n*\3+\3+\3+\7+\u026f\n+\f+\16+\u0272\13+\3")
        buf.write(",\3,\5,\u0276\n,\3,\3,\3-\3-\3-\7-\u027d\n-\f-\16-\u0280")
        buf.write("\13-\3-\3-\5-\u0284\n-\3-\5-\u0287\n-\3.\7.\u028a\n.\f")
        buf.write(".\16.\u028d\13.\3.\3.\3.\3/\7/\u0293\n/\f/\16/\u0296\13")
        buf.write("/\3/\3/\3/\3/\3\60\3\60\3\60\7\60\u029f\n\60\f\60\16\60")
        buf.write("\u02a2\13\60\3\61\3\61\3\61\3\61\3\61\3\61\5\61\u02aa")
        buf.write("\n\61\3\62\3\62\3\63\3\63\3\64\3\64\3\64\3\64\3\64\5\64")
        buf.write("\u02b5\n\64\3\64\5\64\u02b8\n\64\3\65\3\65\3\65\7\65\u02bd")
        buf.write("\n\65\f\65\16\65\u02c0\13\65\3\66\3\66\3\66\3\66\3\67")
        buf.write("\3\67\3\67\5\67\u02c9\n\67\38\38\38\38\78\u02cf\n8\f8")
        buf.write("\168\u02d2\138\58\u02d4\n8\38\58\u02d7\n8\38\38\39\39")
        buf.write("\39\39\39\3:\3:\7:\u02e2\n:\f:\16:\u02e5\13:\3:\3:\3;")
        buf.write("\7;\u02ea\n;\f;\16;\u02ed\13;\3;\3;\5;\u02f1\n;\3<\3<")
        buf.write("\3<\3<\3<\3<\5<\u02f9\n<\3<\3<\5<\u02fd\n<\3<\3<\5<\u0301")
        buf.write("\n<\3<\3<\5<\u0305\n<\5<\u0307\n<\3=\3=\5=\u030b\n=\3")
        buf.write(">\3>\3>\3>\5>\u0311\n>\3?\3?\3@\3@\3@\3A\3A\7A\u031a\n")
        buf.write("A\fA\16A\u031d\13A\3A\3A\3B\3B\3B\3B\3B\5B\u0326\nB\3")
        buf.write("C\7C\u0329\nC\fC\16C\u032c\13C\3C\3C\3C\3D\7D\u0332\n")
        buf.write("D\fD\16D\u0335\13D\3D\3D\5D\u0339\nD\3D\5D\u033c\nD\3")
        buf.write("E\3E\3E\3E\3E\5E\u0343\nE\3E\3E\3E\3E\3E\3E\3E\5E\u034c")
        buf.write("\nE\3E\3E\3E\3E\3E\3E\3E\3E\3E\3E\3E\3E\3E\3E\3E\3E\3")
        buf.write("E\3E\3E\6E\u0361\nE\rE\16E\u0362\3E\5E\u0366\nE\3E\5E")
        buf.write("\u0369\nE\3E\3E\3E\3E\7E\u036f\nE\fE\16E\u0372\13E\3E")
        buf.write("\5E\u0375\nE\3E\3E\3E\3E\7E\u037b\nE\fE\16E\u037e\13E")
        buf.write("\3E\7E\u0381\nE\fE\16E\u0384\13E\3E\3E\3E\3E\3E\3E\3E")
        buf.write("\3E\5E\u038e\nE\3E\3E\3E\3E\3E\3E\3E\5E\u0397\nE\3E\3")
        buf.write("E\3E\5E\u039c\nE\3E\3E\3E\3E\3E\3E\3E\3E\5E\u03a6\nE\3")
        buf.write("F\3F\3F\7F\u03ab\nF\fF\16F\u03ae\13F\3F\3F\3F\3F\3F\3")
        buf.write("G\3G\3G\7G\u03b8\nG\fG\16G\u03bb\13G\3H\3H\3H\3I\3I\3")
        buf.write("I\5I\u03c3\nI\3I\3I\3J\3J\3J\7J\u03ca\nJ\fJ\16J\u03cd")
        buf.write("\13J\3K\7K\u03d0\nK\fK\16K\u03d3\13K\3K\3K\3K\3K\3K\3")
        buf.write("L\6L\u03db\nL\rL\16L\u03dc\3L\6L\u03e0\nL\rL\16L\u03e1")
        buf.write("\3M\3M\3M\5M\u03e7\nM\3M\3M\3M\5M\u03ec\nM\3N\3N\5N\u03f0")
        buf.write("\nN\3N\3N\5N\u03f4\nN\3N\3N\5N\u03f8\nN\5N\u03fa\nN\3")
        buf.write("O\3O\5O\u03fe\nO\3P\7P\u0401\nP\fP\16P\u0404\13P\3P\3")
        buf.write("P\3P\3P\3P\3Q\3Q\3Q\3Q\3R\3R\3R\7R\u0412\nR\fR\16R\u0415")
        buf.write("\13R\3S\3S\3S\5S\u041a\nS\3S\3S\3S\3S\5S\u0420\nS\3S\3")
        buf.write("S\3S\3S\5S\u0426\nS\3S\5S\u0429\nS\3T\3T\3T\3T\3T\3T\3")
        buf.write("T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\5T\u043d\nT\3T\3T\5")
        buf.write("T\u0441\nT\3T\3T\3T\5T\u0446\nT\3T\3T\5T\u044a\nT\3T\3")
        buf.write("T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\5T\u045a\nT\3T\3")
        buf.write("T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3")
        buf.write("T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3")
        buf.write("T\5T\u0482\nT\3T\3T\3T\3T\5T\u0488\nT\3T\3T\3T\3T\3T\3")
        buf.write("T\3T\3T\3T\3T\3T\3T\3T\5T\u0497\nT\3T\7T\u049a\nT\fT\16")
        buf.write("T\u049d\13T\3U\3U\3U\3U\3V\3V\3V\5V\u04a6\nV\3V\3V\3V")
        buf.write("\3V\3V\7V\u04ad\nV\fV\16V\u04b0\13V\3V\5V\u04b3\nV\3W")
        buf.write("\3W\5W\u04b7\nW\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3")
        buf.write("X\3X\3X\3X\5X\u04c9\nX\5X\u04cb\nX\3Y\3Y\3Y\5Y\u04d0\n")
        buf.write("Y\3Y\7Y\u04d3\nY\fY\16Y\u04d6\13Y\3Y\3Y\5Y\u04da\nY\3")
        buf.write("Z\3Z\3Z\3Z\3Z\3Z\3Z\5Z\u04e3\nZ\5Z\u04e5\nZ\3[\3[\5[\u04e9")
        buf.write("\n[\3[\3[\3[\5[\u04ee\n[\7[\u04f0\n[\f[\16[\u04f3\13[")
        buf.write("\3[\5[\u04f6\n[\3\\\3\\\5\\\u04fa\n\\\3\\\3\\\3]\3]\3")
        buf.write("]\3]\7]\u0502\n]\f]\16]\u0505\13]\3]\3]\3]\3]\3]\3]\3")
        buf.write("]\7]\u050e\n]\f]\16]\u0511\13]\3]\3]\7]\u0515\n]\f]\16")
        buf.write("]\u0518\13]\5]\u051a\n]\3^\3^\5^\u051e\n^\3_\3_\3_\3`")
        buf.write("\3`\3`\5`\u0526\n`\3a\3a\3a\5a\u052b\na\3b\3b\3b\3b\3")
        buf.write("c\3c\3c\7c\u0534\nc\fc\16c\u0537\13c\3d\5d\u053a\nd\3")
        buf.write("d\3d\5d\u053e\nd\3d\3d\7d\u0542\nd\fd\16d\u0545\13d\3")
        buf.write("e\3e\3f\3f\3f\3f\7f\u054d\nf\ff\16f\u0550\13f\3f\3f\3")
        buf.write("g\3g\3g\3g\5g\u0558\ng\5g\u055a\ng\3h\3h\3h\3h\5h\u0560")
        buf.write("\nh\3i\3i\5i\u0564\ni\3i\3i\3i\2\3\u00a6j\2\4\6\b\n\f")
        buf.write("\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@")
        buf.write("BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086")
        buf.write("\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098")
        buf.write("\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa")
        buf.write("\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc")
        buf.write("\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce")
        buf.write("\u00d0\2\16\4\2\23\23**\3\2\658\3\29:\3\2UX\3\2KL\4\2")
        buf.write("YZ^^\3\2WX\4\2IJPQ\4\2OORR\4\2HH_i\3\2UV\n\2\5\5\7\7\n")
        buf.write("\n\20\20\26\26\35\35\37\37\'\'\2\u0601\2\u00d3\3\2\2\2")
        buf.write("\4\u00e6\3\2\2\2\6\u00ed\3\2\2\2\b\u0105\3\2\2\2\n\u010c")
        buf.write("\3\2\2\2\f\u0116\3\2\2\2\16\u011a\3\2\2\2\20\u011c\3\2")
        buf.write("\2\2\22\u012b\3\2\2\2\24\u0139\3\2\2\2\26\u0141\3\2\2")
        buf.write("\2\30\u0149\3\2\2\2\32\u015b\3\2\2\2\34\u0166\3\2\2\2")
        buf.write("\36\u0170\3\2\2\2 \u0177\3\2\2\2\"\u0182\3\2\2\2$\u018b")
        buf.write("\3\2\2\2&\u01a0\3\2\2\2(\u01ab\3\2\2\2*\u01ad\3\2\2\2")
        buf.write(",\u01bf\3\2\2\2.\u01c3\3\2\2\2\60\u01c5\3\2\2\2\62\u01c8")
        buf.write("\3\2\2\2\64\u01cb\3\2\2\2\66\u01d3\3\2\2\28\u01df\3\2")
        buf.write("\2\2:\u01e8\3\2\2\2<\u01ea\3\2\2\2>\u01f5\3\2\2\2@\u0203")
        buf.write("\3\2\2\2B\u0227\3\2\2\2D\u0229\3\2\2\2F\u022c\3\2\2\2")
        buf.write("H\u0234\3\2\2\2J\u0239\3\2\2\2L\u0243\3\2\2\2N\u0245\3")
        buf.write("\2\2\2P\u0255\3\2\2\2R\u0269\3\2\2\2T\u026b\3\2\2\2V\u0273")
        buf.write("\3\2\2\2X\u0286\3\2\2\2Z\u028b\3\2\2\2\\\u0294\3\2\2\2")
        buf.write("^\u029b\3\2\2\2`\u02a9\3\2\2\2b\u02ab\3\2\2\2d\u02ad\3")
        buf.write("\2\2\2f\u02af\3\2\2\2h\u02b9\3\2\2\2j\u02c1\3\2\2\2l\u02c8")
        buf.write("\3\2\2\2n\u02ca\3\2\2\2p\u02da\3\2\2\2r\u02df\3\2\2\2")
        buf.write("t\u02f0\3\2\2\2v\u0306\3\2\2\2x\u030a\3\2\2\2z\u030c\3")
        buf.write("\2\2\2|\u0312\3\2\2\2~\u0314\3\2\2\2\u0080\u0317\3\2\2")
        buf.write("\2\u0082\u0325\3\2\2\2\u0084\u032a\3\2\2\2\u0086\u033b")
        buf.write("\3\2\2\2\u0088\u03a5\3\2\2\2\u008a\u03a7\3\2\2\2\u008c")
        buf.write("\u03b4\3\2\2\2\u008e\u03bc\3\2\2\2\u0090\u03bf\3\2\2\2")
        buf.write("\u0092\u03c6\3\2\2\2\u0094\u03d1\3\2\2\2\u0096\u03da\3")
        buf.write("\2\2\2\u0098\u03eb\3\2\2\2\u009a\u03f9\3\2\2\2\u009c\u03fd")
        buf.write("\3\2\2\2\u009e\u0402\3\2\2\2\u00a0\u040a\3\2\2\2\u00a2")
        buf.write("\u040e\3\2\2\2\u00a4\u0428\3\2\2\2\u00a6\u0449\3\2\2\2")
        buf.write("\u00a8\u049e\3\2\2\2\u00aa\u04b2\3\2\2\2\u00ac\u04b6\3")
        buf.write("\2\2\2\u00ae\u04ca\3\2\2\2\u00b0\u04cf\3\2\2\2\u00b2\u04e4")
        buf.write("\3\2\2\2\u00b4\u04f5\3\2\2\2\u00b6\u04f7\3\2\2\2\u00b8")
        buf.write("\u04fd\3\2\2\2\u00ba\u051b\3\2\2\2\u00bc\u051f\3\2\2\2")
        buf.write("\u00be\u0525\3\2\2\2\u00c0\u052a\3\2\2\2\u00c2\u052c\3")
        buf.write("\2\2\2\u00c4\u0530\3\2\2\2\u00c6\u0539\3\2\2\2\u00c8\u0546")
        buf.write("\3\2\2\2\u00ca\u0548\3\2\2\2\u00cc\u0559\3\2\2\2\u00ce")
        buf.write("\u055f\3\2\2\2\u00d0\u0561\3\2\2\2\u00d2\u00d4\5\4\3\2")
        buf.write("\u00d3\u00d2\3\2\2\2\u00d3\u00d4\3\2\2\2\u00d4\u00d8\3")
        buf.write("\2\2\2\u00d5\u00d7\5\6\4\2\u00d6\u00d5\3\2\2\2\u00d7\u00da")
        buf.write("\3\2\2\2\u00d8\u00d6\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d9")
        buf.write("\u00de\3\2\2\2\u00da\u00d8\3\2\2\2\u00db\u00dd\5\b\5\2")
        buf.write("\u00dc\u00db\3\2\2\2\u00dd\u00e0\3\2\2\2\u00de\u00dc\3")
        buf.write("\2\2\2\u00de\u00df\3\2\2\2\u00df\u00e1\3\2\2\2\u00e0\u00de")
        buf.write("\3\2\2\2\u00e1\u00e2\7\2\2\3\u00e2\3\3\2\2\2\u00e3\u00e5")
        buf.write("\5f\64\2\u00e4\u00e3\3\2\2\2\u00e5\u00e8\3\2\2\2\u00e6")
        buf.write("\u00e4\3\2\2\2\u00e6\u00e7\3\2\2\2\u00e7\u00e9\3\2\2\2")
        buf.write("\u00e8\u00e6\3\2\2\2\u00e9\u00ea\7\"\2\2\u00ea\u00eb\5")
        buf.write("^\60\2\u00eb\u00ec\7E\2\2\u00ec\5\3\2\2\2\u00ed\u00ef")
        buf.write("\7\33\2\2\u00ee\u00f0\7(\2\2\u00ef\u00ee\3\2\2\2\u00ef")
        buf.write("\u00f0\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f4\5^\60\2")
        buf.write("\u00f2\u00f3\7G\2\2\u00f3\u00f5\7Y\2\2\u00f4\u00f2\3\2")
        buf.write("\2\2\u00f4\u00f5\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6\u00f7")
        buf.write("\7E\2\2\u00f7\7\3\2\2\2\u00f8\u00fa\5\f\7\2\u00f9\u00f8")
        buf.write("\3\2\2\2\u00fa\u00fd\3\2\2\2\u00fb\u00f9\3\2\2\2\u00fb")
        buf.write("\u00fc\3\2\2\2\u00fc\u0102\3\2\2\2\u00fd\u00fb\3\2\2\2")
        buf.write("\u00fe\u0103\5\20\t\2\u00ff\u0103\5\30\r\2\u0100\u0103")
        buf.write("\5 \21\2\u0101\u0103\5p9\2\u0102\u00fe\3\2\2\2\u0102\u00ff")
        buf.write("\3\2\2\2\u0102\u0100\3\2\2\2\u0102\u0101\3\2\2\2\u0103")
        buf.write("\u0106\3\2\2\2\u0104\u0106\7E\2\2\u0105\u00fb\3\2\2\2")
        buf.write("\u0105\u0104\3\2\2\2\u0106\t\3\2\2\2\u0107\u010d\5\f\7")
        buf.write("\2\u0108\u010d\7 \2\2\u0109\u010d\7,\2\2\u010a\u010d\7")
        buf.write("\60\2\2\u010b\u010d\7\63\2\2\u010c\u0107\3\2\2\2\u010c")
        buf.write("\u0108\3\2\2\2\u010c\u0109\3\2\2\2\u010c\u010a\3\2\2\2")
        buf.write("\u010c\u010b\3\2\2\2\u010d\13\3\2\2\2\u010e\u0117\5f\64")
        buf.write("\2\u010f\u0117\7%\2\2\u0110\u0117\7$\2\2\u0111\u0117\7")
        buf.write("#\2\2\u0112\u0117\7(\2\2\u0113\u0117\7\3\2\2\u0114\u0117")
        buf.write("\7\24\2\2\u0115\u0117\7)\2\2\u0116\u010e\3\2\2\2\u0116")
        buf.write("\u010f\3\2\2\2\u0116\u0110\3\2\2\2\u0116\u0111\3\2\2\2")
        buf.write("\u0116\u0112\3\2\2\2\u0116\u0113\3\2\2\2\u0116\u0114\3")
        buf.write("\2\2\2\u0116\u0115\3\2\2\2\u0117\r\3\2\2\2\u0118\u011b")
        buf.write("\7\24\2\2\u0119\u011b\5f\64\2\u011a\u0118\3\2\2\2\u011a")
        buf.write("\u0119\3\2\2\2\u011b\17\3\2\2\2\u011c\u011d\7\13\2\2\u011d")
        buf.write("\u011f\7q\2\2\u011e\u0120\5\22\n\2\u011f\u011e\3\2\2\2")
        buf.write("\u011f\u0120\3\2\2\2\u0120\u0123\3\2\2\2\u0121\u0122\7")
        buf.write("\23\2\2\u0122\u0124\5\u00c6d\2\u0123\u0121\3\2\2\2\u0123")
        buf.write("\u0124\3\2\2\2\u0124\u0127\3\2\2\2\u0125\u0126\7\32\2")
        buf.write("\2\u0126\u0128\5\u00c4c\2\u0127\u0125\3\2\2\2\u0127\u0128")
        buf.write("\3\2\2\2\u0128\u0129\3\2\2\2\u0129\u012a\5\"\22\2\u012a")
        buf.write("\21\3\2\2\2\u012b\u012c\7J\2\2\u012c\u0131\5\24\13\2\u012d")
        buf.write("\u012e\7F\2\2\u012e\u0130\5\24\13\2\u012f\u012d\3\2\2")
        buf.write("\2\u0130\u0133\3\2\2\2\u0131\u012f\3\2\2\2\u0131\u0132")
        buf.write("\3\2\2\2\u0132\u0134\3\2\2\2\u0133\u0131\3\2\2\2\u0134")
        buf.write("\u0135\7I\2\2\u0135\23\3\2\2\2\u0136\u0138\5f\64\2\u0137")
        buf.write("\u0136\3\2\2\2\u0138\u013b\3\2\2\2\u0139\u0137\3\2\2\2")
        buf.write("\u0139\u013a\3\2\2\2\u013a\u013c\3\2\2\2\u013b\u0139\3")
        buf.write("\2\2\2\u013c\u013f\7q\2\2\u013d\u013e\7\23\2\2\u013e\u0140")
        buf.write("\5\26\f\2\u013f\u013d\3\2\2\2\u013f\u0140\3\2\2\2\u0140")
        buf.write("\25\3\2\2\2\u0141\u0146\5\u00c6d\2\u0142\u0143\7[\2\2")
        buf.write("\u0143\u0145\5\u00c6d\2\u0144\u0142\3\2\2\2\u0145\u0148")
        buf.write("\3\2\2\2\u0146\u0144\3\2\2\2\u0146\u0147\3\2\2\2\u0147")
        buf.write("\27\3\2\2\2\u0148\u0146\3\2\2\2\u0149\u014a\7\22\2\2\u014a")
        buf.write("\u014d\7q\2\2\u014b\u014c\7\32\2\2\u014c\u014e\5\u00c4")
        buf.write("c\2\u014d\u014b\3\2\2\2\u014d\u014e\3\2\2\2\u014e\u014f")
        buf.write("\3\2\2\2\u014f\u0151\7A\2\2\u0150\u0152\5\32\16\2\u0151")
        buf.write("\u0150\3\2\2\2\u0151\u0152\3\2\2\2\u0152\u0154\3\2\2\2")
        buf.write("\u0153\u0155\7F\2\2\u0154\u0153\3\2\2\2\u0154\u0155\3")
        buf.write("\2\2\2\u0155\u0157\3\2\2\2\u0156\u0158\5\36\20\2\u0157")
        buf.write("\u0156\3\2\2\2\u0157\u0158\3\2\2\2\u0158\u0159\3\2\2\2")
        buf.write("\u0159\u015a\7B\2\2\u015a\31\3\2\2\2\u015b\u0160\5\34")
        buf.write("\17\2\u015c\u015d\7F\2\2\u015d\u015f\5\34\17\2\u015e\u015c")
        buf.write("\3\2\2\2\u015f\u0162\3\2\2\2\u0160\u015e\3\2\2\2\u0160")
        buf.write("\u0161\3\2\2\2\u0161\33\3\2\2\2\u0162\u0160\3\2\2\2\u0163")
        buf.write("\u0165\5f\64\2\u0164\u0163\3\2\2\2\u0165\u0168\3\2\2\2")
        buf.write("\u0166\u0164\3\2\2\2\u0166\u0167\3\2\2\2\u0167\u0169\3")
        buf.write("\2\2\2\u0168\u0166\3\2\2\2\u0169\u016b\7q\2\2\u016a\u016c")
        buf.write("\5\u00d0i\2\u016b\u016a\3\2\2\2\u016b\u016c\3\2\2\2\u016c")
        buf.write("\u016e\3\2\2\2\u016d\u016f\5\"\22\2\u016e\u016d\3\2\2")
        buf.write("\2\u016e\u016f\3\2\2\2\u016f\35\3\2\2\2\u0170\u0174\7")
        buf.write("E\2\2\u0171\u0173\5&\24\2\u0172\u0171\3\2\2\2\u0173\u0176")
        buf.write("\3\2\2\2\u0174\u0172\3\2\2\2\u0174\u0175\3\2\2\2\u0175")
        buf.write("\37\3\2\2\2\u0176\u0174\3\2\2\2\u0177\u0178\7\36\2\2\u0178")
        buf.write("\u017a\7q\2\2\u0179\u017b\5\22\n\2\u017a\u0179\3\2\2\2")
        buf.write("\u017a\u017b\3\2\2\2\u017b\u017e\3\2\2\2\u017c\u017d\7")
        buf.write("\23\2\2\u017d\u017f\5\u00c4c\2\u017e\u017c\3\2\2\2\u017e")
        buf.write("\u017f\3\2\2\2\u017f\u0180\3\2\2\2\u0180\u0181\5$\23\2")
        buf.write("\u0181!\3\2\2\2\u0182\u0186\7A\2\2\u0183\u0185\5&\24\2")
        buf.write("\u0184\u0183\3\2\2\2\u0185\u0188\3\2\2\2\u0186\u0184\3")
        buf.write("\2\2\2\u0186\u0187\3\2\2\2\u0187\u0189\3\2\2\2\u0188\u0186")
        buf.write("\3\2\2\2\u0189\u018a\7B\2\2\u018a#\3\2\2\2\u018b\u018f")
        buf.write("\7A\2\2\u018c\u018e\58\35\2\u018d\u018c\3\2\2\2\u018e")
        buf.write("\u0191\3\2\2\2\u018f\u018d\3\2\2\2\u018f\u0190\3\2\2\2")
        buf.write("\u0190\u0192\3\2\2\2\u0191\u018f\3\2\2\2\u0192\u0193\7")
        buf.write("B\2\2\u0193%\3\2\2\2\u0194\u01a1\7E\2\2\u0195\u0197\7")
        buf.write("(\2\2\u0196\u0195\3\2\2\2\u0196\u0197\3\2\2\2\u0197\u0198")
        buf.write("\3\2\2\2\u0198\u01a1\5\u0080A\2\u0199\u019b\5\n\6\2\u019a")
        buf.write("\u0199\3\2\2\2\u019b\u019e\3\2\2\2\u019c\u019a\3\2\2\2")
        buf.write("\u019c\u019d\3\2\2\2\u019d\u019f\3\2\2\2\u019e\u019c\3")
        buf.write("\2\2\2\u019f\u01a1\5(\25\2\u01a0\u0194\3\2\2\2\u01a0\u0196")
        buf.write("\3\2\2\2\u01a0\u019c\3\2\2\2\u01a1\'\3\2\2\2\u01a2\u01ac")
        buf.write("\5*\26\2\u01a3\u01ac\5\60\31\2\u01a4\u01ac\5\66\34\2\u01a5")
        buf.write("\u01ac\5\64\33\2\u01a6\u01ac\5\62\32\2\u01a7\u01ac\5 ")
        buf.write("\21\2\u01a8\u01ac\5p9\2\u01a9\u01ac\5\20\t\2\u01aa\u01ac")
        buf.write("\5\30\r\2\u01ab\u01a2\3\2\2\2\u01ab\u01a3\3\2\2\2\u01ab")
        buf.write("\u01a4\3\2\2\2\u01ab\u01a5\3\2\2\2\u01ab\u01a6\3\2\2\2")
        buf.write("\u01ab\u01a7\3\2\2\2\u01ab\u01a8\3\2\2\2\u01ab\u01a9\3")
        buf.write("\2\2\2\u01ab\u01aa\3\2\2\2\u01ac)\3\2\2\2\u01ad\u01ae")
        buf.write("\5.\30\2\u01ae\u01af\7q\2\2\u01af\u01b4\5V,\2\u01b0\u01b1")
        buf.write("\7C\2\2\u01b1\u01b3\7D\2\2\u01b2\u01b0\3\2\2\2\u01b3\u01b6")
        buf.write("\3\2\2\2\u01b4\u01b2\3\2\2\2\u01b4\u01b5\3\2\2\2\u01b5")
        buf.write("\u01b9\3\2\2\2\u01b6\u01b4\3\2\2\2\u01b7\u01b8\7/\2\2")
        buf.write("\u01b8\u01ba\5T+\2\u01b9\u01b7\3\2\2\2\u01b9\u01ba\3\2")
        buf.write("\2\2\u01ba\u01bb\3\2\2\2\u01bb\u01bc\5,\27\2\u01bc+\3")
        buf.write("\2\2\2\u01bd\u01c0\5\u0080A\2\u01be\u01c0\7E\2\2\u01bf")
        buf.write("\u01bd\3\2\2\2\u01bf\u01be\3\2\2\2\u01c0-\3\2\2\2\u01c1")
        buf.write("\u01c4\5\u00c6d\2\u01c2\u01c4\7\62\2\2\u01c3\u01c1\3\2")
        buf.write("\2\2\u01c3\u01c2\3\2\2\2\u01c4/\3\2\2\2\u01c5\u01c6\5")
        buf.write("\22\n\2\u01c6\u01c7\5*\26\2\u01c7\61\3\2\2\2\u01c8\u01c9")
        buf.write("\5\22\n\2\u01c9\u01ca\5\64\33\2\u01ca\63\3\2\2\2\u01cb")
        buf.write("\u01cc\7q\2\2\u01cc\u01cf\5V,\2\u01cd\u01ce\7/\2\2\u01ce")
        buf.write("\u01d0\5T+\2\u01cf\u01cd\3\2\2\2\u01cf\u01d0\3\2\2\2\u01d0")
        buf.write("\u01d1\3\2\2\2\u01d1\u01d2\5\u0080A\2\u01d2\65\3\2\2\2")
        buf.write("\u01d3\u01d4\5\u00c6d\2\u01d4\u01d5\5F$\2\u01d5\u01d6")
        buf.write("\7E\2\2\u01d6\67\3\2\2\2\u01d7\u01d9\5\n\6\2\u01d8\u01d7")
        buf.write("\3\2\2\2\u01d9\u01dc\3\2\2\2\u01da\u01d8\3\2\2\2\u01da")
        buf.write("\u01db\3\2\2\2\u01db\u01dd\3\2\2\2\u01dc\u01da\3\2\2\2")
        buf.write("\u01dd\u01e0\5:\36\2\u01de\u01e0\7E\2\2\u01df\u01da\3")
        buf.write("\2\2\2\u01df\u01de\3\2\2\2\u01e09\3\2\2\2\u01e1\u01e9")
        buf.write("\5<\37\2\u01e2\u01e9\5@!\2\u01e3\u01e9\5D#\2\u01e4\u01e9")
        buf.write("\5 \21\2\u01e5\u01e9\5p9\2\u01e6\u01e9\5\20\t\2\u01e7")
        buf.write("\u01e9\5\30\r\2\u01e8\u01e1\3\2\2\2\u01e8\u01e2\3\2\2")
        buf.write("\2\u01e8\u01e3\3\2\2\2\u01e8\u01e4\3\2\2\2\u01e8\u01e5")
        buf.write("\3\2\2\2\u01e8\u01e6\3\2\2\2\u01e8\u01e7\3\2\2\2\u01e9")
        buf.write(";\3\2\2\2\u01ea\u01eb\5\u00c6d\2\u01eb\u01f0\5> \2\u01ec")
        buf.write("\u01ed\7F\2\2\u01ed\u01ef\5> \2\u01ee\u01ec\3\2\2\2\u01ef")
        buf.write("\u01f2\3\2\2\2\u01f0\u01ee\3\2\2\2\u01f0\u01f1\3\2\2\2")
        buf.write("\u01f1\u01f3\3\2\2\2\u01f2\u01f0\3\2\2\2\u01f3\u01f4\7")
        buf.write("E\2\2\u01f4=\3\2\2\2\u01f5\u01fa\7q\2\2\u01f6\u01f7\7")
        buf.write("C\2\2\u01f7\u01f9\7D\2\2\u01f8\u01f6\3\2\2\2\u01f9\u01fc")
        buf.write("\3\2\2\2\u01fa\u01f8\3\2\2\2\u01fa\u01fb\3\2\2\2\u01fb")
        buf.write("\u01fd\3\2\2\2\u01fc\u01fa\3\2\2\2\u01fd\u01fe\7H\2\2")
        buf.write("\u01fe\u01ff\5L\'\2\u01ff?\3\2\2\2\u0200\u0202\5B\"\2")
        buf.write("\u0201\u0200\3\2\2\2\u0202\u0205\3\2\2\2\u0203\u0201\3")
        buf.write("\2\2\2\u0203\u0204\3\2\2\2\u0204\u0210\3\2\2\2\u0205\u0203")
        buf.write("\3\2\2\2\u0206\u0211\5.\30\2\u0207\u020b\5\22\n\2\u0208")
        buf.write("\u020a\5f\64\2\u0209\u0208\3\2\2\2\u020a\u020d\3\2\2\2")
        buf.write("\u020b\u0209\3\2\2\2\u020b\u020c\3\2\2\2\u020c\u020e\3")
        buf.write("\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\5.\30\2\u020f\u0211")
        buf.write("\3\2\2\2\u0210\u0206\3\2\2\2\u0210\u0207\3\2\2\2\u0211")
        buf.write("\u0212\3\2\2\2\u0212\u0213\7q\2\2\u0213\u0218\5V,\2\u0214")
        buf.write("\u0215\7C\2\2\u0215\u0217\7D\2\2\u0216\u0214\3\2\2\2\u0217")
        buf.write("\u021a\3\2\2\2\u0218\u0216\3\2\2\2\u0218\u0219\3\2\2\2")
        buf.write("\u0219\u021d\3\2\2\2\u021a\u0218\3\2\2\2\u021b\u021c\7")
        buf.write("/\2\2\u021c\u021e\5T+\2\u021d\u021b\3\2\2\2\u021d\u021e")
        buf.write("\3\2\2\2\u021e\u021f\3\2\2\2\u021f\u0220\5,\27\2\u0220")
        buf.write("A\3\2\2\2\u0221\u0228\5f\64\2\u0222\u0228\7%\2\2\u0223")
        buf.write("\u0228\7\3\2\2\u0224\u0228\7\16\2\2\u0225\u0228\7(\2\2")
        buf.write("\u0226\u0228\7)\2\2\u0227\u0221\3\2\2\2\u0227\u0222\3")
        buf.write("\2\2\2\u0227\u0223\3\2\2\2\u0227\u0224\3\2\2\2\u0227\u0225")
        buf.write("\3\2\2\2\u0227\u0226\3\2\2\2\u0228C\3\2\2\2\u0229\u022a")
        buf.write("\5\22\n\2\u022a\u022b\5@!\2\u022bE\3\2\2\2\u022c\u0231")
        buf.write("\5H%\2\u022d\u022e\7F\2\2\u022e\u0230\5H%\2\u022f\u022d")
        buf.write("\3\2\2\2\u0230\u0233\3\2\2\2\u0231\u022f\3\2\2\2\u0231")
        buf.write("\u0232\3\2\2\2\u0232G\3\2\2\2\u0233\u0231\3\2\2\2\u0234")
        buf.write("\u0237\5J&\2\u0235\u0236\7H\2\2\u0236\u0238\5L\'\2\u0237")
        buf.write("\u0235\3\2\2\2\u0237\u0238\3\2\2\2\u0238I\3\2\2\2\u0239")
        buf.write("\u023e\7q\2\2\u023a\u023b\7C\2\2\u023b\u023d\7D\2\2\u023c")
        buf.write("\u023a\3\2\2\2\u023d\u0240\3\2\2\2\u023e\u023c\3\2\2\2")
        buf.write("\u023e\u023f\3\2\2\2\u023fK\3\2\2\2\u0240\u023e\3\2\2")
        buf.write("\2\u0241\u0244\5N(\2\u0242\u0244\5\u00a6T\2\u0243\u0241")
        buf.write("\3\2\2\2\u0243\u0242\3\2\2\2\u0244M\3\2\2\2\u0245\u0251")
        buf.write("\7A\2\2\u0246\u024b\5L\'\2\u0247\u0248\7F\2\2\u0248\u024a")
        buf.write("\5L\'\2\u0249\u0247\3\2\2\2\u024a\u024d\3\2\2\2\u024b")
        buf.write("\u0249\3\2\2\2\u024b\u024c\3\2\2\2\u024c\u024f\3\2\2\2")
        buf.write("\u024d\u024b\3\2\2\2\u024e\u0250\7F\2\2\u024f\u024e\3")
        buf.write("\2\2\2\u024f\u0250\3\2\2\2\u0250\u0252\3\2\2\2\u0251\u0246")
        buf.write("\3\2\2\2\u0251\u0252\3\2\2\2\u0252\u0253\3\2\2\2\u0253")
        buf.write("\u0254\7B\2\2\u0254O\3\2\2\2\u0255\u0257\7q\2\2\u0256")
        buf.write("\u0258\5\u00caf\2\u0257\u0256\3\2\2\2\u0257\u0258\3\2")
        buf.write("\2\2\u0258\u0260\3\2\2\2\u0259\u025a\7G\2\2\u025a\u025c")
        buf.write("\7q\2\2\u025b\u025d\5\u00caf\2\u025c\u025b\3\2\2\2\u025c")
        buf.write("\u025d\3\2\2\2\u025d\u025f\3\2\2\2\u025e\u0259\3\2\2\2")
        buf.write("\u025f\u0262\3\2\2\2\u0260\u025e\3\2\2\2\u0260\u0261\3")
        buf.write("\2\2\2\u0261Q\3\2\2\2\u0262\u0260\3\2\2\2\u0263\u026a")
        buf.write("\5\u00c6d\2\u0264\u0267\7M\2\2\u0265\u0266\t\2\2\2\u0266")
        buf.write("\u0268\5\u00c6d\2\u0267\u0265\3\2\2\2\u0267\u0268\3\2")
        buf.write("\2\2\u0268\u026a\3\2\2\2\u0269\u0263\3\2\2\2\u0269\u0264")
        buf.write("\3\2\2\2\u026aS\3\2\2\2\u026b\u0270\5^\60\2\u026c\u026d")
        buf.write("\7F\2\2\u026d\u026f\5^\60\2\u026e\u026c\3\2\2\2\u026f")
        buf.write("\u0272\3\2\2\2\u0270\u026e\3\2\2\2\u0270\u0271\3\2\2\2")
        buf.write("\u0271U\3\2\2\2\u0272\u0270\3\2\2\2\u0273\u0275\7?\2\2")
        buf.write("\u0274\u0276\5X-\2\u0275\u0274\3\2\2\2\u0275\u0276\3\2")
        buf.write("\2\2\u0276\u0277\3\2\2\2\u0277\u0278\7@\2\2\u0278W\3\2")
        buf.write("\2\2\u0279\u027e\5Z.\2\u027a\u027b\7F\2\2\u027b\u027d")
        buf.write("\5Z.\2\u027c\u027a\3\2\2\2\u027d\u0280\3\2\2\2\u027e\u027c")
        buf.write("\3\2\2\2\u027e\u027f\3\2\2\2\u027f\u0283\3\2\2\2\u0280")
        buf.write("\u027e\3\2\2\2\u0281\u0282\7F\2\2\u0282\u0284\5\\/\2\u0283")
        buf.write("\u0281\3\2\2\2\u0283\u0284\3\2\2\2\u0284\u0287\3\2\2\2")
        buf.write("\u0285\u0287\5\\/\2\u0286\u0279\3\2\2\2\u0286\u0285\3")
        buf.write("\2\2\2\u0287Y\3\2\2\2\u0288\u028a\5\16\b\2\u0289\u0288")
        buf.write("\3\2\2\2\u028a\u028d\3\2\2\2\u028b\u0289\3\2\2\2\u028b")
        buf.write("\u028c\3\2\2\2\u028c\u028e\3\2\2\2\u028d\u028b\3\2\2\2")
        buf.write("\u028e\u028f\5\u00c6d\2\u028f\u0290\5J&\2\u0290[\3\2\2")
        buf.write("\2\u0291\u0293\5\16\b\2\u0292\u0291\3\2\2\2\u0293\u0296")
        buf.write("\3\2\2\2\u0294\u0292\3\2\2\2\u0294\u0295\3\2\2\2\u0295")
        buf.write("\u0297\3\2\2\2\u0296\u0294\3\2\2\2\u0297\u0298\5\u00c6")
        buf.write("d\2\u0298\u0299\7m\2\2\u0299\u029a\5J&\2\u029a]\3\2\2")
        buf.write("\2\u029b\u02a0\7q\2\2\u029c\u029d\7G\2\2\u029d\u029f\7")
        buf.write("q\2\2\u029e\u029c\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e")
        buf.write("\3\2\2\2\u02a0\u02a1\3\2\2\2\u02a1_\3\2\2\2\u02a2\u02a0")
        buf.write("\3\2\2\2\u02a3\u02aa\5b\62\2\u02a4\u02aa\5d\63\2\u02a5")
        buf.write("\u02aa\7<\2\2\u02a6\u02aa\7=\2\2\u02a7\u02aa\7;\2\2\u02a8")
        buf.write("\u02aa\7>\2\2\u02a9\u02a3\3\2\2\2\u02a9\u02a4\3\2\2\2")
        buf.write("\u02a9\u02a5\3\2\2\2\u02a9\u02a6\3\2\2\2\u02a9\u02a7\3")
        buf.write("\2\2\2\u02a9\u02a8\3\2\2\2\u02aaa\3\2\2\2\u02ab\u02ac")
        buf.write("\t\3\2\2\u02acc\3\2\2\2\u02ad\u02ae\t\4\2\2\u02aee\3\2")
        buf.write("\2\2\u02af\u02b0\7l\2\2\u02b0\u02b7\5^\60\2\u02b1\u02b4")
        buf.write("\7?\2\2\u02b2\u02b5\5h\65\2\u02b3\u02b5\5l\67\2\u02b4")
        buf.write("\u02b2\3\2\2\2\u02b4\u02b3\3\2\2\2\u02b4\u02b5\3\2\2\2")
        buf.write("\u02b5\u02b6\3\2\2\2\u02b6\u02b8\7@\2\2\u02b7\u02b1\3")
        buf.write("\2\2\2\u02b7\u02b8\3\2\2\2\u02b8g\3\2\2\2\u02b9\u02be")
        buf.write("\5j\66\2\u02ba\u02bb\7F\2\2\u02bb\u02bd\5j\66\2\u02bc")
        buf.write("\u02ba\3\2\2\2\u02bd\u02c0\3\2\2\2\u02be\u02bc\3\2\2\2")
        buf.write("\u02be\u02bf\3\2\2\2\u02bfi\3\2\2\2\u02c0\u02be\3\2\2")
        buf.write("\2\u02c1\u02c2\7q\2\2\u02c2\u02c3\7H\2\2\u02c3\u02c4\5")
        buf.write("l\67\2\u02c4k\3\2\2\2\u02c5\u02c9\5\u00a6T\2\u02c6\u02c9")
        buf.write("\5f\64\2\u02c7\u02c9\5n8\2\u02c8\u02c5\3\2\2\2\u02c8\u02c6")
        buf.write("\3\2\2\2\u02c8\u02c7\3\2\2\2\u02c9m\3\2\2\2\u02ca\u02d3")
        buf.write("\7A\2\2\u02cb\u02d0\5l\67\2\u02cc\u02cd\7F\2\2\u02cd\u02cf")
        buf.write("\5l\67\2\u02ce\u02cc\3\2\2\2\u02cf\u02d2\3\2\2\2\u02d0")
        buf.write("\u02ce\3\2\2\2\u02d0\u02d1\3\2\2\2\u02d1\u02d4\3\2\2\2")
        buf.write("\u02d2\u02d0\3\2\2\2\u02d3\u02cb\3\2\2\2\u02d3\u02d4\3")
        buf.write("\2\2\2\u02d4\u02d6\3\2\2\2\u02d5\u02d7\7F\2\2\u02d6\u02d5")
        buf.write("\3\2\2\2\u02d6\u02d7\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8")
        buf.write("\u02d9\7B\2\2\u02d9o\3\2\2\2\u02da\u02db\7l\2\2\u02db")
        buf.write("\u02dc\7\36\2\2\u02dc\u02dd\7q\2\2\u02dd\u02de\5r:\2\u02de")
        buf.write("q\3\2\2\2\u02df\u02e3\7A\2\2\u02e0\u02e2\5t;\2\u02e1\u02e0")
        buf.write("\3\2\2\2\u02e2\u02e5\3\2\2\2\u02e3\u02e1\3\2\2\2\u02e3")
        buf.write("\u02e4\3\2\2\2\u02e4\u02e6\3\2\2\2\u02e5\u02e3\3\2\2\2")
        buf.write("\u02e6\u02e7\7B\2\2\u02e7s\3\2\2\2\u02e8\u02ea\5\n\6\2")
        buf.write("\u02e9\u02e8\3\2\2\2\u02ea\u02ed\3\2\2\2\u02eb\u02e9\3")
        buf.write("\2\2\2\u02eb\u02ec\3\2\2\2\u02ec\u02ee\3\2\2\2\u02ed\u02eb")
        buf.write("\3\2\2\2\u02ee\u02f1\5v<\2\u02ef\u02f1\7E\2\2\u02f0\u02eb")
        buf.write("\3\2\2\2\u02f0\u02ef\3\2\2\2\u02f1u\3\2\2\2\u02f2\u02f3")
        buf.write("\5\u00c6d\2\u02f3\u02f4\5x=\2\u02f4\u02f5\7E\2\2\u02f5")
        buf.write("\u0307\3\2\2\2\u02f6\u02f8\5\20\t\2\u02f7\u02f9\7E\2\2")
        buf.write("\u02f8\u02f7\3\2\2\2\u02f8\u02f9\3\2\2\2\u02f9\u0307\3")
        buf.write("\2\2\2\u02fa\u02fc\5 \21\2\u02fb\u02fd\7E\2\2\u02fc\u02fb")
        buf.write("\3\2\2\2\u02fc\u02fd\3\2\2\2\u02fd\u0307\3\2\2\2\u02fe")
        buf.write("\u0300\5\30\r\2\u02ff\u0301\7E\2\2\u0300\u02ff\3\2\2\2")
        buf.write("\u0300\u0301\3\2\2\2\u0301\u0307\3\2\2\2\u0302\u0304\5")
        buf.write("p9\2\u0303\u0305\7E\2\2\u0304\u0303\3\2\2\2\u0304\u0305")
        buf.write("\3\2\2\2\u0305\u0307\3\2\2\2\u0306\u02f2\3\2\2\2\u0306")
        buf.write("\u02f6\3\2\2\2\u0306\u02fa\3\2\2\2\u0306\u02fe\3\2\2\2")
        buf.write("\u0306\u0302\3\2\2\2\u0307w\3\2\2\2\u0308\u030b\5z>\2")
        buf.write("\u0309\u030b\5|?\2\u030a\u0308\3\2\2\2\u030a\u0309\3\2")
        buf.write("\2\2\u030by\3\2\2\2\u030c\u030d\7q\2\2\u030d\u030e\7?")
        buf.write("\2\2\u030e\u0310\7@\2\2\u030f\u0311\5~@\2\u0310\u030f")
        buf.write("\3\2\2\2\u0310\u0311\3\2\2\2\u0311{\3\2\2\2\u0312\u0313")
        buf.write("\5F$\2\u0313}\3\2\2\2\u0314\u0315\7\16\2\2\u0315\u0316")
        buf.write("\5l\67\2\u0316\177\3\2\2\2\u0317\u031b\7A\2\2\u0318\u031a")
        buf.write("\5\u0082B\2\u0319\u0318\3\2\2\2\u031a\u031d\3\2\2\2\u031b")
        buf.write("\u0319\3\2\2\2\u031b\u031c\3\2\2\2\u031c\u031e\3\2\2\2")
        buf.write("\u031d\u031b\3\2\2\2\u031e\u031f\7B\2\2\u031f\u0081\3")
        buf.write("\2\2\2\u0320\u0321\5\u0084C\2\u0321\u0322\7E\2\2\u0322")
        buf.write("\u0326\3\2\2\2\u0323\u0326\5\u0088E\2\u0324\u0326\5\u0086")
        buf.write("D\2\u0325\u0320\3\2\2\2\u0325\u0323\3\2\2\2\u0325\u0324")
        buf.write("\3\2\2\2\u0326\u0083\3\2\2\2\u0327\u0329\5\16\b\2\u0328")
        buf.write("\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2")
        buf.write("\u032a\u032b\3\2\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3")
        buf.write("\2\2\2\u032d\u032e\5\u00c6d\2\u032e\u032f\5F$\2\u032f")
        buf.write("\u0085\3\2\2\2\u0330\u0332\5\f\7\2\u0331\u0330\3\2\2\2")
        buf.write("\u0332\u0335\3\2\2\2\u0333\u0331\3\2\2\2\u0333\u0334\3")
        buf.write("\2\2\2\u0334\u0338\3\2\2\2\u0335\u0333\3\2\2\2\u0336\u0339")
        buf.write("\5\20\t\2\u0337\u0339\5 \21\2\u0338\u0336\3\2\2\2\u0338")
        buf.write("\u0337\3\2\2\2\u0339\u033c\3\2\2\2\u033a\u033c\7E\2\2")
        buf.write("\u033b\u0333\3\2\2\2\u033b\u033a\3\2\2\2\u033c\u0087\3")
        buf.write("\2\2\2\u033d\u03a6\5\u0080A\2\u033e\u033f\7\4\2\2\u033f")
        buf.write("\u0342\5\u00a6T\2\u0340\u0341\7N\2\2\u0341\u0343\5\u00a6")
        buf.write("T\2\u0342\u0340\3\2\2\2\u0342\u0343\3\2\2\2\u0343\u0344")
        buf.write("\3\2\2\2\u0344\u0345\7E\2\2\u0345\u03a6\3\2\2\2\u0346")
        buf.write("\u0347\7\30\2\2\u0347\u0348\5\u00a0Q\2\u0348\u034b\5\u0088")
        buf.write("E\2\u0349\u034a\7\21\2\2\u034a\u034c\5\u0088E\2\u034b")
        buf.write("\u0349\3\2\2\2\u034b\u034c\3\2\2\2\u034c\u03a6\3\2\2\2")
        buf.write("\u034d\u034e\7\27\2\2\u034e\u034f\7?\2\2\u034f\u0350\5")
        buf.write("\u009aN\2\u0350\u0351\7@\2\2\u0351\u0352\5\u0088E\2\u0352")
        buf.write("\u03a6\3\2\2\2\u0353\u0354\7\64\2\2\u0354\u0355\5\u00a0")
        buf.write("Q\2\u0355\u0356\5\u0088E\2\u0356\u03a6\3\2\2\2\u0357\u0358")
        buf.write("\7\17\2\2\u0358\u0359\5\u0088E\2\u0359\u035a\7\64\2\2")
        buf.write("\u035a\u035b\5\u00a0Q\2\u035b\u035c\7E\2\2\u035c\u03a6")
        buf.write("\3\2\2\2\u035d\u035e\7\61\2\2\u035e\u0368\5\u0080A\2\u035f")
        buf.write("\u0361\5\u008aF\2\u0360\u035f\3\2\2\2\u0361\u0362\3\2")
        buf.write("\2\2\u0362\u0360\3\2\2\2\u0362\u0363\3\2\2\2\u0363\u0365")
        buf.write("\3\2\2\2\u0364\u0366\5\u008eH\2\u0365\u0364\3\2\2\2\u0365")
        buf.write("\u0366\3\2\2\2\u0366\u0369\3\2\2\2\u0367\u0369\5\u008e")
        buf.write("H\2\u0368\u0360\3\2\2\2\u0368\u0367\3\2\2\2\u0369\u03a6")
        buf.write("\3\2\2\2\u036a\u036b\7\61\2\2\u036b\u036c\5\u0090I\2\u036c")
        buf.write("\u0370\5\u0080A\2\u036d\u036f\5\u008aF\2\u036e\u036d\3")
        buf.write("\2\2\2\u036f\u0372\3\2\2\2\u0370\u036e\3\2\2\2\u0370\u0371")
        buf.write("\3\2\2\2\u0371\u0374\3\2\2\2\u0372\u0370\3\2\2\2\u0373")
        buf.write("\u0375\5\u008eH\2\u0374\u0373\3\2\2\2\u0374\u0375\3\2")
        buf.write("\2\2\u0375\u03a6\3\2\2\2\u0376\u0377\7+\2\2\u0377\u0378")
        buf.write("\5\u00a0Q\2\u0378\u037c\7A\2\2\u0379\u037b\5\u0096L\2")
        buf.write("\u037a\u0379\3\2\2\2\u037b\u037e\3\2\2\2\u037c\u037a\3")
        buf.write("\2\2\2\u037c\u037d\3\2\2\2\u037d\u0382\3\2\2\2\u037e\u037c")
        buf.write("\3\2\2\2\u037f\u0381\5\u0098M\2\u0380\u037f\3\2\2\2\u0381")
        buf.write("\u0384\3\2\2\2\u0382\u0380\3\2\2\2\u0382\u0383\3\2\2\2")
        buf.write("\u0383\u0385\3\2\2\2\u0384\u0382\3\2\2\2\u0385\u0386\7")
        buf.write("B\2\2\u0386\u03a6\3\2\2\2\u0387\u0388\7,\2\2\u0388\u0389")
        buf.write("\5\u00a0Q\2\u0389\u038a\5\u0080A\2\u038a\u03a6\3\2\2\2")
        buf.write("\u038b\u038d\7&\2\2\u038c\u038e\5\u00a6T\2\u038d\u038c")
        buf.write("\3\2\2\2\u038d\u038e\3\2\2\2\u038e\u038f\3\2\2\2\u038f")
        buf.write("\u03a6\7E\2\2\u0390\u0391\7.\2\2\u0391\u0392\5\u00a6T")
        buf.write("\2\u0392\u0393\7E\2\2\u0393\u03a6\3\2\2\2\u0394\u0396")
        buf.write("\7\6\2\2\u0395\u0397\7q\2\2\u0396\u0395\3\2\2\2\u0396")
        buf.write("\u0397\3\2\2\2\u0397\u0398\3\2\2\2\u0398\u03a6\7E\2\2")
        buf.write("\u0399\u039b\7\r\2\2\u039a\u039c\7q\2\2\u039b\u039a\3")
        buf.write("\2\2\2\u039b\u039c\3\2\2\2\u039c\u039d\3\2\2\2\u039d\u03a6")
        buf.write("\7E\2\2\u039e\u03a6\7E\2\2\u039f\u03a0\5\u00a6T\2\u03a0")
        buf.write("\u03a1\7E\2\2\u03a1\u03a6\3\2\2\2\u03a2\u03a3\7q\2\2\u03a3")
        buf.write("\u03a4\7N\2\2\u03a4\u03a6\5\u0088E\2\u03a5\u033d\3\2\2")
        buf.write("\2\u03a5\u033e\3\2\2\2\u03a5\u0346\3\2\2\2\u03a5\u034d")
        buf.write("\3\2\2\2\u03a5\u0353\3\2\2\2\u03a5\u0357\3\2\2\2\u03a5")
        buf.write("\u035d\3\2\2\2\u03a5\u036a\3\2\2\2\u03a5\u0376\3\2\2\2")
        buf.write("\u03a5\u0387\3\2\2\2\u03a5\u038b\3\2\2\2\u03a5\u0390\3")
        buf.write("\2\2\2\u03a5\u0394\3\2\2\2\u03a5\u0399\3\2\2\2\u03a5\u039e")
        buf.write("\3\2\2\2\u03a5\u039f\3\2\2\2\u03a5\u03a2\3\2\2\2\u03a6")
        buf.write("\u0089\3\2\2\2\u03a7\u03a8\7\t\2\2\u03a8\u03ac\7?\2\2")
        buf.write("\u03a9\u03ab\5\16\b\2\u03aa\u03a9\3\2\2\2\u03ab\u03ae")
        buf.write("\3\2\2\2\u03ac\u03aa\3\2\2\2\u03ac\u03ad\3\2\2\2\u03ad")
        buf.write("\u03af\3\2\2\2\u03ae\u03ac\3\2\2\2\u03af\u03b0\5\u008c")
        buf.write("G\2\u03b0\u03b1\7q\2\2\u03b1\u03b2\7@\2\2\u03b2\u03b3")
        buf.write("\5\u0080A\2\u03b3\u008b\3\2\2\2\u03b4\u03b9\5^\60\2\u03b5")
        buf.write("\u03b6\7\\\2\2\u03b6\u03b8\5^\60\2\u03b7\u03b5\3\2\2\2")
        buf.write("\u03b8\u03bb\3\2\2\2\u03b9\u03b7\3\2\2\2\u03b9\u03ba\3")
        buf.write("\2\2\2\u03ba\u008d\3\2\2\2\u03bb\u03b9\3\2\2\2\u03bc\u03bd")
        buf.write("\7\25\2\2\u03bd\u03be\5\u0080A\2\u03be\u008f\3\2\2\2\u03bf")
        buf.write("\u03c0\7?\2\2\u03c0\u03c2\5\u0092J\2\u03c1\u03c3\7E\2")
        buf.write("\2\u03c2\u03c1\3\2\2\2\u03c2\u03c3\3\2\2\2\u03c3\u03c4")
        buf.write("\3\2\2\2\u03c4\u03c5\7@\2\2\u03c5\u0091\3\2\2\2\u03c6")
        buf.write("\u03cb\5\u0094K\2\u03c7\u03c8\7E\2\2\u03c8\u03ca\5\u0094")
        buf.write("K\2\u03c9\u03c7\3\2\2\2\u03ca\u03cd\3\2\2\2\u03cb\u03c9")
        buf.write("\3\2\2\2\u03cb\u03cc\3\2\2\2\u03cc\u0093\3\2\2\2\u03cd")
        buf.write("\u03cb\3\2\2\2\u03ce\u03d0\5\16\b\2\u03cf\u03ce\3\2\2")
        buf.write("\2\u03d0\u03d3\3\2\2\2\u03d1\u03cf\3\2\2\2\u03d1\u03d2")
        buf.write("\3\2\2\2\u03d2\u03d4\3\2\2\2\u03d3\u03d1\3\2\2\2\u03d4")
        buf.write("\u03d5\5P)\2\u03d5\u03d6\5J&\2\u03d6\u03d7\7H\2\2\u03d7")
        buf.write("\u03d8\5\u00a6T\2\u03d8\u0095\3\2\2\2\u03d9\u03db\5\u0098")
        buf.write("M\2\u03da\u03d9\3\2\2\2\u03db\u03dc\3\2\2\2\u03dc\u03da")
        buf.write("\3\2\2\2\u03dc\u03dd\3\2\2\2\u03dd\u03df\3\2\2\2\u03de")
        buf.write("\u03e0\5\u0082B\2\u03df\u03de\3\2\2\2\u03e0\u03e1\3\2")
        buf.write("\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2\2\2\u03e2\u0097")
        buf.write("\3\2\2\2\u03e3\u03e6\7\b\2\2\u03e4\u03e7\5\u00a6T\2\u03e5")
        buf.write("\u03e7\7q\2\2\u03e6\u03e4\3\2\2\2\u03e6\u03e5\3\2\2\2")
        buf.write("\u03e7\u03e8\3\2\2\2\u03e8\u03ec\7N\2\2\u03e9\u03ea\7")
        buf.write("\16\2\2\u03ea\u03ec\7N\2\2\u03eb\u03e3\3\2\2\2\u03eb\u03e9")
        buf.write("\3\2\2\2\u03ec\u0099\3\2\2\2\u03ed\u03fa\5\u009eP\2\u03ee")
        buf.write("\u03f0\5\u009cO\2\u03ef\u03ee\3\2\2\2\u03ef\u03f0\3\2")
        buf.write("\2\2\u03f0\u03f1\3\2\2\2\u03f1\u03f3\7E\2\2\u03f2\u03f4")
        buf.write("\5\u00a6T\2\u03f3\u03f2\3\2\2\2\u03f3\u03f4\3\2\2\2\u03f4")
        buf.write("\u03f5\3\2\2\2\u03f5\u03f7\7E\2\2\u03f6\u03f8\5\u00a2")
        buf.write("R\2\u03f7\u03f6\3\2\2\2\u03f7\u03f8\3\2\2\2\u03f8\u03fa")
        buf.write("\3\2\2\2\u03f9\u03ed\3\2\2\2\u03f9\u03ef\3\2\2\2\u03fa")
        buf.write("\u009b\3\2\2\2\u03fb\u03fe\5\u0084C\2\u03fc\u03fe\5\u00a2")
        buf.write("R\2\u03fd\u03fb\3\2\2\2\u03fd\u03fc\3\2\2\2\u03fe\u009d")
        buf.write("\3\2\2\2\u03ff\u0401\5\16\b\2\u0400\u03ff\3\2\2\2\u0401")
        buf.write("\u0404\3\2\2\2\u0402\u0400\3\2\2\2\u0402\u0403\3\2\2\2")
        buf.write("\u0403\u0405\3\2\2\2\u0404\u0402\3\2\2\2\u0405\u0406\5")
        buf.write("\u00c6d\2\u0406\u0407\5J&\2\u0407\u0408\7N\2\2\u0408\u0409")
        buf.write("\5\u00a6T\2\u0409\u009f\3\2\2\2\u040a\u040b\7?\2\2\u040b")
        buf.write("\u040c\5\u00a6T\2\u040c\u040d\7@\2\2\u040d\u00a1\3\2\2")
        buf.write("\2\u040e\u0413\5\u00a6T\2\u040f\u0410\7F\2\2\u0410\u0412")
        buf.write("\5\u00a6T\2\u0411\u040f\3\2\2\2\u0412\u0415\3\2\2\2\u0413")
        buf.write("\u0411\3\2\2\2\u0413\u0414\3\2\2\2\u0414\u00a3\3\2\2\2")
        buf.write("\u0415\u0413\3\2\2\2\u0416\u0417\7q\2\2\u0417\u0419\7")
        buf.write("?\2\2\u0418\u041a\5\u00a2R\2\u0419\u0418\3\2\2\2\u0419")
        buf.write("\u041a\3\2\2\2\u041a\u041b\3\2\2\2\u041b\u0429\7@\2\2")
        buf.write("\u041c\u041d\7-\2\2\u041d\u041f\7?\2\2\u041e\u0420\5\u00a2")
        buf.write("R\2\u041f\u041e\3\2\2\2\u041f\u0420\3\2\2\2\u0420\u0421")
        buf.write("\3\2\2\2\u0421\u0429\7@\2\2\u0422\u0423\7*\2\2\u0423\u0425")
        buf.write("\7?\2\2\u0424\u0426\5\u00a2R\2\u0425\u0424\3\2\2\2\u0425")
        buf.write("\u0426\3\2\2\2\u0426\u0427\3\2\2\2\u0427\u0429\7@\2\2")
        buf.write("\u0428\u0416\3\2\2\2\u0428\u041c\3\2\2\2\u0428\u0422\3")
        buf.write("\2\2\2\u0429\u00a5\3\2\2\2\u042a\u042b\bT\1\2\u042b\u044a")
        buf.write("\5\u00aeX\2\u042c\u044a\5\u00a4S\2\u042d\u042e\7!\2\2")
        buf.write("\u042e\u044a\5\u00b2Z\2\u042f\u0430\7?\2\2\u0430\u0431")
        buf.write("\5\u00c6d\2\u0431\u0432\7@\2\2\u0432\u0433\5\u00a6T\27")
        buf.write("\u0433\u044a\3\2\2\2\u0434\u0435\t\5\2\2\u0435\u044a\5")
        buf.write("\u00a6T\25\u0436\u0437\t\6\2\2\u0437\u044a\5\u00a6T\24")
        buf.write("\u0438\u044a\5\u00a8U\2\u0439\u043a\5\u00c6d\2\u043a\u0440")
        buf.write("\7k\2\2\u043b\u043d\5\u00caf\2\u043c\u043b\3\2\2\2\u043c")
        buf.write("\u043d\3\2\2\2\u043d\u043e\3\2\2\2\u043e\u0441\7q\2\2")
        buf.write("\u043f\u0441\7!\2\2\u0440\u043c\3\2\2\2\u0440\u043f\3")
        buf.write("\2\2\2\u0441\u044a\3\2\2\2\u0442\u0443\5\u00b0Y\2\u0443")
        buf.write("\u0445\7k\2\2\u0444\u0446\5\u00caf\2\u0445\u0444\3\2\2")
        buf.write("\2\u0445\u0446\3\2\2\2\u0446\u0447\3\2\2\2\u0447\u0448")
        buf.write("\7!\2\2\u0448\u044a\3\2\2\2\u0449\u042a\3\2\2\2\u0449")
        buf.write("\u042c\3\2\2\2\u0449\u042d\3\2\2\2\u0449\u042f\3\2\2\2")
        buf.write("\u0449\u0434\3\2\2\2\u0449\u0436\3\2\2\2\u0449\u0438\3")
        buf.write("\2\2\2\u0449\u0439\3\2\2\2\u0449\u0442\3\2\2\2\u044a\u049b")
        buf.write("\3\2\2\2\u044b\u044c\f\23\2\2\u044c\u044d\t\7\2\2\u044d")
        buf.write("\u049a\5\u00a6T\24\u044e\u044f\f\22\2\2\u044f\u0450\t")
        buf.write("\b\2\2\u0450\u049a\5\u00a6T\23\u0451\u0459\f\21\2\2\u0452")
        buf.write("\u0453\7J\2\2\u0453\u045a\7J\2\2\u0454\u0455\7I\2\2\u0455")
        buf.write("\u0456\7I\2\2\u0456\u045a\7I\2\2\u0457\u0458\7I\2\2\u0458")
        buf.write("\u045a\7I\2\2\u0459\u0452\3\2\2\2\u0459\u0454\3\2\2\2")
        buf.write("\u0459\u0457\3\2\2\2\u045a\u045b\3\2\2\2\u045b\u049a\5")
        buf.write("\u00a6T\22\u045c\u045d\f\20\2\2\u045d\u045e\t\t\2\2\u045e")
        buf.write("\u049a\5\u00a6T\21\u045f\u0460\f\16\2\2\u0460\u0461\t")
        buf.write("\n\2\2\u0461\u049a\5\u00a6T\17\u0462\u0463\f\r\2\2\u0463")
        buf.write("\u0464\7[\2\2\u0464\u049a\5\u00a6T\16\u0465\u0466\f\f")
        buf.write("\2\2\u0466\u0467\7]\2\2\u0467\u049a\5\u00a6T\r\u0468\u0469")
        buf.write("\f\13\2\2\u0469\u046a\7\\\2\2\u046a\u049a\5\u00a6T\f\u046b")
        buf.write("\u046c\f\n\2\2\u046c\u046d\7S\2\2\u046d\u049a\5\u00a6")
        buf.write("T\13\u046e\u046f\f\t\2\2\u046f\u0470\7T\2\2\u0470\u049a")
        buf.write("\5\u00a6T\n\u0471\u0472\f\b\2\2\u0472\u0473\7M\2\2\u0473")
        buf.write("\u0474\5\u00a6T\2\u0474\u0475\7N\2\2\u0475\u0476\5\u00a6")
        buf.write("T\t\u0476\u049a\3\2\2\2\u0477\u0478\f\7\2\2\u0478\u0479")
        buf.write("\t\13\2\2\u0479\u049a\5\u00a6T\7\u047a\u047b\f\33\2\2")
        buf.write("\u047b\u0487\7G\2\2\u047c\u0488\7q\2\2\u047d\u0488\5\u00a4")
        buf.write("S\2\u047e\u0488\7-\2\2\u047f\u0481\7!\2\2\u0480\u0482")
        buf.write("\5\u00c2b\2\u0481\u0480\3\2\2\2\u0481\u0482\3\2\2\2\u0482")
        buf.write("\u0483\3\2\2\2\u0483\u0488\5\u00b6\\\2\u0484\u0485\7*")
        buf.write("\2\2\u0485\u0488\5\u00ccg\2\u0486\u0488\5\u00bc_\2\u0487")
        buf.write("\u047c\3\2\2\2\u0487\u047d\3\2\2\2\u0487\u047e\3\2\2\2")
        buf.write("\u0487\u047f\3\2\2\2\u0487\u0484\3\2\2\2\u0487\u0486\3")
        buf.write("\2\2\2\u0488\u049a\3\2\2\2\u0489\u048a\f\32\2\2\u048a")
        buf.write("\u048b\7C\2\2\u048b\u048c\5\u00a6T\2\u048c\u048d\7D\2")
        buf.write("\2\u048d\u049a\3\2\2\2\u048e\u048f\f\26\2\2\u048f\u049a")
        buf.write("\t\f\2\2\u0490\u0491\f\17\2\2\u0491\u0492\7\34\2\2\u0492")
        buf.write("\u049a\5\u00c6d\2\u0493\u0494\f\5\2\2\u0494\u0496\7k\2")
        buf.write("\2\u0495\u0497\5\u00caf\2\u0496\u0495\3\2\2\2\u0496\u0497")
        buf.write("\3\2\2\2\u0497\u0498\3\2\2\2\u0498\u049a\7q\2\2\u0499")
        buf.write("\u044b\3\2\2\2\u0499\u044e\3\2\2\2\u0499\u0451\3\2\2\2")
        buf.write("\u0499\u045c\3\2\2\2\u0499\u045f\3\2\2\2\u0499\u0462\3")
        buf.write("\2\2\2\u0499\u0465\3\2\2\2\u0499\u0468\3\2\2\2\u0499\u046b")
        buf.write("\3\2\2\2\u0499\u046e\3\2\2\2\u0499\u0471\3\2\2\2\u0499")
        buf.write("\u0477\3\2\2\2\u0499\u047a\3\2\2\2\u0499\u0489\3\2\2\2")
        buf.write("\u0499\u048e\3\2\2\2\u0499\u0490\3\2\2\2\u0499\u0493\3")
        buf.write("\2\2\2\u049a\u049d\3\2\2\2\u049b\u0499\3\2\2\2\u049b\u049c")
        buf.write("\3\2\2\2\u049c\u00a7\3\2\2\2\u049d\u049b\3\2\2\2\u049e")
        buf.write("\u049f\5\u00aaV\2\u049f\u04a0\7j\2\2\u04a0\u04a1\5\u00ac")
        buf.write("W\2\u04a1\u00a9\3\2\2\2\u04a2\u04b3\7q\2\2\u04a3\u04a5")
        buf.write("\7?\2\2\u04a4\u04a6\5X-\2\u04a5\u04a4\3\2\2\2\u04a5\u04a6")
        buf.write("\3\2\2\2\u04a6\u04a7\3\2\2\2\u04a7\u04b3\7@\2\2\u04a8")
        buf.write("\u04a9\7?\2\2\u04a9\u04ae\7q\2\2\u04aa\u04ab\7F\2\2\u04ab")
        buf.write("\u04ad\7q\2\2\u04ac\u04aa\3\2\2\2\u04ad\u04b0\3\2\2\2")
        buf.write("\u04ae\u04ac\3\2\2\2\u04ae\u04af\3\2\2\2\u04af\u04b1\3")
        buf.write("\2\2\2\u04b0\u04ae\3\2\2\2\u04b1\u04b3\7@\2\2\u04b2\u04a2")
        buf.write("\3\2\2\2\u04b2\u04a3\3\2\2\2\u04b2\u04a8\3\2\2\2\u04b3")
        buf.write("\u00ab\3\2\2\2\u04b4\u04b7\5\u00a6T\2\u04b5\u04b7\5\u0080")
        buf.write("A\2\u04b6\u04b4\3\2\2\2\u04b6\u04b5\3\2\2\2\u04b7\u00ad")
        buf.write("\3\2\2\2\u04b8\u04b9\7?\2\2\u04b9\u04ba\5\u00a6T\2\u04ba")
        buf.write("\u04bb\7@\2\2\u04bb\u04cb\3\2\2\2\u04bc\u04cb\7-\2\2\u04bd")
        buf.write("\u04cb\7*\2\2\u04be\u04cb\5`\61\2\u04bf\u04cb\7q\2\2\u04c0")
        buf.write("\u04c1\5.\30\2\u04c1\u04c2\7G\2\2\u04c2\u04c3\7\13\2\2")
        buf.write("\u04c3\u04cb\3\2\2\2\u04c4\u04c8\5\u00c2b\2\u04c5\u04c9")
        buf.write("\5\u00ceh\2\u04c6\u04c7\7-\2\2\u04c7\u04c9\5\u00d0i\2")
        buf.write("\u04c8\u04c5\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c9\u04cb\3")
        buf.write("\2\2\2\u04ca\u04b8\3\2\2\2\u04ca\u04bc\3\2\2\2\u04ca\u04bd")
        buf.write("\3\2\2\2\u04ca\u04be\3\2\2\2\u04ca\u04bf\3\2\2\2\u04ca")
        buf.write("\u04c0\3\2\2\2\u04ca\u04c4\3\2\2\2\u04cb\u00af\3\2\2\2")
        buf.write("\u04cc\u04cd\5P)\2\u04cd\u04ce\7G\2\2\u04ce\u04d0\3\2")
        buf.write("\2\2\u04cf\u04cc\3\2\2\2\u04cf\u04d0\3\2\2\2\u04d0\u04d4")
        buf.write("\3\2\2\2\u04d1\u04d3\5f\64\2\u04d2\u04d1\3\2\2\2\u04d3")
        buf.write("\u04d6\3\2\2\2\u04d4\u04d2\3\2\2\2\u04d4\u04d5\3\2\2\2")
        buf.write("\u04d5\u04d7\3\2\2\2\u04d6\u04d4\3\2\2\2\u04d7\u04d9\7")
        buf.write("q\2\2\u04d8\u04da\5\u00caf\2\u04d9\u04d8\3\2\2\2\u04d9")
        buf.write("\u04da\3\2\2\2\u04da\u00b1\3\2\2\2\u04db\u04dc\5\u00c2")
        buf.write("b\2\u04dc\u04dd\5\u00b4[\2\u04dd\u04de\5\u00ba^\2\u04de")
        buf.write("\u04e5\3\2\2\2\u04df\u04e2\5\u00b4[\2\u04e0\u04e3\5\u00b8")
        buf.write("]\2\u04e1\u04e3\5\u00ba^\2\u04e2\u04e0\3\2\2\2\u04e2\u04e1")
        buf.write("\3\2\2\2\u04e3\u04e5\3\2\2\2\u04e4\u04db\3\2\2\2\u04e4")
        buf.write("\u04df\3\2\2\2\u04e5\u00b3\3\2\2\2\u04e6\u04e8\7q\2\2")
        buf.write("\u04e7\u04e9\5\u00be`\2\u04e8\u04e7\3\2\2\2\u04e8\u04e9")
        buf.write("\3\2\2\2\u04e9\u04f1\3\2\2\2\u04ea\u04eb\7G\2\2\u04eb")
        buf.write("\u04ed\7q\2\2\u04ec\u04ee\5\u00be`\2\u04ed\u04ec\3\2\2")
        buf.write("\2\u04ed\u04ee\3\2\2\2\u04ee\u04f0\3\2\2\2\u04ef\u04ea")
        buf.write("\3\2\2\2\u04f0\u04f3\3\2\2\2\u04f1\u04ef\3\2\2\2\u04f1")
        buf.write("\u04f2\3\2\2\2\u04f2\u04f6\3\2\2\2\u04f3\u04f1\3\2\2\2")
        buf.write("\u04f4\u04f6\5\u00c8e\2\u04f5\u04e6\3\2\2\2\u04f5\u04f4")
        buf.write("\3\2\2\2\u04f6\u00b5\3\2\2\2\u04f7\u04f9\7q\2\2\u04f8")
        buf.write("\u04fa\5\u00c0a\2\u04f9\u04f8\3\2\2\2\u04f9\u04fa\3\2")
        buf.write("\2\2\u04fa\u04fb\3\2\2\2\u04fb\u04fc\5\u00ba^\2\u04fc")
        buf.write("\u00b7\3\2\2\2\u04fd\u0519\7C\2\2\u04fe\u0503\7D\2\2\u04ff")
        buf.write("\u0500\7C\2\2\u0500\u0502\7D\2\2\u0501\u04ff\3\2\2\2\u0502")
        buf.write("\u0505\3\2\2\2\u0503\u0501\3\2\2\2\u0503\u0504\3\2\2\2")
        buf.write("\u0504\u0506\3\2\2\2\u0505\u0503\3\2\2\2\u0506\u051a\5")
        buf.write("N(\2\u0507\u0508\5\u00a6T\2\u0508\u050f\7D\2\2\u0509\u050a")
        buf.write("\7C\2\2\u050a\u050b\5\u00a6T\2\u050b\u050c\7D\2\2\u050c")
        buf.write("\u050e\3\2\2\2\u050d\u0509\3\2\2\2\u050e\u0511\3\2\2\2")
        buf.write("\u050f\u050d\3\2\2\2\u050f\u0510\3\2\2\2\u0510\u0516\3")
        buf.write("\2\2\2\u0511\u050f\3\2\2\2\u0512\u0513\7C\2\2\u0513\u0515")
        buf.write("\7D\2\2\u0514\u0512\3\2\2\2\u0515\u0518\3\2\2\2\u0516")
        buf.write("\u0514\3\2\2\2\u0516\u0517\3\2\2\2\u0517\u051a\3\2\2\2")
        buf.write("\u0518\u0516\3\2\2\2\u0519\u04fe\3\2\2\2\u0519\u0507\3")
        buf.write("\2\2\2\u051a\u00b9\3\2\2\2\u051b\u051d\5\u00d0i\2\u051c")
        buf.write("\u051e\5\"\22\2\u051d\u051c\3\2\2\2\u051d\u051e\3\2\2")
        buf.write("\2\u051e\u00bb\3\2\2\2\u051f\u0520\5\u00c2b\2\u0520\u0521")
        buf.write("\5\u00ceh\2\u0521\u00bd\3\2\2\2\u0522\u0523\7J\2\2\u0523")
        buf.write("\u0526\7I\2\2\u0524\u0526\5\u00caf\2\u0525\u0522\3\2\2")
        buf.write("\2\u0525\u0524\3\2\2\2\u0526\u00bf\3\2\2\2\u0527\u0528")
        buf.write("\7J\2\2\u0528\u052b\7I\2\2\u0529\u052b\5\u00c2b\2\u052a")
        buf.write("\u0527\3\2\2\2\u052a\u0529\3\2\2\2\u052b\u00c1\3\2\2\2")
        buf.write("\u052c\u052d\7J\2\2\u052d\u052e\5\u00c4c\2\u052e\u052f")
        buf.write("\7I\2\2\u052f\u00c3\3\2\2\2\u0530\u0535\5\u00c6d\2\u0531")
        buf.write("\u0532\7F\2\2\u0532\u0534\5\u00c6d\2\u0533\u0531\3\2\2")
        buf.write("\2\u0534\u0537\3\2\2\2\u0535\u0533\3\2\2\2\u0535\u0536")
        buf.write("\3\2\2\2\u0536\u00c5\3\2\2\2\u0537\u0535\3\2\2\2\u0538")
        buf.write("\u053a\5f\64\2\u0539\u0538\3\2\2\2\u0539\u053a\3\2\2\2")
        buf.write("\u053a\u053d\3\2\2\2\u053b\u053e\5P)\2\u053c\u053e\5\u00c8")
        buf.write("e\2\u053d\u053b\3\2\2\2\u053d\u053c\3\2\2\2\u053e\u0543")
        buf.write("\3\2\2\2\u053f\u0540\7C\2\2\u0540\u0542\7D\2\2\u0541\u053f")
        buf.write("\3\2\2\2\u0542\u0545\3\2\2\2\u0543\u0541\3\2\2\2\u0543")
        buf.write("\u0544\3\2\2\2\u0544\u00c7\3\2\2\2\u0545\u0543\3\2\2\2")
        buf.write("\u0546\u0547\t\r\2\2\u0547\u00c9\3\2\2\2\u0548\u0549\7")
        buf.write("J\2\2\u0549\u054e\5R*\2\u054a\u054b\7F\2\2\u054b\u054d")
        buf.write("\5R*\2\u054c\u054a\3\2\2\2\u054d\u0550\3\2\2\2\u054e\u054c")
        buf.write("\3\2\2\2\u054e\u054f\3\2\2\2\u054f\u0551\3\2\2\2\u0550")
        buf.write("\u054e\3\2\2\2\u0551\u0552\7I\2\2\u0552\u00cb\3\2\2\2")
        buf.write("\u0553\u055a\5\u00d0i\2\u0554\u0555\7G\2\2\u0555\u0557")
        buf.write("\7q\2\2\u0556\u0558\5\u00d0i\2\u0557\u0556\3\2\2\2\u0557")
        buf.write("\u0558\3\2\2\2\u0558\u055a\3\2\2\2\u0559\u0553\3\2\2\2")
        buf.write("\u0559\u0554\3\2\2\2\u055a\u00cd\3\2\2\2\u055b\u055c\7")
        buf.write("*\2\2\u055c\u0560\5\u00ccg\2\u055d\u055e\7q\2\2\u055e")
        buf.write("\u0560\5\u00d0i\2\u055f\u055b\3\2\2\2\u055f\u055d\3\2")
        buf.write("\2\2\u0560\u00cf\3\2\2\2\u0561\u0563\7?\2\2\u0562\u0564")
        buf.write("\5\u00a2R\2\u0563\u0562\3\2\2\2\u0563\u0564\3\2\2\2\u0564")
        buf.write("\u0565\3\2\2\2\u0565\u0566\7@\2\2\u0566\u00d1\3\2\2\2")
        buf.write("\u00ad\u00d3\u00d8\u00de\u00e6\u00ef\u00f4\u00fb\u0102")
        buf.write("\u0105\u010c\u0116\u011a\u011f\u0123\u0127\u0131\u0139")
        buf.write("\u013f\u0146\u014d\u0151\u0154\u0157\u0160\u0166\u016b")
        buf.write("\u016e\u0174\u017a\u017e\u0186\u018f\u0196\u019c\u01a0")
        buf.write("\u01ab\u01b4\u01b9\u01bf\u01c3\u01cf\u01da\u01df\u01e8")
        buf.write("\u01f0\u01fa\u0203\u020b\u0210\u0218\u021d\u0227\u0231")
        buf.write("\u0237\u023e\u0243\u024b\u024f\u0251\u0257\u025c\u0260")
        buf.write("\u0267\u0269\u0270\u0275\u027e\u0283\u0286\u028b\u0294")
        buf.write("\u02a0\u02a9\u02b4\u02b7\u02be\u02c8\u02d0\u02d3\u02d6")
        buf.write("\u02e3\u02eb\u02f0\u02f8\u02fc\u0300\u0304\u0306\u030a")
        buf.write("\u0310\u031b\u0325\u032a\u0333\u0338\u033b\u0342\u034b")
        buf.write("\u0362\u0365\u0368\u0370\u0374\u037c\u0382\u038d\u0396")
        buf.write("\u039b\u03a5\u03ac\u03b9\u03c2\u03cb\u03d1\u03dc\u03e1")
        buf.write("\u03e6\u03eb\u03ef\u03f3\u03f7\u03f9\u03fd\u0402\u0413")
        buf.write("\u0419\u041f\u0425\u0428\u043c\u0440\u0445\u0449\u0459")
        buf.write("\u0481\u0487\u0496\u0499\u049b\u04a5\u04ae\u04b2\u04b6")
        buf.write("\u04c8\u04ca\u04cf\u04d4\u04d9\u04e2\u04e4\u04e8\u04ed")
        buf.write("\u04f1\u04f5\u04f9\u0503\u050f\u0516\u0519\u051d\u0525")
        buf.write("\u052a\u0535\u0539\u053d\u0543\u054e\u0557\u0559\u055f")
        buf.write("\u0563")
        return buf.getvalue()


class Java8Parser ( Parser ):

    grammarFileName = "Java8Parser.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'abstract'", "'assert'", "'boolean'", 
                     "'break'", "'byte'", "'case'", "'catch'", "'char'", 
                     "'class'", "'const'", "'continue'", "'default'", "'do'", 
                     "'double'", "'else'", "'enum'", "'extends'", "'final'", 
                     "'finally'", "'float'", "'for'", "'if'", "'goto'", 
                     "'implements'", "'import'", "'instanceof'", "'int'", 
                     "'interface'", "'long'", "'native'", "'new'", "'package'", 
                     "'private'", "'protected'", "'public'", "'return'", 
                     "'short'", "'static'", "'strictfp'", "'super'", "'switch'", 
                     "'synchronized'", "'this'", "'throw'", "'throws'", 
                     "'transient'", "'try'", "'void'", "'volatile'", "'while'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'null'", "'('", "')'", "'{'", "'}'", 
                     "'['", "']'", "';'", "','", "'.'", "'='", "'>'", "'<'", 
                     "'!'", "'~'", "'?'", "':'", "'=='", "'<='", "'>='", 
                     "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", "'-'", 
                     "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'+='", "'-='", 
                     "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", 
                     "'>>='", "'>>>='", "'->'", "'::'", "'@'", "'...'" ]

    symbolicNames = [ "<INVALID>", "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", 
                      "BYTE", "CASE", "CATCH", "CHAR", "CLASS", "CONST", 
                      "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", 
                      "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", 
                      "GOTO", "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", 
                      "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", "PRIVATE", 
                      "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", 
                      "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", 
                      "THROW", "THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", 
                      "WHILE", "DECIMAL_LITERAL", "HEX_LITERAL", "OCT_LITERAL", 
                      "BINARY_LITERAL", "FLOAT_LITERAL", "HEX_FLOAT_LITERAL", 
                      "BOOL_LITERAL", "CHAR_LITERAL", "STRING_LITERAL", 
                      "NULL_LITERAL", "LPAREN", "RPAREN", "LBRACE", "RBRACE", 
                      "LBRACK", "RBRACK", "SEMI", "COMMA", "DOT", "ASSIGN", 
                      "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", 
                      "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", 
                      "DEC", "ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", 
                      "CARET", "MOD", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", 
                      "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", 
                      "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", 
                      "ARROW", "COLONCOLON", "AT", "ELLIPSIS", "WS", "COMMENT", 
                      "LINE_COMMENT", "IDENTIFIER" ]

    RULE_compilationUnit = 0
    RULE_packageDeclaration = 1
    RULE_importDeclaration = 2
    RULE_typeDeclaration = 3
    RULE_modifier = 4
    RULE_classOrInterfaceModifier = 5
    RULE_variableModifier = 6
    RULE_classDeclaration = 7
    RULE_typeParameters = 8
    RULE_typeParameter = 9
    RULE_typeBound = 10
    RULE_enumDeclaration = 11
    RULE_enumConstants = 12
    RULE_enumConstant = 13
    RULE_enumBodyDeclarations = 14
    RULE_interfaceDeclaration = 15
    RULE_classBody = 16
    RULE_interfaceBody = 17
    RULE_classBodyDeclaration = 18
    RULE_memberDeclaration = 19
    RULE_methodDeclaration = 20
    RULE_methodBody = 21
    RULE_typeTypeOrVoid = 22
    RULE_genericMethodDeclaration = 23
    RULE_genericConstructorDeclaration = 24
    RULE_constructorDeclaration = 25
    RULE_fieldDeclaration = 26
    RULE_interfaceBodyDeclaration = 27
    RULE_interfaceMemberDeclaration = 28
    RULE_constDeclaration = 29
    RULE_constantDeclarator = 30
    RULE_interfaceMethodDeclaration = 31
    RULE_interfaceMethodModifier = 32
    RULE_genericInterfaceMethodDeclaration = 33
    RULE_variableDeclarators = 34
    RULE_variableDeclarator = 35
    RULE_variableDeclaratorId = 36
    RULE_variableInitializer = 37
    RULE_arrayInitializer = 38
    RULE_classOrInterfaceType = 39
    RULE_typeArgument = 40
    RULE_qualifiedNameList = 41
    RULE_formalParameters = 42
    RULE_formalParameterList = 43
    RULE_formalParameter = 44
    RULE_lastFormalParameter = 45
    RULE_qualifiedName = 46
    RULE_literal = 47
    RULE_integerLiteral = 48
    RULE_floatLiteral = 49
    RULE_annotation = 50
    RULE_elementValuePairs = 51
    RULE_elementValuePair = 52
    RULE_elementValue = 53
    RULE_elementValueArrayInitializer = 54
    RULE_annotationTypeDeclaration = 55
    RULE_annotationTypeBody = 56
    RULE_annotationTypeElementDeclaration = 57
    RULE_annotationTypeElementRest = 58
    RULE_annotationMethodOrConstantRest = 59
    RULE_annotationMethodRest = 60
    RULE_annotationConstantRest = 61
    RULE_defaultValue = 62
    RULE_block = 63
    RULE_blockStatement = 64
    RULE_localVariableDeclaration = 65
    RULE_localTypeDeclaration = 66
    RULE_statement = 67
    RULE_catchClause = 68
    RULE_catchType = 69
    RULE_finallyBlock = 70
    RULE_resourceSpecification = 71
    RULE_resources = 72
    RULE_resource = 73
    RULE_switchBlockStatementGroup = 74
    RULE_switchLabel = 75
    RULE_forControl = 76
    RULE_forInit = 77
    RULE_enhancedForControl = 78
    RULE_parExpression = 79
    RULE_expressionList = 80
    RULE_methodCall = 81
    RULE_expression = 82
    RULE_lambdaExpression = 83
    RULE_lambdaParameters = 84
    RULE_lambdaBody = 85
    RULE_primary = 86
    RULE_classType = 87
    RULE_creator = 88
    RULE_createdName = 89
    RULE_innerCreator = 90
    RULE_arrayCreatorRest = 91
    RULE_classCreatorRest = 92
    RULE_explicitGenericInvocation = 93
    RULE_typeArgumentsOrDiamond = 94
    RULE_nonWildcardTypeArgumentsOrDiamond = 95
    RULE_nonWildcardTypeArguments = 96
    RULE_typeList = 97
    RULE_typeType = 98
    RULE_primitiveType = 99
    RULE_typeArguments = 100
    RULE_superSuffix = 101
    RULE_explicitGenericInvocationSuffix = 102
    RULE_arguments = 103

    ruleNames =  [ "compilationUnit", "packageDeclaration", "importDeclaration", 
                   "typeDeclaration", "modifier", "classOrInterfaceModifier", 
                   "variableModifier", "classDeclaration", "typeParameters", 
                   "typeParameter", "typeBound", "enumDeclaration", "enumConstants", 
                   "enumConstant", "enumBodyDeclarations", "interfaceDeclaration", 
                   "classBody", "interfaceBody", "classBodyDeclaration", 
                   "memberDeclaration", "methodDeclaration", "methodBody", 
                   "typeTypeOrVoid", "genericMethodDeclaration", "genericConstructorDeclaration", 
                   "constructorDeclaration", "fieldDeclaration", "interfaceBodyDeclaration", 
                   "interfaceMemberDeclaration", "constDeclaration", "constantDeclarator", 
                   "interfaceMethodDeclaration", "interfaceMethodModifier", 
                   "genericInterfaceMethodDeclaration", "variableDeclarators", 
                   "variableDeclarator", "variableDeclaratorId", "variableInitializer", 
                   "arrayInitializer", "classOrInterfaceType", "typeArgument", 
                   "qualifiedNameList", "formalParameters", "formalParameterList", 
                   "formalParameter", "lastFormalParameter", "qualifiedName", 
                   "literal", "integerLiteral", "floatLiteral", "annotation", 
                   "elementValuePairs", "elementValuePair", "elementValue", 
                   "elementValueArrayInitializer", "annotationTypeDeclaration", 
                   "annotationTypeBody", "annotationTypeElementDeclaration", 
                   "annotationTypeElementRest", "annotationMethodOrConstantRest", 
                   "annotationMethodRest", "annotationConstantRest", "defaultValue", 
                   "block", "blockStatement", "localVariableDeclaration", 
                   "localTypeDeclaration", "statement", "catchClause", "catchType", 
                   "finallyBlock", "resourceSpecification", "resources", 
                   "resource", "switchBlockStatementGroup", "switchLabel", 
                   "forControl", "forInit", "enhancedForControl", "parExpression", 
                   "expressionList", "methodCall", "expression", "lambdaExpression", 
                   "lambdaParameters", "lambdaBody", "primary", "classType", 
                   "creator", "createdName", "innerCreator", "arrayCreatorRest", 
                   "classCreatorRest", "explicitGenericInvocation", "typeArgumentsOrDiamond", 
                   "nonWildcardTypeArgumentsOrDiamond", "nonWildcardTypeArguments", 
                   "typeList", "typeType", "primitiveType", "typeArguments", 
                   "superSuffix", "explicitGenericInvocationSuffix", "arguments" ]

    EOF = Token.EOF
    ABSTRACT=1
    ASSERT=2
    BOOLEAN=3
    BREAK=4
    BYTE=5
    CASE=6
    CATCH=7
    CHAR=8
    CLASS=9
    CONST=10
    CONTINUE=11
    DEFAULT=12
    DO=13
    DOUBLE=14
    ELSE=15
    ENUM=16
    EXTENDS=17
    FINAL=18
    FINALLY=19
    FLOAT=20
    FOR=21
    IF=22
    GOTO=23
    IMPLEMENTS=24
    IMPORT=25
    INSTANCEOF=26
    INT=27
    INTERFACE=28
    LONG=29
    NATIVE=30
    NEW=31
    PACKAGE=32
    PRIVATE=33
    PROTECTED=34
    PUBLIC=35
    RETURN=36
    SHORT=37
    STATIC=38
    STRICTFP=39
    SUPER=40
    SWITCH=41
    SYNCHRONIZED=42
    THIS=43
    THROW=44
    THROWS=45
    TRANSIENT=46
    TRY=47
    VOID=48
    VOLATILE=49
    WHILE=50
    DECIMAL_LITERAL=51
    HEX_LITERAL=52
    OCT_LITERAL=53
    BINARY_LITERAL=54
    FLOAT_LITERAL=55
    HEX_FLOAT_LITERAL=56
    BOOL_LITERAL=57
    CHAR_LITERAL=58
    STRING_LITERAL=59
    NULL_LITERAL=60
    LPAREN=61
    RPAREN=62
    LBRACE=63
    RBRACE=64
    LBRACK=65
    RBRACK=66
    SEMI=67
    COMMA=68
    DOT=69
    ASSIGN=70
    GT=71
    LT=72
    BANG=73
    TILDE=74
    QUESTION=75
    COLON=76
    EQUAL=77
    LE=78
    GE=79
    NOTEQUAL=80
    AND=81
    OR=82
    INC=83
    DEC=84
    ADD=85
    SUB=86
    MUL=87
    DIV=88
    BITAND=89
    BITOR=90
    CARET=91
    MOD=92
    ADD_ASSIGN=93
    SUB_ASSIGN=94
    MUL_ASSIGN=95
    DIV_ASSIGN=96
    AND_ASSIGN=97
    OR_ASSIGN=98
    XOR_ASSIGN=99
    MOD_ASSIGN=100
    LSHIFT_ASSIGN=101
    RSHIFT_ASSIGN=102
    URSHIFT_ASSIGN=103
    ARROW=104
    COLONCOLON=105
    AT=106
    ELLIPSIS=107
    WS=108
    COMMENT=109
    LINE_COMMENT=110
    IDENTIFIER=111

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




    class CompilationUnitContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def EOF(self):
            return self.getToken(Java8Parser.EOF, 0)

        def packageDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.PackageDeclarationContext,0)


        def importDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ImportDeclarationContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ImportDeclarationContext,i)


        def typeDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.TypeDeclarationContext)
            else:
                return self.getTypedRuleContext(Java8Parser.TypeDeclarationContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_compilationUnit




    def compilationUnit(self):

        localctx = Java8Parser.CompilationUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_compilationUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 209
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
            if la_ == 1:
                self.state = 208
                self.packageDeclaration()


            self.state = 214
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.IMPORT:
                self.state = 211
                self.importDeclaration()
                self.state = 216
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 220
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.ABSTRACT) | (1 << Java8Parser.CLASS) | (1 << Java8Parser.ENUM) | (1 << Java8Parser.FINAL) | (1 << Java8Parser.INTERFACE) | (1 << Java8Parser.PRIVATE) | (1 << Java8Parser.PROTECTED) | (1 << Java8Parser.PUBLIC) | (1 << Java8Parser.STATIC) | (1 << Java8Parser.STRICTFP))) != 0) or _la==Java8Parser.SEMI or _la==Java8Parser.AT:
                self.state = 217
                self.typeDeclaration()
                self.state = 222
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 223
            self.match(Java8Parser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PackageDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PACKAGE(self):
            return self.getToken(Java8Parser.PACKAGE, 0)

        def qualifiedName(self):
            return self.getTypedRuleContext(Java8Parser.QualifiedNameContext,0)


        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

        def annotation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.AnnotationContext)
            else:
                return self.getTypedRuleContext(Java8Parser.AnnotationContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_packageDeclaration




    def packageDeclaration(self):

        localctx = Java8Parser.PackageDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_packageDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 228
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.AT:
                self.state = 225
                self.annotation()
                self.state = 230
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 231
            self.match(Java8Parser.PACKAGE)
            self.state = 232
            self.qualifiedName()
            self.state = 233
            self.match(Java8Parser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ImportDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IMPORT(self):
            return self.getToken(Java8Parser.IMPORT, 0)

        def qualifiedName(self):
            return self.getTypedRuleContext(Java8Parser.QualifiedNameContext,0)


        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

        def STATIC(self):
            return self.getToken(Java8Parser.STATIC, 0)

        def DOT(self):
            return self.getToken(Java8Parser.DOT, 0)

        def MUL(self):
            return self.getToken(Java8Parser.MUL, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_importDeclaration




    def importDeclaration(self):

        localctx = Java8Parser.ImportDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_importDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 235
            self.match(Java8Parser.IMPORT)
            self.state = 237
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.STATIC:
                self.state = 236
                self.match(Java8Parser.STATIC)


            self.state = 239
            self.qualifiedName()
            self.state = 242
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.DOT:
                self.state = 240
                self.match(Java8Parser.DOT)
                self.state = 241
                self.match(Java8Parser.MUL)


            self.state = 244
            self.match(Java8Parser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def classDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.ClassDeclarationContext,0)


        def enumDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.EnumDeclarationContext,0)


        def interfaceDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.InterfaceDeclarationContext,0)


        def annotationTypeDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.AnnotationTypeDeclarationContext,0)


        def classOrInterfaceModifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ClassOrInterfaceModifierContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ClassOrInterfaceModifierContext,i)


        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_typeDeclaration




    def typeDeclaration(self):

        localctx = Java8Parser.TypeDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_typeDeclaration)
        try:
            self.state = 259
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.ABSTRACT, Java8Parser.CLASS, Java8Parser.ENUM, Java8Parser.FINAL, Java8Parser.INTERFACE, Java8Parser.PRIVATE, Java8Parser.PROTECTED, Java8Parser.PUBLIC, Java8Parser.STATIC, Java8Parser.STRICTFP, Java8Parser.AT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 249
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,6,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 246
                        self.classOrInterfaceModifier() 
                    self.state = 251
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,6,self._ctx)

                self.state = 256
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [Java8Parser.CLASS]:
                    self.state = 252
                    self.classDeclaration()
                    pass
                elif token in [Java8Parser.ENUM]:
                    self.state = 253
                    self.enumDeclaration()
                    pass
                elif token in [Java8Parser.INTERFACE]:
                    self.state = 254
                    self.interfaceDeclaration()
                    pass
                elif token in [Java8Parser.AT]:
                    self.state = 255
                    self.annotationTypeDeclaration()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [Java8Parser.SEMI]:
                self.enterOuterAlt(localctx, 2)
                self.state = 258
                self.match(Java8Parser.SEMI)
                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 ModifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def classOrInterfaceModifier(self):
            return self.getTypedRuleContext(Java8Parser.ClassOrInterfaceModifierContext,0)


        def NATIVE(self):
            return self.getToken(Java8Parser.NATIVE, 0)

        def SYNCHRONIZED(self):
            return self.getToken(Java8Parser.SYNCHRONIZED, 0)

        def TRANSIENT(self):
            return self.getToken(Java8Parser.TRANSIENT, 0)

        def VOLATILE(self):
            return self.getToken(Java8Parser.VOLATILE, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_modifier




    def modifier(self):

        localctx = Java8Parser.ModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_modifier)
        try:
            self.state = 266
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.ABSTRACT, Java8Parser.FINAL, Java8Parser.PRIVATE, Java8Parser.PROTECTED, Java8Parser.PUBLIC, Java8Parser.STATIC, Java8Parser.STRICTFP, Java8Parser.AT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 261
                self.classOrInterfaceModifier()
                pass
            elif token in [Java8Parser.NATIVE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 262
                self.match(Java8Parser.NATIVE)
                pass
            elif token in [Java8Parser.SYNCHRONIZED]:
                self.enterOuterAlt(localctx, 3)
                self.state = 263
                self.match(Java8Parser.SYNCHRONIZED)
                pass
            elif token in [Java8Parser.TRANSIENT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 264
                self.match(Java8Parser.TRANSIENT)
                pass
            elif token in [Java8Parser.VOLATILE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 265
                self.match(Java8Parser.VOLATILE)
                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 ClassOrInterfaceModifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def annotation(self):
            return self.getTypedRuleContext(Java8Parser.AnnotationContext,0)


        def PUBLIC(self):
            return self.getToken(Java8Parser.PUBLIC, 0)

        def PROTECTED(self):
            return self.getToken(Java8Parser.PROTECTED, 0)

        def PRIVATE(self):
            return self.getToken(Java8Parser.PRIVATE, 0)

        def STATIC(self):
            return self.getToken(Java8Parser.STATIC, 0)

        def ABSTRACT(self):
            return self.getToken(Java8Parser.ABSTRACT, 0)

        def FINAL(self):
            return self.getToken(Java8Parser.FINAL, 0)

        def STRICTFP(self):
            return self.getToken(Java8Parser.STRICTFP, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_classOrInterfaceModifier




    def classOrInterfaceModifier(self):

        localctx = Java8Parser.ClassOrInterfaceModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_classOrInterfaceModifier)
        try:
            self.state = 276
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.AT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 268
                self.annotation()
                pass
            elif token in [Java8Parser.PUBLIC]:
                self.enterOuterAlt(localctx, 2)
                self.state = 269
                self.match(Java8Parser.PUBLIC)
                pass
            elif token in [Java8Parser.PROTECTED]:
                self.enterOuterAlt(localctx, 3)
                self.state = 270
                self.match(Java8Parser.PROTECTED)
                pass
            elif token in [Java8Parser.PRIVATE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 271
                self.match(Java8Parser.PRIVATE)
                pass
            elif token in [Java8Parser.STATIC]:
                self.enterOuterAlt(localctx, 5)
                self.state = 272
                self.match(Java8Parser.STATIC)
                pass
            elif token in [Java8Parser.ABSTRACT]:
                self.enterOuterAlt(localctx, 6)
                self.state = 273
                self.match(Java8Parser.ABSTRACT)
                pass
            elif token in [Java8Parser.FINAL]:
                self.enterOuterAlt(localctx, 7)
                self.state = 274
                self.match(Java8Parser.FINAL)
                pass
            elif token in [Java8Parser.STRICTFP]:
                self.enterOuterAlt(localctx, 8)
                self.state = 275
                self.match(Java8Parser.STRICTFP)
                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 VariableModifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FINAL(self):
            return self.getToken(Java8Parser.FINAL, 0)

        def annotation(self):
            return self.getTypedRuleContext(Java8Parser.AnnotationContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_variableModifier




    def variableModifier(self):

        localctx = Java8Parser.VariableModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_variableModifier)
        try:
            self.state = 280
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.FINAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 278
                self.match(Java8Parser.FINAL)
                pass
            elif token in [Java8Parser.AT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 279
                self.annotation()
                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 ClassDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CLASS(self):
            return self.getToken(Java8Parser.CLASS, 0)

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def classBody(self):
            return self.getTypedRuleContext(Java8Parser.ClassBodyContext,0)


        def typeParameters(self):
            return self.getTypedRuleContext(Java8Parser.TypeParametersContext,0)


        def EXTENDS(self):
            return self.getToken(Java8Parser.EXTENDS, 0)

        def typeType(self):
            return self.getTypedRuleContext(Java8Parser.TypeTypeContext,0)


        def IMPLEMENTS(self):
            return self.getToken(Java8Parser.IMPLEMENTS, 0)

        def typeList(self):
            return self.getTypedRuleContext(Java8Parser.TypeListContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_classDeclaration




    def classDeclaration(self):

        localctx = Java8Parser.ClassDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_classDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 282
            self.match(Java8Parser.CLASS)
            self.state = 283
            self.match(Java8Parser.IDENTIFIER)
            self.state = 285
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.LT:
                self.state = 284
                self.typeParameters()


            self.state = 289
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.EXTENDS:
                self.state = 287
                self.match(Java8Parser.EXTENDS)
                self.state = 288
                self.typeType()


            self.state = 293
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.IMPLEMENTS:
                self.state = 291
                self.match(Java8Parser.IMPLEMENTS)
                self.state = 292
                self.typeList()


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


    class TypeParametersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LT(self):
            return self.getToken(Java8Parser.LT, 0)

        def typeParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.TypeParameterContext)
            else:
                return self.getTypedRuleContext(Java8Parser.TypeParameterContext,i)


        def GT(self):
            return self.getToken(Java8Parser.GT, 0)

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

        def getRuleIndex(self):
            return Java8Parser.RULE_typeParameters




    def typeParameters(self):

        localctx = Java8Parser.TypeParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_typeParameters)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 297
            self.match(Java8Parser.LT)
            self.state = 298
            self.typeParameter()
            self.state = 303
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.COMMA:
                self.state = 299
                self.match(Java8Parser.COMMA)
                self.state = 300
                self.typeParameter()
                self.state = 305
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 306
            self.match(Java8Parser.GT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeParameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def annotation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.AnnotationContext)
            else:
                return self.getTypedRuleContext(Java8Parser.AnnotationContext,i)


        def EXTENDS(self):
            return self.getToken(Java8Parser.EXTENDS, 0)

        def typeBound(self):
            return self.getTypedRuleContext(Java8Parser.TypeBoundContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_typeParameter




    def typeParameter(self):

        localctx = Java8Parser.TypeParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_typeParameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 311
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.AT:
                self.state = 308
                self.annotation()
                self.state = 313
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 314
            self.match(Java8Parser.IDENTIFIER)
            self.state = 317
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.EXTENDS:
                self.state = 315
                self.match(Java8Parser.EXTENDS)
                self.state = 316
                self.typeBound()


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


    class TypeBoundContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.TypeTypeContext)
            else:
                return self.getTypedRuleContext(Java8Parser.TypeTypeContext,i)


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

        def getRuleIndex(self):
            return Java8Parser.RULE_typeBound




    def typeBound(self):

        localctx = Java8Parser.TypeBoundContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_typeBound)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 319
            self.typeType()
            self.state = 324
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.BITAND:
                self.state = 320
                self.match(Java8Parser.BITAND)
                self.state = 321
                self.typeType()
                self.state = 326
                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 EnumDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def LBRACE(self):
            return self.getToken(Java8Parser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(Java8Parser.RBRACE, 0)

        def IMPLEMENTS(self):
            return self.getToken(Java8Parser.IMPLEMENTS, 0)

        def typeList(self):
            return self.getTypedRuleContext(Java8Parser.TypeListContext,0)


        def enumConstants(self):
            return self.getTypedRuleContext(Java8Parser.EnumConstantsContext,0)


        def COMMA(self):
            return self.getToken(Java8Parser.COMMA, 0)

        def enumBodyDeclarations(self):
            return self.getTypedRuleContext(Java8Parser.EnumBodyDeclarationsContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_enumDeclaration




    def enumDeclaration(self):

        localctx = Java8Parser.EnumDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_enumDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 327
            self.match(Java8Parser.ENUM)
            self.state = 328
            self.match(Java8Parser.IDENTIFIER)
            self.state = 331
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.IMPLEMENTS:
                self.state = 329
                self.match(Java8Parser.IMPLEMENTS)
                self.state = 330
                self.typeList()


            self.state = 333
            self.match(Java8Parser.LBRACE)
            self.state = 335
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.AT or _la==Java8Parser.IDENTIFIER:
                self.state = 334
                self.enumConstants()


            self.state = 338
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.COMMA:
                self.state = 337
                self.match(Java8Parser.COMMA)


            self.state = 341
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.SEMI:
                self.state = 340
                self.enumBodyDeclarations()


            self.state = 343
            self.match(Java8Parser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumConstantsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def enumConstant(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.EnumConstantContext)
            else:
                return self.getTypedRuleContext(Java8Parser.EnumConstantContext,i)


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

        def getRuleIndex(self):
            return Java8Parser.RULE_enumConstants




    def enumConstants(self):

        localctx = Java8Parser.EnumConstantsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_enumConstants)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 345
            self.enumConstant()
            self.state = 350
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,23,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 346
                    self.match(Java8Parser.COMMA)
                    self.state = 347
                    self.enumConstant() 
                self.state = 352
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,23,self._ctx)

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


    class EnumConstantContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def annotation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.AnnotationContext)
            else:
                return self.getTypedRuleContext(Java8Parser.AnnotationContext,i)


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


        def classBody(self):
            return self.getTypedRuleContext(Java8Parser.ClassBodyContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_enumConstant




    def enumConstant(self):

        localctx = Java8Parser.EnumConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_enumConstant)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 356
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.AT:
                self.state = 353
                self.annotation()
                self.state = 358
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 359
            self.match(Java8Parser.IDENTIFIER)
            self.state = 361
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.LPAREN:
                self.state = 360
                self.arguments()


            self.state = 364
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.LBRACE:
                self.state = 363
                self.classBody()


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


    class EnumBodyDeclarationsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

        def classBodyDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ClassBodyDeclarationContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ClassBodyDeclarationContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_enumBodyDeclarations




    def enumBodyDeclarations(self):

        localctx = Java8Parser.EnumBodyDeclarationsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_enumBodyDeclarations)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 366
            self.match(Java8Parser.SEMI)
            self.state = 370
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.ABSTRACT) | (1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.CLASS) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.ENUM) | (1 << Java8Parser.FINAL) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.INTERFACE) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NATIVE) | (1 << Java8Parser.PRIVATE) | (1 << Java8Parser.PROTECTED) | (1 << Java8Parser.PUBLIC) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.STATIC) | (1 << Java8Parser.STRICTFP) | (1 << Java8Parser.SYNCHRONIZED) | (1 << Java8Parser.TRANSIENT) | (1 << Java8Parser.VOID) | (1 << Java8Parser.VOLATILE) | (1 << Java8Parser.LBRACE))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (Java8Parser.SEMI - 67)) | (1 << (Java8Parser.LT - 67)) | (1 << (Java8Parser.AT - 67)) | (1 << (Java8Parser.IDENTIFIER - 67)))) != 0):
                self.state = 367
                self.classBodyDeclaration()
                self.state = 372
                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 InterfaceDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def interfaceBody(self):
            return self.getTypedRuleContext(Java8Parser.InterfaceBodyContext,0)


        def typeParameters(self):
            return self.getTypedRuleContext(Java8Parser.TypeParametersContext,0)


        def EXTENDS(self):
            return self.getToken(Java8Parser.EXTENDS, 0)

        def typeList(self):
            return self.getTypedRuleContext(Java8Parser.TypeListContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_interfaceDeclaration




    def interfaceDeclaration(self):

        localctx = Java8Parser.InterfaceDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_interfaceDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 373
            self.match(Java8Parser.INTERFACE)
            self.state = 374
            self.match(Java8Parser.IDENTIFIER)
            self.state = 376
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.LT:
                self.state = 375
                self.typeParameters()


            self.state = 380
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.EXTENDS:
                self.state = 378
                self.match(Java8Parser.EXTENDS)
                self.state = 379
                self.typeList()


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


    class ClassBodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LBRACE(self):
            return self.getToken(Java8Parser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(Java8Parser.RBRACE, 0)

        def classBodyDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ClassBodyDeclarationContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ClassBodyDeclarationContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_classBody




    def classBody(self):

        localctx = Java8Parser.ClassBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_classBody)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 384
            self.match(Java8Parser.LBRACE)
            self.state = 388
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.ABSTRACT) | (1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.CLASS) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.ENUM) | (1 << Java8Parser.FINAL) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.INTERFACE) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NATIVE) | (1 << Java8Parser.PRIVATE) | (1 << Java8Parser.PROTECTED) | (1 << Java8Parser.PUBLIC) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.STATIC) | (1 << Java8Parser.STRICTFP) | (1 << Java8Parser.SYNCHRONIZED) | (1 << Java8Parser.TRANSIENT) | (1 << Java8Parser.VOID) | (1 << Java8Parser.VOLATILE) | (1 << Java8Parser.LBRACE))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (Java8Parser.SEMI - 67)) | (1 << (Java8Parser.LT - 67)) | (1 << (Java8Parser.AT - 67)) | (1 << (Java8Parser.IDENTIFIER - 67)))) != 0):
                self.state = 385
                self.classBodyDeclaration()
                self.state = 390
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 391
            self.match(Java8Parser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InterfaceBodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LBRACE(self):
            return self.getToken(Java8Parser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(Java8Parser.RBRACE, 0)

        def interfaceBodyDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.InterfaceBodyDeclarationContext)
            else:
                return self.getTypedRuleContext(Java8Parser.InterfaceBodyDeclarationContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_interfaceBody




    def interfaceBody(self):

        localctx = Java8Parser.InterfaceBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_interfaceBody)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 393
            self.match(Java8Parser.LBRACE)
            self.state = 397
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.ABSTRACT) | (1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.CLASS) | (1 << Java8Parser.DEFAULT) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.ENUM) | (1 << Java8Parser.FINAL) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.INTERFACE) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NATIVE) | (1 << Java8Parser.PRIVATE) | (1 << Java8Parser.PROTECTED) | (1 << Java8Parser.PUBLIC) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.STATIC) | (1 << Java8Parser.STRICTFP) | (1 << Java8Parser.SYNCHRONIZED) | (1 << Java8Parser.TRANSIENT) | (1 << Java8Parser.VOID) | (1 << Java8Parser.VOLATILE))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (Java8Parser.SEMI - 67)) | (1 << (Java8Parser.LT - 67)) | (1 << (Java8Parser.AT - 67)) | (1 << (Java8Parser.IDENTIFIER - 67)))) != 0):
                self.state = 394
                self.interfaceBodyDeclaration()
                self.state = 399
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 400
            self.match(Java8Parser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassBodyDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

        def block(self):
            return self.getTypedRuleContext(Java8Parser.BlockContext,0)


        def STATIC(self):
            return self.getToken(Java8Parser.STATIC, 0)

        def memberDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.MemberDeclarationContext,0)


        def modifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ModifierContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ModifierContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_classBodyDeclaration




    def classBodyDeclaration(self):

        localctx = Java8Parser.ClassBodyDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_classBodyDeclaration)
        self._la = 0 # Token type
        try:
            self.state = 414
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 402
                self.match(Java8Parser.SEMI)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 404
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==Java8Parser.STATIC:
                    self.state = 403
                    self.match(Java8Parser.STATIC)


                self.state = 406
                self.block()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 410
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,33,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 407
                        self.modifier() 
                    self.state = 412
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,33,self._ctx)

                self.state = 413
                self.memberDeclaration()
                pass


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


    class MemberDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def methodDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.MethodDeclarationContext,0)


        def genericMethodDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.GenericMethodDeclarationContext,0)


        def fieldDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.FieldDeclarationContext,0)


        def constructorDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.ConstructorDeclarationContext,0)


        def genericConstructorDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.GenericConstructorDeclarationContext,0)


        def interfaceDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.InterfaceDeclarationContext,0)


        def annotationTypeDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.AnnotationTypeDeclarationContext,0)


        def classDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.ClassDeclarationContext,0)


        def enumDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.EnumDeclarationContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_memberDeclaration




    def memberDeclaration(self):

        localctx = Java8Parser.MemberDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_memberDeclaration)
        try:
            self.state = 425
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 416
                self.methodDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 417
                self.genericMethodDeclaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 418
                self.fieldDeclaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 419
                self.constructorDeclaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 420
                self.genericConstructorDeclaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 421
                self.interfaceDeclaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 422
                self.annotationTypeDeclaration()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 423
                self.classDeclaration()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 424
                self.enumDeclaration()
                pass


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


    class MethodDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeTypeOrVoid(self):
            return self.getTypedRuleContext(Java8Parser.TypeTypeOrVoidContext,0)


        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def formalParameters(self):
            return self.getTypedRuleContext(Java8Parser.FormalParametersContext,0)


        def methodBody(self):
            return self.getTypedRuleContext(Java8Parser.MethodBodyContext,0)


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

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

        def THROWS(self):
            return self.getToken(Java8Parser.THROWS, 0)

        def qualifiedNameList(self):
            return self.getTypedRuleContext(Java8Parser.QualifiedNameListContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_methodDeclaration




    def methodDeclaration(self):

        localctx = Java8Parser.MethodDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_methodDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 427
            self.typeTypeOrVoid()
            self.state = 428
            self.match(Java8Parser.IDENTIFIER)
            self.state = 429
            self.formalParameters()
            self.state = 434
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.LBRACK:
                self.state = 430
                self.match(Java8Parser.LBRACK)
                self.state = 431
                self.match(Java8Parser.RBRACK)
                self.state = 436
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 439
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.THROWS:
                self.state = 437
                self.match(Java8Parser.THROWS)
                self.state = 438
                self.qualifiedNameList()


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


    class MethodBodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def block(self):
            return self.getTypedRuleContext(Java8Parser.BlockContext,0)


        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_methodBody




    def methodBody(self):

        localctx = Java8Parser.MethodBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_methodBody)
        try:
            self.state = 445
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.LBRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 443
                self.block()
                pass
            elif token in [Java8Parser.SEMI]:
                self.enterOuterAlt(localctx, 2)
                self.state = 444
                self.match(Java8Parser.SEMI)
                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 TypeTypeOrVoidContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeType(self):
            return self.getTypedRuleContext(Java8Parser.TypeTypeContext,0)


        def VOID(self):
            return self.getToken(Java8Parser.VOID, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_typeTypeOrVoid




    def typeTypeOrVoid(self):

        localctx = Java8Parser.TypeTypeOrVoidContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_typeTypeOrVoid)
        try:
            self.state = 449
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.BOOLEAN, Java8Parser.BYTE, Java8Parser.CHAR, Java8Parser.DOUBLE, Java8Parser.FLOAT, Java8Parser.INT, Java8Parser.LONG, Java8Parser.SHORT, Java8Parser.AT, Java8Parser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 447
                self.typeType()
                pass
            elif token in [Java8Parser.VOID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 448
                self.match(Java8Parser.VOID)
                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 GenericMethodDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeParameters(self):
            return self.getTypedRuleContext(Java8Parser.TypeParametersContext,0)


        def methodDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.MethodDeclarationContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_genericMethodDeclaration




    def genericMethodDeclaration(self):

        localctx = Java8Parser.GenericMethodDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_genericMethodDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 451
            self.typeParameters()
            self.state = 452
            self.methodDeclaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GenericConstructorDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeParameters(self):
            return self.getTypedRuleContext(Java8Parser.TypeParametersContext,0)


        def constructorDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.ConstructorDeclarationContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_genericConstructorDeclaration




    def genericConstructorDeclaration(self):

        localctx = Java8Parser.GenericConstructorDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_genericConstructorDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 454
            self.typeParameters()
            self.state = 455
            self.constructorDeclaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstructorDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def formalParameters(self):
            return self.getTypedRuleContext(Java8Parser.FormalParametersContext,0)


        def block(self):
            return self.getTypedRuleContext(Java8Parser.BlockContext,0)


        def THROWS(self):
            return self.getToken(Java8Parser.THROWS, 0)

        def qualifiedNameList(self):
            return self.getTypedRuleContext(Java8Parser.QualifiedNameListContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_constructorDeclaration




    def constructorDeclaration(self):

        localctx = Java8Parser.ConstructorDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_constructorDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 457
            self.match(Java8Parser.IDENTIFIER)
            self.state = 458
            self.formalParameters()
            self.state = 461
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.THROWS:
                self.state = 459
                self.match(Java8Parser.THROWS)
                self.state = 460
                self.qualifiedNameList()


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


    class FieldDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeType(self):
            return self.getTypedRuleContext(Java8Parser.TypeTypeContext,0)


        def variableDeclarators(self):
            return self.getTypedRuleContext(Java8Parser.VariableDeclaratorsContext,0)


        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_fieldDeclaration




    def fieldDeclaration(self):

        localctx = Java8Parser.FieldDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_fieldDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 465
            self.typeType()
            self.state = 466
            self.variableDeclarators()
            self.state = 467
            self.match(Java8Parser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InterfaceBodyDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def interfaceMemberDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.InterfaceMemberDeclarationContext,0)


        def modifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ModifierContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ModifierContext,i)


        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_interfaceBodyDeclaration




    def interfaceBodyDeclaration(self):

        localctx = Java8Parser.InterfaceBodyDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_interfaceBodyDeclaration)
        try:
            self.state = 477
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.ABSTRACT, Java8Parser.BOOLEAN, Java8Parser.BYTE, Java8Parser.CHAR, Java8Parser.CLASS, Java8Parser.DEFAULT, Java8Parser.DOUBLE, Java8Parser.ENUM, Java8Parser.FINAL, Java8Parser.FLOAT, Java8Parser.INT, Java8Parser.INTERFACE, Java8Parser.LONG, Java8Parser.NATIVE, Java8Parser.PRIVATE, Java8Parser.PROTECTED, Java8Parser.PUBLIC, Java8Parser.SHORT, Java8Parser.STATIC, Java8Parser.STRICTFP, Java8Parser.SYNCHRONIZED, Java8Parser.TRANSIENT, Java8Parser.VOID, Java8Parser.VOLATILE, Java8Parser.LT, Java8Parser.AT, Java8Parser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 472
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,41,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 469
                        self.modifier() 
                    self.state = 474
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,41,self._ctx)

                self.state = 475
                self.interfaceMemberDeclaration()
                pass
            elif token in [Java8Parser.SEMI]:
                self.enterOuterAlt(localctx, 2)
                self.state = 476
                self.match(Java8Parser.SEMI)
                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 InterfaceMemberDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def constDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.ConstDeclarationContext,0)


        def interfaceMethodDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.InterfaceMethodDeclarationContext,0)


        def genericInterfaceMethodDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.GenericInterfaceMethodDeclarationContext,0)


        def interfaceDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.InterfaceDeclarationContext,0)


        def annotationTypeDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.AnnotationTypeDeclarationContext,0)


        def classDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.ClassDeclarationContext,0)


        def enumDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.EnumDeclarationContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_interfaceMemberDeclaration




    def interfaceMemberDeclaration(self):

        localctx = Java8Parser.InterfaceMemberDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_interfaceMemberDeclaration)
        try:
            self.state = 486
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 479
                self.constDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 480
                self.interfaceMethodDeclaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 481
                self.genericInterfaceMethodDeclaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 482
                self.interfaceDeclaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 483
                self.annotationTypeDeclaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 484
                self.classDeclaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 485
                self.enumDeclaration()
                pass


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


    class ConstDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeType(self):
            return self.getTypedRuleContext(Java8Parser.TypeTypeContext,0)


        def constantDeclarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ConstantDeclaratorContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ConstantDeclaratorContext,i)


        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

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

        def getRuleIndex(self):
            return Java8Parser.RULE_constDeclaration




    def constDeclaration(self):

        localctx = Java8Parser.ConstDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_constDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 488
            self.typeType()
            self.state = 489
            self.constantDeclarator()
            self.state = 494
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.COMMA:
                self.state = 490
                self.match(Java8Parser.COMMA)
                self.state = 491
                self.constantDeclarator()
                self.state = 496
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 497
            self.match(Java8Parser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstantDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def ASSIGN(self):
            return self.getToken(Java8Parser.ASSIGN, 0)

        def variableInitializer(self):
            return self.getTypedRuleContext(Java8Parser.VariableInitializerContext,0)


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

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

        def getRuleIndex(self):
            return Java8Parser.RULE_constantDeclarator




    def constantDeclarator(self):

        localctx = Java8Parser.ConstantDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_constantDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 499
            self.match(Java8Parser.IDENTIFIER)
            self.state = 504
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.LBRACK:
                self.state = 500
                self.match(Java8Parser.LBRACK)
                self.state = 501
                self.match(Java8Parser.RBRACK)
                self.state = 506
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 507
            self.match(Java8Parser.ASSIGN)
            self.state = 508
            self.variableInitializer()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InterfaceMethodDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def formalParameters(self):
            return self.getTypedRuleContext(Java8Parser.FormalParametersContext,0)


        def methodBody(self):
            return self.getTypedRuleContext(Java8Parser.MethodBodyContext,0)


        def typeTypeOrVoid(self):
            return self.getTypedRuleContext(Java8Parser.TypeTypeOrVoidContext,0)


        def typeParameters(self):
            return self.getTypedRuleContext(Java8Parser.TypeParametersContext,0)


        def interfaceMethodModifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.InterfaceMethodModifierContext)
            else:
                return self.getTypedRuleContext(Java8Parser.InterfaceMethodModifierContext,i)


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

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

        def THROWS(self):
            return self.getToken(Java8Parser.THROWS, 0)

        def qualifiedNameList(self):
            return self.getTypedRuleContext(Java8Parser.QualifiedNameListContext,0)


        def annotation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.AnnotationContext)
            else:
                return self.getTypedRuleContext(Java8Parser.AnnotationContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_interfaceMethodDeclaration




    def interfaceMethodDeclaration(self):

        localctx = Java8Parser.InterfaceMethodDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_interfaceMethodDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 513
            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:
                    self.state = 510
                    self.interfaceMethodModifier() 
                self.state = 515
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,46,self._ctx)

            self.state = 526
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.BOOLEAN, Java8Parser.BYTE, Java8Parser.CHAR, Java8Parser.DOUBLE, Java8Parser.FLOAT, Java8Parser.INT, Java8Parser.LONG, Java8Parser.SHORT, Java8Parser.VOID, Java8Parser.AT, Java8Parser.IDENTIFIER]:
                self.state = 516
                self.typeTypeOrVoid()
                pass
            elif token in [Java8Parser.LT]:
                self.state = 517
                self.typeParameters()
                self.state = 521
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,47,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 518
                        self.annotation() 
                    self.state = 523
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,47,self._ctx)

                self.state = 524
                self.typeTypeOrVoid()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 528
            self.match(Java8Parser.IDENTIFIER)
            self.state = 529
            self.formalParameters()
            self.state = 534
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.LBRACK:
                self.state = 530
                self.match(Java8Parser.LBRACK)
                self.state = 531
                self.match(Java8Parser.RBRACK)
                self.state = 536
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 539
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.THROWS:
                self.state = 537
                self.match(Java8Parser.THROWS)
                self.state = 538
                self.qualifiedNameList()


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


    class InterfaceMethodModifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def annotation(self):
            return self.getTypedRuleContext(Java8Parser.AnnotationContext,0)


        def PUBLIC(self):
            return self.getToken(Java8Parser.PUBLIC, 0)

        def ABSTRACT(self):
            return self.getToken(Java8Parser.ABSTRACT, 0)

        def DEFAULT(self):
            return self.getToken(Java8Parser.DEFAULT, 0)

        def STATIC(self):
            return self.getToken(Java8Parser.STATIC, 0)

        def STRICTFP(self):
            return self.getToken(Java8Parser.STRICTFP, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_interfaceMethodModifier




    def interfaceMethodModifier(self):

        localctx = Java8Parser.InterfaceMethodModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_interfaceMethodModifier)
        try:
            self.state = 549
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.AT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 543
                self.annotation()
                pass
            elif token in [Java8Parser.PUBLIC]:
                self.enterOuterAlt(localctx, 2)
                self.state = 544
                self.match(Java8Parser.PUBLIC)
                pass
            elif token in [Java8Parser.ABSTRACT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 545
                self.match(Java8Parser.ABSTRACT)
                pass
            elif token in [Java8Parser.DEFAULT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 546
                self.match(Java8Parser.DEFAULT)
                pass
            elif token in [Java8Parser.STATIC]:
                self.enterOuterAlt(localctx, 5)
                self.state = 547
                self.match(Java8Parser.STATIC)
                pass
            elif token in [Java8Parser.STRICTFP]:
                self.enterOuterAlt(localctx, 6)
                self.state = 548
                self.match(Java8Parser.STRICTFP)
                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 GenericInterfaceMethodDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeParameters(self):
            return self.getTypedRuleContext(Java8Parser.TypeParametersContext,0)


        def interfaceMethodDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.InterfaceMethodDeclarationContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_genericInterfaceMethodDeclaration




    def genericInterfaceMethodDeclaration(self):

        localctx = Java8Parser.GenericInterfaceMethodDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_genericInterfaceMethodDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 551
            self.typeParameters()
            self.state = 552
            self.interfaceMethodDeclaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDeclaratorsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def variableDeclarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.VariableDeclaratorContext)
            else:
                return self.getTypedRuleContext(Java8Parser.VariableDeclaratorContext,i)


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

        def getRuleIndex(self):
            return Java8Parser.RULE_variableDeclarators




    def variableDeclarators(self):

        localctx = Java8Parser.VariableDeclaratorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_variableDeclarators)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 554
            self.variableDeclarator()
            self.state = 559
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.COMMA:
                self.state = 555
                self.match(Java8Parser.COMMA)
                self.state = 556
                self.variableDeclarator()
                self.state = 561
                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 VariableDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def variableDeclaratorId(self):
            return self.getTypedRuleContext(Java8Parser.VariableDeclaratorIdContext,0)


        def ASSIGN(self):
            return self.getToken(Java8Parser.ASSIGN, 0)

        def variableInitializer(self):
            return self.getTypedRuleContext(Java8Parser.VariableInitializerContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_variableDeclarator




    def variableDeclarator(self):

        localctx = Java8Parser.VariableDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_variableDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 562
            self.variableDeclaratorId()
            self.state = 565
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.ASSIGN:
                self.state = 563
                self.match(Java8Parser.ASSIGN)
                self.state = 564
                self.variableInitializer()


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


    class VariableDeclaratorIdContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

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

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

        def getRuleIndex(self):
            return Java8Parser.RULE_variableDeclaratorId




    def variableDeclaratorId(self):

        localctx = Java8Parser.VariableDeclaratorIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_variableDeclaratorId)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 567
            self.match(Java8Parser.IDENTIFIER)
            self.state = 572
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.LBRACK:
                self.state = 568
                self.match(Java8Parser.LBRACK)
                self.state = 569
                self.match(Java8Parser.RBRACK)
                self.state = 574
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class VariableInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def arrayInitializer(self):
            return self.getTypedRuleContext(Java8Parser.ArrayInitializerContext,0)


        def expression(self):
            return self.getTypedRuleContext(Java8Parser.ExpressionContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_variableInitializer




    def variableInitializer(self):

        localctx = Java8Parser.VariableInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_variableInitializer)
        try:
            self.state = 577
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.LBRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 575
                self.arrayInitializer()
                pass
            elif token in [Java8Parser.BOOLEAN, Java8Parser.BYTE, Java8Parser.CHAR, Java8Parser.DOUBLE, Java8Parser.FLOAT, Java8Parser.INT, Java8Parser.LONG, Java8Parser.NEW, Java8Parser.SHORT, Java8Parser.SUPER, Java8Parser.THIS, Java8Parser.VOID, Java8Parser.DECIMAL_LITERAL, Java8Parser.HEX_LITERAL, Java8Parser.OCT_LITERAL, Java8Parser.BINARY_LITERAL, Java8Parser.FLOAT_LITERAL, Java8Parser.HEX_FLOAT_LITERAL, Java8Parser.BOOL_LITERAL, Java8Parser.CHAR_LITERAL, Java8Parser.STRING_LITERAL, Java8Parser.NULL_LITERAL, Java8Parser.LPAREN, Java8Parser.LT, Java8Parser.BANG, Java8Parser.TILDE, Java8Parser.INC, Java8Parser.DEC, Java8Parser.ADD, Java8Parser.SUB, Java8Parser.AT, Java8Parser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 576
                self.expression(0)
                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 ArrayInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LBRACE(self):
            return self.getToken(Java8Parser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(Java8Parser.RBRACE, 0)

        def variableInitializer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.VariableInitializerContext)
            else:
                return self.getTypedRuleContext(Java8Parser.VariableInitializerContext,i)


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

        def getRuleIndex(self):
            return Java8Parser.RULE_arrayInitializer




    def arrayInitializer(self):

        localctx = Java8Parser.ArrayInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_arrayInitializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 579
            self.match(Java8Parser.LBRACE)
            self.state = 591
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NEW) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.SUPER) | (1 << Java8Parser.THIS) | (1 << Java8Parser.VOID) | (1 << Java8Parser.DECIMAL_LITERAL) | (1 << Java8Parser.HEX_LITERAL) | (1 << Java8Parser.OCT_LITERAL) | (1 << Java8Parser.BINARY_LITERAL) | (1 << Java8Parser.FLOAT_LITERAL) | (1 << Java8Parser.HEX_FLOAT_LITERAL) | (1 << Java8Parser.BOOL_LITERAL) | (1 << Java8Parser.CHAR_LITERAL) | (1 << Java8Parser.STRING_LITERAL) | (1 << Java8Parser.NULL_LITERAL) | (1 << Java8Parser.LPAREN) | (1 << Java8Parser.LBRACE))) != 0) or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (Java8Parser.LT - 72)) | (1 << (Java8Parser.BANG - 72)) | (1 << (Java8Parser.TILDE - 72)) | (1 << (Java8Parser.INC - 72)) | (1 << (Java8Parser.DEC - 72)) | (1 << (Java8Parser.ADD - 72)) | (1 << (Java8Parser.SUB - 72)) | (1 << (Java8Parser.AT - 72)) | (1 << (Java8Parser.IDENTIFIER - 72)))) != 0):
                self.state = 580
                self.variableInitializer()
                self.state = 585
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,56,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 581
                        self.match(Java8Parser.COMMA)
                        self.state = 582
                        self.variableInitializer() 
                    self.state = 587
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,56,self._ctx)

                self.state = 589
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==Java8Parser.COMMA:
                    self.state = 588
                    self.match(Java8Parser.COMMA)




            self.state = 593
            self.match(Java8Parser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassOrInterfaceTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def typeArguments(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.TypeArgumentsContext)
            else:
                return self.getTypedRuleContext(Java8Parser.TypeArgumentsContext,i)


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

        def getRuleIndex(self):
            return Java8Parser.RULE_classOrInterfaceType




    def classOrInterfaceType(self):

        localctx = Java8Parser.ClassOrInterfaceTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_classOrInterfaceType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 595
            self.match(Java8Parser.IDENTIFIER)
            self.state = 597
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,59,self._ctx)
            if la_ == 1:
                self.state = 596
                self.typeArguments()


            self.state = 606
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,61,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 599
                    self.match(Java8Parser.DOT)
                    self.state = 600
                    self.match(Java8Parser.IDENTIFIER)
                    self.state = 602
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,60,self._ctx)
                    if la_ == 1:
                        self.state = 601
                        self.typeArguments()

             
                self.state = 608
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,61,self._ctx)

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


    class TypeArgumentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeType(self):
            return self.getTypedRuleContext(Java8Parser.TypeTypeContext,0)


        def QUESTION(self):
            return self.getToken(Java8Parser.QUESTION, 0)

        def EXTENDS(self):
            return self.getToken(Java8Parser.EXTENDS, 0)

        def SUPER(self):
            return self.getToken(Java8Parser.SUPER, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_typeArgument




    def typeArgument(self):

        localctx = Java8Parser.TypeArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_typeArgument)
        self._la = 0 # Token type
        try:
            self.state = 615
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.BOOLEAN, Java8Parser.BYTE, Java8Parser.CHAR, Java8Parser.DOUBLE, Java8Parser.FLOAT, Java8Parser.INT, Java8Parser.LONG, Java8Parser.SHORT, Java8Parser.AT, Java8Parser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 609
                self.typeType()
                pass
            elif token in [Java8Parser.QUESTION]:
                self.enterOuterAlt(localctx, 2)
                self.state = 610
                self.match(Java8Parser.QUESTION)
                self.state = 613
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==Java8Parser.EXTENDS or _la==Java8Parser.SUPER:
                    self.state = 611
                    _la = self._input.LA(1)
                    if not(_la==Java8Parser.EXTENDS or _la==Java8Parser.SUPER):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 612
                    self.typeType()


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

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

        def qualifiedName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.QualifiedNameContext)
            else:
                return self.getTypedRuleContext(Java8Parser.QualifiedNameContext,i)


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

        def getRuleIndex(self):
            return Java8Parser.RULE_qualifiedNameList




    def qualifiedNameList(self):

        localctx = Java8Parser.QualifiedNameListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_qualifiedNameList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 617
            self.qualifiedName()
            self.state = 622
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.COMMA:
                self.state = 618
                self.match(Java8Parser.COMMA)
                self.state = 619
                self.qualifiedName()
                self.state = 624
                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 FormalParametersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LPAREN(self):
            return self.getToken(Java8Parser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(Java8Parser.RPAREN, 0)

        def formalParameterList(self):
            return self.getTypedRuleContext(Java8Parser.FormalParameterListContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_formalParameters




    def formalParameters(self):

        localctx = Java8Parser.FormalParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_formalParameters)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 625
            self.match(Java8Parser.LPAREN)
            self.state = 627
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FINAL) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.LONG) | (1 << Java8Parser.SHORT))) != 0) or _la==Java8Parser.AT or _la==Java8Parser.IDENTIFIER:
                self.state = 626
                self.formalParameterList()


            self.state = 629
            self.match(Java8Parser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FormalParameterListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def formalParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.FormalParameterContext)
            else:
                return self.getTypedRuleContext(Java8Parser.FormalParameterContext,i)


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

        def lastFormalParameter(self):
            return self.getTypedRuleContext(Java8Parser.LastFormalParameterContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_formalParameterList




    def formalParameterList(self):

        localctx = Java8Parser.FormalParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_formalParameterList)
        self._la = 0 # Token type
        try:
            self.state = 644
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 631
                self.formalParameter()
                self.state = 636
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,66,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 632
                        self.match(Java8Parser.COMMA)
                        self.state = 633
                        self.formalParameter() 
                    self.state = 638
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,66,self._ctx)

                self.state = 641
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==Java8Parser.COMMA:
                    self.state = 639
                    self.match(Java8Parser.COMMA)
                    self.state = 640
                    self.lastFormalParameter()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 643
                self.lastFormalParameter()
                pass


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


    class FormalParameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeType(self):
            return self.getTypedRuleContext(Java8Parser.TypeTypeContext,0)


        def variableDeclaratorId(self):
            return self.getTypedRuleContext(Java8Parser.VariableDeclaratorIdContext,0)


        def variableModifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.VariableModifierContext)
            else:
                return self.getTypedRuleContext(Java8Parser.VariableModifierContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_formalParameter




    def formalParameter(self):

        localctx = Java8Parser.FormalParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_formalParameter)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 649
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,69,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 646
                    self.variableModifier() 
                self.state = 651
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,69,self._ctx)

            self.state = 652
            self.typeType()
            self.state = 653
            self.variableDeclaratorId()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LastFormalParameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeType(self):
            return self.getTypedRuleContext(Java8Parser.TypeTypeContext,0)


        def ELLIPSIS(self):
            return self.getToken(Java8Parser.ELLIPSIS, 0)

        def variableDeclaratorId(self):
            return self.getTypedRuleContext(Java8Parser.VariableDeclaratorIdContext,0)


        def variableModifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.VariableModifierContext)
            else:
                return self.getTypedRuleContext(Java8Parser.VariableModifierContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_lastFormalParameter




    def lastFormalParameter(self):

        localctx = Java8Parser.LastFormalParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_lastFormalParameter)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 658
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,70,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 655
                    self.variableModifier() 
                self.state = 660
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,70,self._ctx)

            self.state = 661
            self.typeType()
            self.state = 662
            self.match(Java8Parser.ELLIPSIS)
            self.state = 663
            self.variableDeclaratorId()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QualifiedNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def getRuleIndex(self):
            return Java8Parser.RULE_qualifiedName




    def qualifiedName(self):

        localctx = Java8Parser.QualifiedNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_qualifiedName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 665
            self.match(Java8Parser.IDENTIFIER)
            self.state = 670
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,71,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 666
                    self.match(Java8Parser.DOT)
                    self.state = 667
                    self.match(Java8Parser.IDENTIFIER) 
                self.state = 672
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,71,self._ctx)

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


    class LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def integerLiteral(self):
            return self.getTypedRuleContext(Java8Parser.IntegerLiteralContext,0)


        def floatLiteral(self):
            return self.getTypedRuleContext(Java8Parser.FloatLiteralContext,0)


        def CHAR_LITERAL(self):
            return self.getToken(Java8Parser.CHAR_LITERAL, 0)

        def STRING_LITERAL(self):
            return self.getToken(Java8Parser.STRING_LITERAL, 0)

        def BOOL_LITERAL(self):
            return self.getToken(Java8Parser.BOOL_LITERAL, 0)

        def NULL_LITERAL(self):
            return self.getToken(Java8Parser.NULL_LITERAL, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_literal




    def literal(self):

        localctx = Java8Parser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_literal)
        try:
            self.state = 679
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.DECIMAL_LITERAL, Java8Parser.HEX_LITERAL, Java8Parser.OCT_LITERAL, Java8Parser.BINARY_LITERAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 673
                self.integerLiteral()
                pass
            elif token in [Java8Parser.FLOAT_LITERAL, Java8Parser.HEX_FLOAT_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 674
                self.floatLiteral()
                pass
            elif token in [Java8Parser.CHAR_LITERAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 675
                self.match(Java8Parser.CHAR_LITERAL)
                pass
            elif token in [Java8Parser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 4)
                self.state = 676
                self.match(Java8Parser.STRING_LITERAL)
                pass
            elif token in [Java8Parser.BOOL_LITERAL]:
                self.enterOuterAlt(localctx, 5)
                self.state = 677
                self.match(Java8Parser.BOOL_LITERAL)
                pass
            elif token in [Java8Parser.NULL_LITERAL]:
                self.enterOuterAlt(localctx, 6)
                self.state = 678
                self.match(Java8Parser.NULL_LITERAL)
                pass
            else:
                raise NoViableAltException(self)

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


    class IntegerLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DECIMAL_LITERAL(self):
            return self.getToken(Java8Parser.DECIMAL_LITERAL, 0)

        def HEX_LITERAL(self):
            return self.getToken(Java8Parser.HEX_LITERAL, 0)

        def OCT_LITERAL(self):
            return self.getToken(Java8Parser.OCT_LITERAL, 0)

        def BINARY_LITERAL(self):
            return self.getToken(Java8Parser.BINARY_LITERAL, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_integerLiteral




    def integerLiteral(self):

        localctx = Java8Parser.IntegerLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_integerLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 681
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.DECIMAL_LITERAL) | (1 << Java8Parser.HEX_LITERAL) | (1 << Java8Parser.OCT_LITERAL) | (1 << Java8Parser.BINARY_LITERAL))) != 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 FloatLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FLOAT_LITERAL(self):
            return self.getToken(Java8Parser.FLOAT_LITERAL, 0)

        def HEX_FLOAT_LITERAL(self):
            return self.getToken(Java8Parser.HEX_FLOAT_LITERAL, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_floatLiteral




    def floatLiteral(self):

        localctx = Java8Parser.FloatLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_floatLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 683
            _la = self._input.LA(1)
            if not(_la==Java8Parser.FLOAT_LITERAL or _la==Java8Parser.HEX_FLOAT_LITERAL):
                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 AnnotationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AT(self):
            return self.getToken(Java8Parser.AT, 0)

        def qualifiedName(self):
            return self.getTypedRuleContext(Java8Parser.QualifiedNameContext,0)


        def LPAREN(self):
            return self.getToken(Java8Parser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(Java8Parser.RPAREN, 0)

        def elementValuePairs(self):
            return self.getTypedRuleContext(Java8Parser.ElementValuePairsContext,0)


        def elementValue(self):
            return self.getTypedRuleContext(Java8Parser.ElementValueContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_annotation




    def annotation(self):

        localctx = Java8Parser.AnnotationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_annotation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 685
            self.match(Java8Parser.AT)
            self.state = 686
            self.qualifiedName()
            self.state = 693
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.LPAREN:
                self.state = 687
                self.match(Java8Parser.LPAREN)
                self.state = 690
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
                if la_ == 1:
                    self.state = 688
                    self.elementValuePairs()

                elif la_ == 2:
                    self.state = 689
                    self.elementValue()


                self.state = 692
                self.match(Java8Parser.RPAREN)


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


    class ElementValuePairsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def elementValuePair(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ElementValuePairContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ElementValuePairContext,i)


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

        def getRuleIndex(self):
            return Java8Parser.RULE_elementValuePairs




    def elementValuePairs(self):

        localctx = Java8Parser.ElementValuePairsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_elementValuePairs)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 695
            self.elementValuePair()
            self.state = 700
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.COMMA:
                self.state = 696
                self.match(Java8Parser.COMMA)
                self.state = 697
                self.elementValuePair()
                self.state = 702
                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 ElementValuePairContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def ASSIGN(self):
            return self.getToken(Java8Parser.ASSIGN, 0)

        def elementValue(self):
            return self.getTypedRuleContext(Java8Parser.ElementValueContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_elementValuePair




    def elementValuePair(self):

        localctx = Java8Parser.ElementValuePairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_elementValuePair)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 703
            self.match(Java8Parser.IDENTIFIER)
            self.state = 704
            self.match(Java8Parser.ASSIGN)
            self.state = 705
            self.elementValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ElementValueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self):
            return self.getTypedRuleContext(Java8Parser.ExpressionContext,0)


        def annotation(self):
            return self.getTypedRuleContext(Java8Parser.AnnotationContext,0)


        def elementValueArrayInitializer(self):
            return self.getTypedRuleContext(Java8Parser.ElementValueArrayInitializerContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_elementValue




    def elementValue(self):

        localctx = Java8Parser.ElementValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_elementValue)
        try:
            self.state = 710
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 707
                self.expression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 708
                self.annotation()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 709
                self.elementValueArrayInitializer()
                pass


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


    class ElementValueArrayInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LBRACE(self):
            return self.getToken(Java8Parser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(Java8Parser.RBRACE, 0)

        def elementValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ElementValueContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ElementValueContext,i)


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

        def getRuleIndex(self):
            return Java8Parser.RULE_elementValueArrayInitializer




    def elementValueArrayInitializer(self):

        localctx = Java8Parser.ElementValueArrayInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_elementValueArrayInitializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 712
            self.match(Java8Parser.LBRACE)
            self.state = 721
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NEW) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.SUPER) | (1 << Java8Parser.THIS) | (1 << Java8Parser.VOID) | (1 << Java8Parser.DECIMAL_LITERAL) | (1 << Java8Parser.HEX_LITERAL) | (1 << Java8Parser.OCT_LITERAL) | (1 << Java8Parser.BINARY_LITERAL) | (1 << Java8Parser.FLOAT_LITERAL) | (1 << Java8Parser.HEX_FLOAT_LITERAL) | (1 << Java8Parser.BOOL_LITERAL) | (1 << Java8Parser.CHAR_LITERAL) | (1 << Java8Parser.STRING_LITERAL) | (1 << Java8Parser.NULL_LITERAL) | (1 << Java8Parser.LPAREN) | (1 << Java8Parser.LBRACE))) != 0) or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (Java8Parser.LT - 72)) | (1 << (Java8Parser.BANG - 72)) | (1 << (Java8Parser.TILDE - 72)) | (1 << (Java8Parser.INC - 72)) | (1 << (Java8Parser.DEC - 72)) | (1 << (Java8Parser.ADD - 72)) | (1 << (Java8Parser.SUB - 72)) | (1 << (Java8Parser.AT - 72)) | (1 << (Java8Parser.IDENTIFIER - 72)))) != 0):
                self.state = 713
                self.elementValue()
                self.state = 718
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,77,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 714
                        self.match(Java8Parser.COMMA)
                        self.state = 715
                        self.elementValue() 
                    self.state = 720
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,77,self._ctx)



            self.state = 724
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.COMMA:
                self.state = 723
                self.match(Java8Parser.COMMA)


            self.state = 726
            self.match(Java8Parser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AnnotationTypeDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AT(self):
            return self.getToken(Java8Parser.AT, 0)

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

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def annotationTypeBody(self):
            return self.getTypedRuleContext(Java8Parser.AnnotationTypeBodyContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_annotationTypeDeclaration




    def annotationTypeDeclaration(self):

        localctx = Java8Parser.AnnotationTypeDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_annotationTypeDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 728
            self.match(Java8Parser.AT)
            self.state = 729
            self.match(Java8Parser.INTERFACE)
            self.state = 730
            self.match(Java8Parser.IDENTIFIER)
            self.state = 731
            self.annotationTypeBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AnnotationTypeBodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LBRACE(self):
            return self.getToken(Java8Parser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(Java8Parser.RBRACE, 0)

        def annotationTypeElementDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.AnnotationTypeElementDeclarationContext)
            else:
                return self.getTypedRuleContext(Java8Parser.AnnotationTypeElementDeclarationContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_annotationTypeBody




    def annotationTypeBody(self):

        localctx = Java8Parser.AnnotationTypeBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_annotationTypeBody)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 733
            self.match(Java8Parser.LBRACE)
            self.state = 737
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.ABSTRACT) | (1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.CLASS) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.ENUM) | (1 << Java8Parser.FINAL) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.INTERFACE) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NATIVE) | (1 << Java8Parser.PRIVATE) | (1 << Java8Parser.PROTECTED) | (1 << Java8Parser.PUBLIC) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.STATIC) | (1 << Java8Parser.STRICTFP) | (1 << Java8Parser.SYNCHRONIZED) | (1 << Java8Parser.TRANSIENT) | (1 << Java8Parser.VOLATILE))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (Java8Parser.SEMI - 67)) | (1 << (Java8Parser.AT - 67)) | (1 << (Java8Parser.IDENTIFIER - 67)))) != 0):
                self.state = 734
                self.annotationTypeElementDeclaration()
                self.state = 739
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 740
            self.match(Java8Parser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AnnotationTypeElementDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def annotationTypeElementRest(self):
            return self.getTypedRuleContext(Java8Parser.AnnotationTypeElementRestContext,0)


        def modifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ModifierContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ModifierContext,i)


        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_annotationTypeElementDeclaration




    def annotationTypeElementDeclaration(self):

        localctx = Java8Parser.AnnotationTypeElementDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_annotationTypeElementDeclaration)
        try:
            self.state = 750
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.ABSTRACT, Java8Parser.BOOLEAN, Java8Parser.BYTE, Java8Parser.CHAR, Java8Parser.CLASS, Java8Parser.DOUBLE, Java8Parser.ENUM, Java8Parser.FINAL, Java8Parser.FLOAT, Java8Parser.INT, Java8Parser.INTERFACE, Java8Parser.LONG, Java8Parser.NATIVE, Java8Parser.PRIVATE, Java8Parser.PROTECTED, Java8Parser.PUBLIC, Java8Parser.SHORT, Java8Parser.STATIC, Java8Parser.STRICTFP, Java8Parser.SYNCHRONIZED, Java8Parser.TRANSIENT, Java8Parser.VOLATILE, Java8Parser.AT, Java8Parser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 745
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,81,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 742
                        self.modifier() 
                    self.state = 747
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,81,self._ctx)

                self.state = 748
                self.annotationTypeElementRest()
                pass
            elif token in [Java8Parser.SEMI]:
                self.enterOuterAlt(localctx, 2)
                self.state = 749
                self.match(Java8Parser.SEMI)
                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 AnnotationTypeElementRestContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeType(self):
            return self.getTypedRuleContext(Java8Parser.TypeTypeContext,0)


        def annotationMethodOrConstantRest(self):
            return self.getTypedRuleContext(Java8Parser.AnnotationMethodOrConstantRestContext,0)


        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

        def classDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.ClassDeclarationContext,0)


        def interfaceDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.InterfaceDeclarationContext,0)


        def enumDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.EnumDeclarationContext,0)


        def annotationTypeDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.AnnotationTypeDeclarationContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_annotationTypeElementRest




    def annotationTypeElementRest(self):

        localctx = Java8Parser.AnnotationTypeElementRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_annotationTypeElementRest)
        try:
            self.state = 772
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 752
                self.typeType()
                self.state = 753
                self.annotationMethodOrConstantRest()
                self.state = 754
                self.match(Java8Parser.SEMI)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 756
                self.classDeclaration()
                self.state = 758
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
                if la_ == 1:
                    self.state = 757
                    self.match(Java8Parser.SEMI)


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 760
                self.interfaceDeclaration()
                self.state = 762
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
                if la_ == 1:
                    self.state = 761
                    self.match(Java8Parser.SEMI)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 764
                self.enumDeclaration()
                self.state = 766
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
                if la_ == 1:
                    self.state = 765
                    self.match(Java8Parser.SEMI)


                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 768
                self.annotationTypeDeclaration()
                self.state = 770
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
                if la_ == 1:
                    self.state = 769
                    self.match(Java8Parser.SEMI)


                pass


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


    class AnnotationMethodOrConstantRestContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def annotationMethodRest(self):
            return self.getTypedRuleContext(Java8Parser.AnnotationMethodRestContext,0)


        def annotationConstantRest(self):
            return self.getTypedRuleContext(Java8Parser.AnnotationConstantRestContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_annotationMethodOrConstantRest




    def annotationMethodOrConstantRest(self):

        localctx = Java8Parser.AnnotationMethodOrConstantRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_annotationMethodOrConstantRest)
        try:
            self.state = 776
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 774
                self.annotationMethodRest()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 775
                self.annotationConstantRest()
                pass


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


    class AnnotationMethodRestContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def LPAREN(self):
            return self.getToken(Java8Parser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(Java8Parser.RPAREN, 0)

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


        def getRuleIndex(self):
            return Java8Parser.RULE_annotationMethodRest




    def annotationMethodRest(self):

        localctx = Java8Parser.AnnotationMethodRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_annotationMethodRest)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 778
            self.match(Java8Parser.IDENTIFIER)
            self.state = 779
            self.match(Java8Parser.LPAREN)
            self.state = 780
            self.match(Java8Parser.RPAREN)
            self.state = 782
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.DEFAULT:
                self.state = 781
                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 AnnotationConstantRestContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def variableDeclarators(self):
            return self.getTypedRuleContext(Java8Parser.VariableDeclaratorsContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_annotationConstantRest




    def annotationConstantRest(self):

        localctx = Java8Parser.AnnotationConstantRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_annotationConstantRest)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 784
            self.variableDeclarators()
        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):
        __slots__ = 'parser'

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

        def DEFAULT(self):
            return self.getToken(Java8Parser.DEFAULT, 0)

        def elementValue(self):
            return self.getTypedRuleContext(Java8Parser.ElementValueContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_defaultValue




    def defaultValue(self):

        localctx = Java8Parser.DefaultValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_defaultValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 786
            self.match(Java8Parser.DEFAULT)
            self.state = 787
            self.elementValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LBRACE(self):
            return self.getToken(Java8Parser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(Java8Parser.RBRACE, 0)

        def blockStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.BlockStatementContext)
            else:
                return self.getTypedRuleContext(Java8Parser.BlockStatementContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_block




    def block(self):

        localctx = Java8Parser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 789
            self.match(Java8Parser.LBRACE)
            self.state = 793
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.ABSTRACT) | (1 << Java8Parser.ASSERT) | (1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BREAK) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.CLASS) | (1 << Java8Parser.CONTINUE) | (1 << Java8Parser.DO) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FINAL) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.FOR) | (1 << Java8Parser.IF) | (1 << Java8Parser.INT) | (1 << Java8Parser.INTERFACE) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NEW) | (1 << Java8Parser.PRIVATE) | (1 << Java8Parser.PROTECTED) | (1 << Java8Parser.PUBLIC) | (1 << Java8Parser.RETURN) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.STATIC) | (1 << Java8Parser.STRICTFP) | (1 << Java8Parser.SUPER) | (1 << Java8Parser.SWITCH) | (1 << Java8Parser.SYNCHRONIZED) | (1 << Java8Parser.THIS) | (1 << Java8Parser.THROW) | (1 << Java8Parser.TRY) | (1 << Java8Parser.VOID) | (1 << Java8Parser.WHILE) | (1 << Java8Parser.DECIMAL_LITERAL) | (1 << Java8Parser.HEX_LITERAL) | (1 << Java8Parser.OCT_LITERAL) | (1 << Java8Parser.BINARY_LITERAL) | (1 << Java8Parser.FLOAT_LITERAL) | (1 << Java8Parser.HEX_FLOAT_LITERAL) | (1 << Java8Parser.BOOL_LITERAL) | (1 << Java8Parser.CHAR_LITERAL) | (1 << Java8Parser.STRING_LITERAL) | (1 << Java8Parser.NULL_LITERAL) | (1 << Java8Parser.LPAREN) | (1 << Java8Parser.LBRACE))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (Java8Parser.SEMI - 67)) | (1 << (Java8Parser.LT - 67)) | (1 << (Java8Parser.BANG - 67)) | (1 << (Java8Parser.TILDE - 67)) | (1 << (Java8Parser.INC - 67)) | (1 << (Java8Parser.DEC - 67)) | (1 << (Java8Parser.ADD - 67)) | (1 << (Java8Parser.SUB - 67)) | (1 << (Java8Parser.AT - 67)) | (1 << (Java8Parser.IDENTIFIER - 67)))) != 0):
                self.state = 790
                self.blockStatement()
                self.state = 795
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 796
            self.match(Java8Parser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BlockStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def localVariableDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.LocalVariableDeclarationContext,0)


        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

        def statement(self):
            return self.getTypedRuleContext(Java8Parser.StatementContext,0)


        def localTypeDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.LocalTypeDeclarationContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_blockStatement




    def blockStatement(self):

        localctx = Java8Parser.BlockStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_blockStatement)
        try:
            self.state = 803
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,91,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 798
                self.localVariableDeclaration()
                self.state = 799
                self.match(Java8Parser.SEMI)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 801
                self.statement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 802
                self.localTypeDeclaration()
                pass


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


    class LocalVariableDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeType(self):
            return self.getTypedRuleContext(Java8Parser.TypeTypeContext,0)


        def variableDeclarators(self):
            return self.getTypedRuleContext(Java8Parser.VariableDeclaratorsContext,0)


        def variableModifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.VariableModifierContext)
            else:
                return self.getTypedRuleContext(Java8Parser.VariableModifierContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_localVariableDeclaration




    def localVariableDeclaration(self):

        localctx = Java8Parser.LocalVariableDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_localVariableDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 808
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,92,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 805
                    self.variableModifier() 
                self.state = 810
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,92,self._ctx)

            self.state = 811
            self.typeType()
            self.state = 812
            self.variableDeclarators()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LocalTypeDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def classDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.ClassDeclarationContext,0)


        def interfaceDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.InterfaceDeclarationContext,0)


        def classOrInterfaceModifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ClassOrInterfaceModifierContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ClassOrInterfaceModifierContext,i)


        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_localTypeDeclaration




    def localTypeDeclaration(self):

        localctx = Java8Parser.LocalTypeDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_localTypeDeclaration)
        self._la = 0 # Token type
        try:
            self.state = 825
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.ABSTRACT, Java8Parser.CLASS, Java8Parser.FINAL, Java8Parser.INTERFACE, Java8Parser.PRIVATE, Java8Parser.PROTECTED, Java8Parser.PUBLIC, Java8Parser.STATIC, Java8Parser.STRICTFP, Java8Parser.AT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 817
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.ABSTRACT) | (1 << Java8Parser.FINAL) | (1 << Java8Parser.PRIVATE) | (1 << Java8Parser.PROTECTED) | (1 << Java8Parser.PUBLIC) | (1 << Java8Parser.STATIC) | (1 << Java8Parser.STRICTFP))) != 0) or _la==Java8Parser.AT:
                    self.state = 814
                    self.classOrInterfaceModifier()
                    self.state = 819
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 822
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [Java8Parser.CLASS]:
                    self.state = 820
                    self.classDeclaration()
                    pass
                elif token in [Java8Parser.INTERFACE]:
                    self.state = 821
                    self.interfaceDeclaration()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [Java8Parser.SEMI]:
                self.enterOuterAlt(localctx, 2)
                self.state = 824
                self.match(Java8Parser.SEMI)
                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 StatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.blockLabel = None # BlockContext
            self.statementExpression = None # ExpressionContext
            self.identifierLabel = None # Token

        def block(self):
            return self.getTypedRuleContext(Java8Parser.BlockContext,0)


        def ASSERT(self):
            return self.getToken(Java8Parser.ASSERT, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ExpressionContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ExpressionContext,i)


        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

        def COLON(self):
            return self.getToken(Java8Parser.COLON, 0)

        def IF(self):
            return self.getToken(Java8Parser.IF, 0)

        def parExpression(self):
            return self.getTypedRuleContext(Java8Parser.ParExpressionContext,0)


        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.StatementContext)
            else:
                return self.getTypedRuleContext(Java8Parser.StatementContext,i)


        def ELSE(self):
            return self.getToken(Java8Parser.ELSE, 0)

        def FOR(self):
            return self.getToken(Java8Parser.FOR, 0)

        def LPAREN(self):
            return self.getToken(Java8Parser.LPAREN, 0)

        def forControl(self):
            return self.getTypedRuleContext(Java8Parser.ForControlContext,0)


        def RPAREN(self):
            return self.getToken(Java8Parser.RPAREN, 0)

        def WHILE(self):
            return self.getToken(Java8Parser.WHILE, 0)

        def DO(self):
            return self.getToken(Java8Parser.DO, 0)

        def TRY(self):
            return self.getToken(Java8Parser.TRY, 0)

        def finallyBlock(self):
            return self.getTypedRuleContext(Java8Parser.FinallyBlockContext,0)


        def catchClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.CatchClauseContext)
            else:
                return self.getTypedRuleContext(Java8Parser.CatchClauseContext,i)


        def resourceSpecification(self):
            return self.getTypedRuleContext(Java8Parser.ResourceSpecificationContext,0)


        def SWITCH(self):
            return self.getToken(Java8Parser.SWITCH, 0)

        def LBRACE(self):
            return self.getToken(Java8Parser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(Java8Parser.RBRACE, 0)

        def switchBlockStatementGroup(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.SwitchBlockStatementGroupContext)
            else:
                return self.getTypedRuleContext(Java8Parser.SwitchBlockStatementGroupContext,i)


        def switchLabel(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.SwitchLabelContext)
            else:
                return self.getTypedRuleContext(Java8Parser.SwitchLabelContext,i)


        def SYNCHRONIZED(self):
            return self.getToken(Java8Parser.SYNCHRONIZED, 0)

        def RETURN(self):
            return self.getToken(Java8Parser.RETURN, 0)

        def THROW(self):
            return self.getToken(Java8Parser.THROW, 0)

        def BREAK(self):
            return self.getToken(Java8Parser.BREAK, 0)

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def CONTINUE(self):
            return self.getToken(Java8Parser.CONTINUE, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_statement




    def statement(self):

        localctx = Java8Parser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_statement)
        self._la = 0 # Token type
        try:
            self.state = 931
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 827
                localctx.blockLabel = self.block()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 828
                self.match(Java8Parser.ASSERT)
                self.state = 829
                self.expression(0)
                self.state = 832
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==Java8Parser.COLON:
                    self.state = 830
                    self.match(Java8Parser.COLON)
                    self.state = 831
                    self.expression(0)


                self.state = 834
                self.match(Java8Parser.SEMI)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 836
                self.match(Java8Parser.IF)
                self.state = 837
                self.parExpression()
                self.state = 838
                self.statement()
                self.state = 841
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
                if la_ == 1:
                    self.state = 839
                    self.match(Java8Parser.ELSE)
                    self.state = 840
                    self.statement()


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 843
                self.match(Java8Parser.FOR)
                self.state = 844
                self.match(Java8Parser.LPAREN)
                self.state = 845
                self.forControl()
                self.state = 846
                self.match(Java8Parser.RPAREN)
                self.state = 847
                self.statement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 849
                self.match(Java8Parser.WHILE)
                self.state = 850
                self.parExpression()
                self.state = 851
                self.statement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 853
                self.match(Java8Parser.DO)
                self.state = 854
                self.statement()
                self.state = 855
                self.match(Java8Parser.WHILE)
                self.state = 856
                self.parExpression()
                self.state = 857
                self.match(Java8Parser.SEMI)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 859
                self.match(Java8Parser.TRY)
                self.state = 860
                self.block()
                self.state = 870
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [Java8Parser.CATCH]:
                    self.state = 862 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 861
                        self.catchClause()
                        self.state = 864 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not (_la==Java8Parser.CATCH):
                            break

                    self.state = 867
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==Java8Parser.FINALLY:
                        self.state = 866
                        self.finallyBlock()


                    pass
                elif token in [Java8Parser.FINALLY]:
                    self.state = 869
                    self.finallyBlock()
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 872
                self.match(Java8Parser.TRY)
                self.state = 873
                self.resourceSpecification()
                self.state = 874
                self.block()
                self.state = 878
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==Java8Parser.CATCH:
                    self.state = 875
                    self.catchClause()
                    self.state = 880
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 882
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==Java8Parser.FINALLY:
                    self.state = 881
                    self.finallyBlock()


                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 884
                self.match(Java8Parser.SWITCH)
                self.state = 885
                self.parExpression()
                self.state = 886
                self.match(Java8Parser.LBRACE)
                self.state = 890
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,103,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 887
                        self.switchBlockStatementGroup() 
                    self.state = 892
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,103,self._ctx)

                self.state = 896
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==Java8Parser.CASE or _la==Java8Parser.DEFAULT:
                    self.state = 893
                    self.switchLabel()
                    self.state = 898
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 899
                self.match(Java8Parser.RBRACE)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 901
                self.match(Java8Parser.SYNCHRONIZED)
                self.state = 902
                self.parExpression()
                self.state = 903
                self.block()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 905
                self.match(Java8Parser.RETURN)
                self.state = 907
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NEW) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.SUPER) | (1 << Java8Parser.THIS) | (1 << Java8Parser.VOID) | (1 << Java8Parser.DECIMAL_LITERAL) | (1 << Java8Parser.HEX_LITERAL) | (1 << Java8Parser.OCT_LITERAL) | (1 << Java8Parser.BINARY_LITERAL) | (1 << Java8Parser.FLOAT_LITERAL) | (1 << Java8Parser.HEX_FLOAT_LITERAL) | (1 << Java8Parser.BOOL_LITERAL) | (1 << Java8Parser.CHAR_LITERAL) | (1 << Java8Parser.STRING_LITERAL) | (1 << Java8Parser.NULL_LITERAL) | (1 << Java8Parser.LPAREN))) != 0) or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (Java8Parser.LT - 72)) | (1 << (Java8Parser.BANG - 72)) | (1 << (Java8Parser.TILDE - 72)) | (1 << (Java8Parser.INC - 72)) | (1 << (Java8Parser.DEC - 72)) | (1 << (Java8Parser.ADD - 72)) | (1 << (Java8Parser.SUB - 72)) | (1 << (Java8Parser.AT - 72)) | (1 << (Java8Parser.IDENTIFIER - 72)))) != 0):
                    self.state = 906
                    self.expression(0)


                self.state = 909
                self.match(Java8Parser.SEMI)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 910
                self.match(Java8Parser.THROW)
                self.state = 911
                self.expression(0)
                self.state = 912
                self.match(Java8Parser.SEMI)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 914
                self.match(Java8Parser.BREAK)
                self.state = 916
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==Java8Parser.IDENTIFIER:
                    self.state = 915
                    self.match(Java8Parser.IDENTIFIER)


                self.state = 918
                self.match(Java8Parser.SEMI)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 919
                self.match(Java8Parser.CONTINUE)
                self.state = 921
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==Java8Parser.IDENTIFIER:
                    self.state = 920
                    self.match(Java8Parser.IDENTIFIER)


                self.state = 923
                self.match(Java8Parser.SEMI)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 924
                self.match(Java8Parser.SEMI)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 925
                localctx.statementExpression = self.expression(0)
                self.state = 926
                self.match(Java8Parser.SEMI)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 928
                localctx.identifierLabel = self.match(Java8Parser.IDENTIFIER)
                self.state = 929
                self.match(Java8Parser.COLON)
                self.state = 930
                self.statement()
                pass


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


    class CatchClauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CATCH(self):
            return self.getToken(Java8Parser.CATCH, 0)

        def LPAREN(self):
            return self.getToken(Java8Parser.LPAREN, 0)

        def catchType(self):
            return self.getTypedRuleContext(Java8Parser.CatchTypeContext,0)


        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def RPAREN(self):
            return self.getToken(Java8Parser.RPAREN, 0)

        def block(self):
            return self.getTypedRuleContext(Java8Parser.BlockContext,0)


        def variableModifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.VariableModifierContext)
            else:
                return self.getTypedRuleContext(Java8Parser.VariableModifierContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_catchClause




    def catchClause(self):

        localctx = Java8Parser.CatchClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_catchClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 933
            self.match(Java8Parser.CATCH)
            self.state = 934
            self.match(Java8Parser.LPAREN)
            self.state = 938
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.FINAL or _la==Java8Parser.AT:
                self.state = 935
                self.variableModifier()
                self.state = 940
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 941
            self.catchType()
            self.state = 942
            self.match(Java8Parser.IDENTIFIER)
            self.state = 943
            self.match(Java8Parser.RPAREN)
            self.state = 944
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CatchTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qualifiedName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.QualifiedNameContext)
            else:
                return self.getTypedRuleContext(Java8Parser.QualifiedNameContext,i)


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

        def getRuleIndex(self):
            return Java8Parser.RULE_catchType




    def catchType(self):

        localctx = Java8Parser.CatchTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_catchType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 946
            self.qualifiedName()
            self.state = 951
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.BITOR:
                self.state = 947
                self.match(Java8Parser.BITOR)
                self.state = 948
                self.qualifiedName()
                self.state = 953
                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 FinallyBlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FINALLY(self):
            return self.getToken(Java8Parser.FINALLY, 0)

        def block(self):
            return self.getTypedRuleContext(Java8Parser.BlockContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_finallyBlock




    def finallyBlock(self):

        localctx = Java8Parser.FinallyBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_finallyBlock)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 954
            self.match(Java8Parser.FINALLY)
            self.state = 955
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ResourceSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LPAREN(self):
            return self.getToken(Java8Parser.LPAREN, 0)

        def resources(self):
            return self.getTypedRuleContext(Java8Parser.ResourcesContext,0)


        def RPAREN(self):
            return self.getToken(Java8Parser.RPAREN, 0)

        def SEMI(self):
            return self.getToken(Java8Parser.SEMI, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_resourceSpecification




    def resourceSpecification(self):

        localctx = Java8Parser.ResourceSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_resourceSpecification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 957
            self.match(Java8Parser.LPAREN)
            self.state = 958
            self.resources()
            self.state = 960
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.SEMI:
                self.state = 959
                self.match(Java8Parser.SEMI)


            self.state = 962
            self.match(Java8Parser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ResourcesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def resource(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ResourceContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ResourceContext,i)


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

        def getRuleIndex(self):
            return Java8Parser.RULE_resources




    def resources(self):

        localctx = Java8Parser.ResourcesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_resources)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 964
            self.resource()
            self.state = 969
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,112,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 965
                    self.match(Java8Parser.SEMI)
                    self.state = 966
                    self.resource() 
                self.state = 971
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,112,self._ctx)

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


    class ResourceContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def classOrInterfaceType(self):
            return self.getTypedRuleContext(Java8Parser.ClassOrInterfaceTypeContext,0)


        def variableDeclaratorId(self):
            return self.getTypedRuleContext(Java8Parser.VariableDeclaratorIdContext,0)


        def ASSIGN(self):
            return self.getToken(Java8Parser.ASSIGN, 0)

        def expression(self):
            return self.getTypedRuleContext(Java8Parser.ExpressionContext,0)


        def variableModifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.VariableModifierContext)
            else:
                return self.getTypedRuleContext(Java8Parser.VariableModifierContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_resource




    def resource(self):

        localctx = Java8Parser.ResourceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_resource)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 975
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.FINAL or _la==Java8Parser.AT:
                self.state = 972
                self.variableModifier()
                self.state = 977
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 978
            self.classOrInterfaceType()
            self.state = 979
            self.variableDeclaratorId()
            self.state = 980
            self.match(Java8Parser.ASSIGN)
            self.state = 981
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SwitchBlockStatementGroupContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def switchLabel(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.SwitchLabelContext)
            else:
                return self.getTypedRuleContext(Java8Parser.SwitchLabelContext,i)


        def blockStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.BlockStatementContext)
            else:
                return self.getTypedRuleContext(Java8Parser.BlockStatementContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_switchBlockStatementGroup




    def switchBlockStatementGroup(self):

        localctx = Java8Parser.SwitchBlockStatementGroupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_switchBlockStatementGroup)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 984 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 983
                self.switchLabel()
                self.state = 986 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==Java8Parser.CASE or _la==Java8Parser.DEFAULT):
                    break

            self.state = 989 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 988
                self.blockStatement()
                self.state = 991 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.ABSTRACT) | (1 << Java8Parser.ASSERT) | (1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BREAK) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.CLASS) | (1 << Java8Parser.CONTINUE) | (1 << Java8Parser.DO) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FINAL) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.FOR) | (1 << Java8Parser.IF) | (1 << Java8Parser.INT) | (1 << Java8Parser.INTERFACE) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NEW) | (1 << Java8Parser.PRIVATE) | (1 << Java8Parser.PROTECTED) | (1 << Java8Parser.PUBLIC) | (1 << Java8Parser.RETURN) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.STATIC) | (1 << Java8Parser.STRICTFP) | (1 << Java8Parser.SUPER) | (1 << Java8Parser.SWITCH) | (1 << Java8Parser.SYNCHRONIZED) | (1 << Java8Parser.THIS) | (1 << Java8Parser.THROW) | (1 << Java8Parser.TRY) | (1 << Java8Parser.VOID) | (1 << Java8Parser.WHILE) | (1 << Java8Parser.DECIMAL_LITERAL) | (1 << Java8Parser.HEX_LITERAL) | (1 << Java8Parser.OCT_LITERAL) | (1 << Java8Parser.BINARY_LITERAL) | (1 << Java8Parser.FLOAT_LITERAL) | (1 << Java8Parser.HEX_FLOAT_LITERAL) | (1 << Java8Parser.BOOL_LITERAL) | (1 << Java8Parser.CHAR_LITERAL) | (1 << Java8Parser.STRING_LITERAL) | (1 << Java8Parser.NULL_LITERAL) | (1 << Java8Parser.LPAREN) | (1 << Java8Parser.LBRACE))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (Java8Parser.SEMI - 67)) | (1 << (Java8Parser.LT - 67)) | (1 << (Java8Parser.BANG - 67)) | (1 << (Java8Parser.TILDE - 67)) | (1 << (Java8Parser.INC - 67)) | (1 << (Java8Parser.DEC - 67)) | (1 << (Java8Parser.ADD - 67)) | (1 << (Java8Parser.SUB - 67)) | (1 << (Java8Parser.AT - 67)) | (1 << (Java8Parser.IDENTIFIER - 67)))) != 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 SwitchLabelContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.constantExpression = None # ExpressionContext
            self.enumConstantName = None # Token

        def CASE(self):
            return self.getToken(Java8Parser.CASE, 0)

        def COLON(self):
            return self.getToken(Java8Parser.COLON, 0)

        def expression(self):
            return self.getTypedRuleContext(Java8Parser.ExpressionContext,0)


        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def DEFAULT(self):
            return self.getToken(Java8Parser.DEFAULT, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_switchLabel




    def switchLabel(self):

        localctx = Java8Parser.SwitchLabelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_switchLabel)
        try:
            self.state = 1001
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.CASE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 993
                self.match(Java8Parser.CASE)
                self.state = 996
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,116,self._ctx)
                if la_ == 1:
                    self.state = 994
                    localctx.constantExpression = self.expression(0)
                    pass

                elif la_ == 2:
                    self.state = 995
                    localctx.enumConstantName = self.match(Java8Parser.IDENTIFIER)
                    pass


                self.state = 998
                self.match(Java8Parser.COLON)
                pass
            elif token in [Java8Parser.DEFAULT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 999
                self.match(Java8Parser.DEFAULT)
                self.state = 1000
                self.match(Java8Parser.COLON)
                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 ForControlContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def enhancedForControl(self):
            return self.getTypedRuleContext(Java8Parser.EnhancedForControlContext,0)


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

        def forInit(self):
            return self.getTypedRuleContext(Java8Parser.ForInitContext,0)


        def expression(self):
            return self.getTypedRuleContext(Java8Parser.ExpressionContext,0)


        def expressionList(self):
            return self.getTypedRuleContext(Java8Parser.ExpressionListContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_forControl




    def forControl(self):

        localctx = Java8Parser.ForControlContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_forControl)
        self._la = 0 # Token type
        try:
            self.state = 1015
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1003
                self.enhancedForControl()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1005
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FINAL) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NEW) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.SUPER) | (1 << Java8Parser.THIS) | (1 << Java8Parser.VOID) | (1 << Java8Parser.DECIMAL_LITERAL) | (1 << Java8Parser.HEX_LITERAL) | (1 << Java8Parser.OCT_LITERAL) | (1 << Java8Parser.BINARY_LITERAL) | (1 << Java8Parser.FLOAT_LITERAL) | (1 << Java8Parser.HEX_FLOAT_LITERAL) | (1 << Java8Parser.BOOL_LITERAL) | (1 << Java8Parser.CHAR_LITERAL) | (1 << Java8Parser.STRING_LITERAL) | (1 << Java8Parser.NULL_LITERAL) | (1 << Java8Parser.LPAREN))) != 0) or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (Java8Parser.LT - 72)) | (1 << (Java8Parser.BANG - 72)) | (1 << (Java8Parser.TILDE - 72)) | (1 << (Java8Parser.INC - 72)) | (1 << (Java8Parser.DEC - 72)) | (1 << (Java8Parser.ADD - 72)) | (1 << (Java8Parser.SUB - 72)) | (1 << (Java8Parser.AT - 72)) | (1 << (Java8Parser.IDENTIFIER - 72)))) != 0):
                    self.state = 1004
                    self.forInit()


                self.state = 1007
                self.match(Java8Parser.SEMI)
                self.state = 1009
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NEW) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.SUPER) | (1 << Java8Parser.THIS) | (1 << Java8Parser.VOID) | (1 << Java8Parser.DECIMAL_LITERAL) | (1 << Java8Parser.HEX_LITERAL) | (1 << Java8Parser.OCT_LITERAL) | (1 << Java8Parser.BINARY_LITERAL) | (1 << Java8Parser.FLOAT_LITERAL) | (1 << Java8Parser.HEX_FLOAT_LITERAL) | (1 << Java8Parser.BOOL_LITERAL) | (1 << Java8Parser.CHAR_LITERAL) | (1 << Java8Parser.STRING_LITERAL) | (1 << Java8Parser.NULL_LITERAL) | (1 << Java8Parser.LPAREN))) != 0) or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (Java8Parser.LT - 72)) | (1 << (Java8Parser.BANG - 72)) | (1 << (Java8Parser.TILDE - 72)) | (1 << (Java8Parser.INC - 72)) | (1 << (Java8Parser.DEC - 72)) | (1 << (Java8Parser.ADD - 72)) | (1 << (Java8Parser.SUB - 72)) | (1 << (Java8Parser.AT - 72)) | (1 << (Java8Parser.IDENTIFIER - 72)))) != 0):
                    self.state = 1008
                    self.expression(0)


                self.state = 1011
                self.match(Java8Parser.SEMI)
                self.state = 1013
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NEW) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.SUPER) | (1 << Java8Parser.THIS) | (1 << Java8Parser.VOID) | (1 << Java8Parser.DECIMAL_LITERAL) | (1 << Java8Parser.HEX_LITERAL) | (1 << Java8Parser.OCT_LITERAL) | (1 << Java8Parser.BINARY_LITERAL) | (1 << Java8Parser.FLOAT_LITERAL) | (1 << Java8Parser.HEX_FLOAT_LITERAL) | (1 << Java8Parser.BOOL_LITERAL) | (1 << Java8Parser.CHAR_LITERAL) | (1 << Java8Parser.STRING_LITERAL) | (1 << Java8Parser.NULL_LITERAL) | (1 << Java8Parser.LPAREN))) != 0) or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (Java8Parser.LT - 72)) | (1 << (Java8Parser.BANG - 72)) | (1 << (Java8Parser.TILDE - 72)) | (1 << (Java8Parser.INC - 72)) | (1 << (Java8Parser.DEC - 72)) | (1 << (Java8Parser.ADD - 72)) | (1 << (Java8Parser.SUB - 72)) | (1 << (Java8Parser.AT - 72)) | (1 << (Java8Parser.IDENTIFIER - 72)))) != 0):
                    self.state = 1012
                    localctx.forUpdate = self.expressionList()


                pass


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


    class ForInitContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def localVariableDeclaration(self):
            return self.getTypedRuleContext(Java8Parser.LocalVariableDeclarationContext,0)


        def expressionList(self):
            return self.getTypedRuleContext(Java8Parser.ExpressionListContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_forInit




    def forInit(self):

        localctx = Java8Parser.ForInitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_forInit)
        try:
            self.state = 1019
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1017
                self.localVariableDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1018
                self.expressionList()
                pass


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


    class EnhancedForControlContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeType(self):
            return self.getTypedRuleContext(Java8Parser.TypeTypeContext,0)


        def variableDeclaratorId(self):
            return self.getTypedRuleContext(Java8Parser.VariableDeclaratorIdContext,0)


        def COLON(self):
            return self.getToken(Java8Parser.COLON, 0)

        def expression(self):
            return self.getTypedRuleContext(Java8Parser.ExpressionContext,0)


        def variableModifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.VariableModifierContext)
            else:
                return self.getTypedRuleContext(Java8Parser.VariableModifierContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_enhancedForControl




    def enhancedForControl(self):

        localctx = Java8Parser.EnhancedForControlContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_enhancedForControl)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1024
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,123,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1021
                    self.variableModifier() 
                self.state = 1026
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,123,self._ctx)

            self.state = 1027
            self.typeType()
            self.state = 1028
            self.variableDeclaratorId()
            self.state = 1029
            self.match(Java8Parser.COLON)
            self.state = 1030
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LPAREN(self):
            return self.getToken(Java8Parser.LPAREN, 0)

        def expression(self):
            return self.getTypedRuleContext(Java8Parser.ExpressionContext,0)


        def RPAREN(self):
            return self.getToken(Java8Parser.RPAREN, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_parExpression




    def parExpression(self):

        localctx = Java8Parser.ParExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_parExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1032
            self.match(Java8Parser.LPAREN)
            self.state = 1033
            self.expression(0)
            self.state = 1034
            self.match(Java8Parser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ExpressionContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ExpressionContext,i)


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

        def getRuleIndex(self):
            return Java8Parser.RULE_expressionList




    def expressionList(self):

        localctx = Java8Parser.ExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_expressionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1036
            self.expression(0)
            self.state = 1041
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.COMMA:
                self.state = 1037
                self.match(Java8Parser.COMMA)
                self.state = 1038
                self.expression(0)
                self.state = 1043
                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 MethodCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def LPAREN(self):
            return self.getToken(Java8Parser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(Java8Parser.RPAREN, 0)

        def expressionList(self):
            return self.getTypedRuleContext(Java8Parser.ExpressionListContext,0)


        def THIS(self):
            return self.getToken(Java8Parser.THIS, 0)

        def SUPER(self):
            return self.getToken(Java8Parser.SUPER, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_methodCall




    def methodCall(self):

        localctx = Java8Parser.MethodCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_methodCall)
        self._la = 0 # Token type
        try:
            self.state = 1062
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1044
                self.match(Java8Parser.IDENTIFIER)
                self.state = 1045
                self.match(Java8Parser.LPAREN)
                self.state = 1047
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NEW) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.SUPER) | (1 << Java8Parser.THIS) | (1 << Java8Parser.VOID) | (1 << Java8Parser.DECIMAL_LITERAL) | (1 << Java8Parser.HEX_LITERAL) | (1 << Java8Parser.OCT_LITERAL) | (1 << Java8Parser.BINARY_LITERAL) | (1 << Java8Parser.FLOAT_LITERAL) | (1 << Java8Parser.HEX_FLOAT_LITERAL) | (1 << Java8Parser.BOOL_LITERAL) | (1 << Java8Parser.CHAR_LITERAL) | (1 << Java8Parser.STRING_LITERAL) | (1 << Java8Parser.NULL_LITERAL) | (1 << Java8Parser.LPAREN))) != 0) or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (Java8Parser.LT - 72)) | (1 << (Java8Parser.BANG - 72)) | (1 << (Java8Parser.TILDE - 72)) | (1 << (Java8Parser.INC - 72)) | (1 << (Java8Parser.DEC - 72)) | (1 << (Java8Parser.ADD - 72)) | (1 << (Java8Parser.SUB - 72)) | (1 << (Java8Parser.AT - 72)) | (1 << (Java8Parser.IDENTIFIER - 72)))) != 0):
                    self.state = 1046
                    self.expressionList()


                self.state = 1049
                self.match(Java8Parser.RPAREN)
                pass
            elif token in [Java8Parser.THIS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1050
                self.match(Java8Parser.THIS)
                self.state = 1051
                self.match(Java8Parser.LPAREN)
                self.state = 1053
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NEW) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.SUPER) | (1 << Java8Parser.THIS) | (1 << Java8Parser.VOID) | (1 << Java8Parser.DECIMAL_LITERAL) | (1 << Java8Parser.HEX_LITERAL) | (1 << Java8Parser.OCT_LITERAL) | (1 << Java8Parser.BINARY_LITERAL) | (1 << Java8Parser.FLOAT_LITERAL) | (1 << Java8Parser.HEX_FLOAT_LITERAL) | (1 << Java8Parser.BOOL_LITERAL) | (1 << Java8Parser.CHAR_LITERAL) | (1 << Java8Parser.STRING_LITERAL) | (1 << Java8Parser.NULL_LITERAL) | (1 << Java8Parser.LPAREN))) != 0) or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (Java8Parser.LT - 72)) | (1 << (Java8Parser.BANG - 72)) | (1 << (Java8Parser.TILDE - 72)) | (1 << (Java8Parser.INC - 72)) | (1 << (Java8Parser.DEC - 72)) | (1 << (Java8Parser.ADD - 72)) | (1 << (Java8Parser.SUB - 72)) | (1 << (Java8Parser.AT - 72)) | (1 << (Java8Parser.IDENTIFIER - 72)))) != 0):
                    self.state = 1052
                    self.expressionList()


                self.state = 1055
                self.match(Java8Parser.RPAREN)
                pass
            elif token in [Java8Parser.SUPER]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1056
                self.match(Java8Parser.SUPER)
                self.state = 1057
                self.match(Java8Parser.LPAREN)
                self.state = 1059
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NEW) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.SUPER) | (1 << Java8Parser.THIS) | (1 << Java8Parser.VOID) | (1 << Java8Parser.DECIMAL_LITERAL) | (1 << Java8Parser.HEX_LITERAL) | (1 << Java8Parser.OCT_LITERAL) | (1 << Java8Parser.BINARY_LITERAL) | (1 << Java8Parser.FLOAT_LITERAL) | (1 << Java8Parser.HEX_FLOAT_LITERAL) | (1 << Java8Parser.BOOL_LITERAL) | (1 << Java8Parser.CHAR_LITERAL) | (1 << Java8Parser.STRING_LITERAL) | (1 << Java8Parser.NULL_LITERAL) | (1 << Java8Parser.LPAREN))) != 0) or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (Java8Parser.LT - 72)) | (1 << (Java8Parser.BANG - 72)) | (1 << (Java8Parser.TILDE - 72)) | (1 << (Java8Parser.INC - 72)) | (1 << (Java8Parser.DEC - 72)) | (1 << (Java8Parser.ADD - 72)) | (1 << (Java8Parser.SUB - 72)) | (1 << (Java8Parser.AT - 72)) | (1 << (Java8Parser.IDENTIFIER - 72)))) != 0):
                    self.state = 1058
                    self.expressionList()


                self.state = 1061
                self.match(Java8Parser.RPAREN)
                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 ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.prefix = None # Token
            self.bop = None # Token
            self.postfix = None # Token

        def primary(self):
            return self.getTypedRuleContext(Java8Parser.PrimaryContext,0)


        def methodCall(self):
            return self.getTypedRuleContext(Java8Parser.MethodCallContext,0)


        def NEW(self):
            return self.getToken(Java8Parser.NEW, 0)

        def creator(self):
            return self.getTypedRuleContext(Java8Parser.CreatorContext,0)


        def LPAREN(self):
            return self.getToken(Java8Parser.LPAREN, 0)

        def typeType(self):
            return self.getTypedRuleContext(Java8Parser.TypeTypeContext,0)


        def RPAREN(self):
            return self.getToken(Java8Parser.RPAREN, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ExpressionContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ExpressionContext,i)


        def ADD(self):
            return self.getToken(Java8Parser.ADD, 0)

        def SUB(self):
            return self.getToken(Java8Parser.SUB, 0)

        def INC(self):
            return self.getToken(Java8Parser.INC, 0)

        def DEC(self):
            return self.getToken(Java8Parser.DEC, 0)

        def TILDE(self):
            return self.getToken(Java8Parser.TILDE, 0)

        def BANG(self):
            return self.getToken(Java8Parser.BANG, 0)

        def lambdaExpression(self):
            return self.getTypedRuleContext(Java8Parser.LambdaExpressionContext,0)


        def COLONCOLON(self):
            return self.getToken(Java8Parser.COLONCOLON, 0)

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def typeArguments(self):
            return self.getTypedRuleContext(Java8Parser.TypeArgumentsContext,0)


        def classType(self):
            return self.getTypedRuleContext(Java8Parser.ClassTypeContext,0)


        def MUL(self):
            return self.getToken(Java8Parser.MUL, 0)

        def DIV(self):
            return self.getToken(Java8Parser.DIV, 0)

        def MOD(self):
            return self.getToken(Java8Parser.MOD, 0)

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

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

        def LE(self):
            return self.getToken(Java8Parser.LE, 0)

        def GE(self):
            return self.getToken(Java8Parser.GE, 0)

        def EQUAL(self):
            return self.getToken(Java8Parser.EQUAL, 0)

        def NOTEQUAL(self):
            return self.getToken(Java8Parser.NOTEQUAL, 0)

        def BITAND(self):
            return self.getToken(Java8Parser.BITAND, 0)

        def CARET(self):
            return self.getToken(Java8Parser.CARET, 0)

        def BITOR(self):
            return self.getToken(Java8Parser.BITOR, 0)

        def AND(self):
            return self.getToken(Java8Parser.AND, 0)

        def OR(self):
            return self.getToken(Java8Parser.OR, 0)

        def COLON(self):
            return self.getToken(Java8Parser.COLON, 0)

        def QUESTION(self):
            return self.getToken(Java8Parser.QUESTION, 0)

        def ASSIGN(self):
            return self.getToken(Java8Parser.ASSIGN, 0)

        def ADD_ASSIGN(self):
            return self.getToken(Java8Parser.ADD_ASSIGN, 0)

        def SUB_ASSIGN(self):
            return self.getToken(Java8Parser.SUB_ASSIGN, 0)

        def MUL_ASSIGN(self):
            return self.getToken(Java8Parser.MUL_ASSIGN, 0)

        def DIV_ASSIGN(self):
            return self.getToken(Java8Parser.DIV_ASSIGN, 0)

        def AND_ASSIGN(self):
            return self.getToken(Java8Parser.AND_ASSIGN, 0)

        def OR_ASSIGN(self):
            return self.getToken(Java8Parser.OR_ASSIGN, 0)

        def XOR_ASSIGN(self):
            return self.getToken(Java8Parser.XOR_ASSIGN, 0)

        def RSHIFT_ASSIGN(self):
            return self.getToken(Java8Parser.RSHIFT_ASSIGN, 0)

        def URSHIFT_ASSIGN(self):
            return self.getToken(Java8Parser.URSHIFT_ASSIGN, 0)

        def LSHIFT_ASSIGN(self):
            return self.getToken(Java8Parser.LSHIFT_ASSIGN, 0)

        def MOD_ASSIGN(self):
            return self.getToken(Java8Parser.MOD_ASSIGN, 0)

        def DOT(self):
            return self.getToken(Java8Parser.DOT, 0)

        def THIS(self):
            return self.getToken(Java8Parser.THIS, 0)

        def innerCreator(self):
            return self.getTypedRuleContext(Java8Parser.InnerCreatorContext,0)


        def SUPER(self):
            return self.getToken(Java8Parser.SUPER, 0)

        def superSuffix(self):
            return self.getTypedRuleContext(Java8Parser.SuperSuffixContext,0)


        def explicitGenericInvocation(self):
            return self.getTypedRuleContext(Java8Parser.ExplicitGenericInvocationContext,0)


        def nonWildcardTypeArguments(self):
            return self.getTypedRuleContext(Java8Parser.NonWildcardTypeArgumentsContext,0)


        def LBRACK(self):
            return self.getToken(Java8Parser.LBRACK, 0)

        def RBRACK(self):
            return self.getToken(Java8Parser.RBRACK, 0)

        def INSTANCEOF(self):
            return self.getToken(Java8Parser.INSTANCEOF, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_expression



    def expression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = Java8Parser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 164
        self.enterRecursionRule(localctx, 164, self.RULE_expression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1095
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,132,self._ctx)
            if la_ == 1:
                self.state = 1065
                self.primary()
                pass

            elif la_ == 2:
                self.state = 1066
                self.methodCall()
                pass

            elif la_ == 3:
                self.state = 1067
                self.match(Java8Parser.NEW)
                self.state = 1068
                self.creator()
                pass

            elif la_ == 4:
                self.state = 1069
                self.match(Java8Parser.LPAREN)
                self.state = 1070
                self.typeType()
                self.state = 1071
                self.match(Java8Parser.RPAREN)
                self.state = 1072
                self.expression(21)
                pass

            elif la_ == 5:
                self.state = 1074
                localctx.prefix = self._input.LT(1)
                _la = self._input.LA(1)
                if not(((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (Java8Parser.INC - 83)) | (1 << (Java8Parser.DEC - 83)) | (1 << (Java8Parser.ADD - 83)) | (1 << (Java8Parser.SUB - 83)))) != 0)):
                    localctx.prefix = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1075
                self.expression(19)
                pass

            elif la_ == 6:
                self.state = 1076
                localctx.prefix = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==Java8Parser.BANG or _la==Java8Parser.TILDE):
                    localctx.prefix = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1077
                self.expression(18)
                pass

            elif la_ == 7:
                self.state = 1078
                self.lambdaExpression()
                pass

            elif la_ == 8:
                self.state = 1079
                self.typeType()
                self.state = 1080
                self.match(Java8Parser.COLONCOLON)
                self.state = 1086
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [Java8Parser.LT, Java8Parser.IDENTIFIER]:
                    self.state = 1082
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==Java8Parser.LT:
                        self.state = 1081
                        self.typeArguments()


                    self.state = 1084
                    self.match(Java8Parser.IDENTIFIER)
                    pass
                elif token in [Java8Parser.NEW]:
                    self.state = 1085
                    self.match(Java8Parser.NEW)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 9:
                self.state = 1088
                self.classType()
                self.state = 1089
                self.match(Java8Parser.COLONCOLON)
                self.state = 1091
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==Java8Parser.LT:
                    self.state = 1090
                    self.typeArguments()


                self.state = 1093
                self.match(Java8Parser.NEW)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1177
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,138,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 1175
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,137,self._ctx)
                    if la_ == 1:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1097
                        if not self.precpred(self._ctx, 17):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
                        self.state = 1098
                        localctx.bop = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 87)) & ~0x3f) == 0 and ((1 << (_la - 87)) & ((1 << (Java8Parser.MUL - 87)) | (1 << (Java8Parser.DIV - 87)) | (1 << (Java8Parser.MOD - 87)))) != 0)):
                            localctx.bop = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1099
                        self.expression(18)
                        pass

                    elif la_ == 2:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1100
                        if not self.precpred(self._ctx, 16):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
                        self.state = 1101
                        localctx.bop = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==Java8Parser.ADD or _la==Java8Parser.SUB):
                            localctx.bop = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1102
                        self.expression(17)
                        pass

                    elif la_ == 3:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1103
                        if not self.precpred(self._ctx, 15):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 15)")
                        self.state = 1111
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,133,self._ctx)
                        if la_ == 1:
                            self.state = 1104
                            self.match(Java8Parser.LT)
                            self.state = 1105
                            self.match(Java8Parser.LT)
                            pass

                        elif la_ == 2:
                            self.state = 1106
                            self.match(Java8Parser.GT)
                            self.state = 1107
                            self.match(Java8Parser.GT)
                            self.state = 1108
                            self.match(Java8Parser.GT)
                            pass

                        elif la_ == 3:
                            self.state = 1109
                            self.match(Java8Parser.GT)
                            self.state = 1110
                            self.match(Java8Parser.GT)
                            pass


                        self.state = 1113
                        self.expression(16)
                        pass

                    elif la_ == 4:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1114
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 1115
                        localctx.bop = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (Java8Parser.GT - 71)) | (1 << (Java8Parser.LT - 71)) | (1 << (Java8Parser.LE - 71)) | (1 << (Java8Parser.GE - 71)))) != 0)):
                            localctx.bop = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1116
                        self.expression(15)
                        pass

                    elif la_ == 5:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1117
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 1118
                        localctx.bop = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==Java8Parser.EQUAL or _la==Java8Parser.NOTEQUAL):
                            localctx.bop = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1119
                        self.expression(13)
                        pass

                    elif la_ == 6:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1120
                        if not self.precpred(self._ctx, 11):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        self.state = 1121
                        localctx.bop = self.match(Java8Parser.BITAND)
                        self.state = 1122
                        self.expression(12)
                        pass

                    elif la_ == 7:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1123
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 1124
                        localctx.bop = self.match(Java8Parser.CARET)
                        self.state = 1125
                        self.expression(11)
                        pass

                    elif la_ == 8:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1126
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 1127
                        localctx.bop = self.match(Java8Parser.BITOR)
                        self.state = 1128
                        self.expression(10)
                        pass

                    elif la_ == 9:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1129
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 1130
                        localctx.bop = self.match(Java8Parser.AND)
                        self.state = 1131
                        self.expression(9)
                        pass

                    elif la_ == 10:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1132
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 1133
                        localctx.bop = self.match(Java8Parser.OR)
                        self.state = 1134
                        self.expression(8)
                        pass

                    elif la_ == 11:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1135
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 1136
                        localctx.bop = self.match(Java8Parser.QUESTION)
                        self.state = 1137
                        self.expression(0)
                        self.state = 1138
                        self.match(Java8Parser.COLON)
                        self.state = 1139
                        self.expression(7)
                        pass

                    elif la_ == 12:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1141
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 1142
                        localctx.bop = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (Java8Parser.ASSIGN - 70)) | (1 << (Java8Parser.ADD_ASSIGN - 70)) | (1 << (Java8Parser.SUB_ASSIGN - 70)) | (1 << (Java8Parser.MUL_ASSIGN - 70)) | (1 << (Java8Parser.DIV_ASSIGN - 70)) | (1 << (Java8Parser.AND_ASSIGN - 70)) | (1 << (Java8Parser.OR_ASSIGN - 70)) | (1 << (Java8Parser.XOR_ASSIGN - 70)) | (1 << (Java8Parser.MOD_ASSIGN - 70)) | (1 << (Java8Parser.LSHIFT_ASSIGN - 70)) | (1 << (Java8Parser.RSHIFT_ASSIGN - 70)) | (1 << (Java8Parser.URSHIFT_ASSIGN - 70)))) != 0)):
                            localctx.bop = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1143
                        self.expression(5)
                        pass

                    elif la_ == 13:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1144
                        if not self.precpred(self._ctx, 25):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 25)")
                        self.state = 1145
                        localctx.bop = self.match(Java8Parser.DOT)
                        self.state = 1157
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
                        if la_ == 1:
                            self.state = 1146
                            self.match(Java8Parser.IDENTIFIER)
                            pass

                        elif la_ == 2:
                            self.state = 1147
                            self.methodCall()
                            pass

                        elif la_ == 3:
                            self.state = 1148
                            self.match(Java8Parser.THIS)
                            pass

                        elif la_ == 4:
                            self.state = 1149
                            self.match(Java8Parser.NEW)
                            self.state = 1151
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if _la==Java8Parser.LT:
                                self.state = 1150
                                self.nonWildcardTypeArguments()


                            self.state = 1153
                            self.innerCreator()
                            pass

                        elif la_ == 5:
                            self.state = 1154
                            self.match(Java8Parser.SUPER)
                            self.state = 1155
                            self.superSuffix()
                            pass

                        elif la_ == 6:
                            self.state = 1156
                            self.explicitGenericInvocation()
                            pass


                        pass

                    elif la_ == 14:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1159
                        if not self.precpred(self._ctx, 24):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 24)")
                        self.state = 1160
                        self.match(Java8Parser.LBRACK)
                        self.state = 1161
                        self.expression(0)
                        self.state = 1162
                        self.match(Java8Parser.RBRACK)
                        pass

                    elif la_ == 15:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1164
                        if not self.precpred(self._ctx, 20):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 20)")
                        self.state = 1165
                        localctx.postfix = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==Java8Parser.INC or _la==Java8Parser.DEC):
                            localctx.postfix = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        pass

                    elif la_ == 16:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1166
                        if not self.precpred(self._ctx, 13):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 13)")
                        self.state = 1167
                        localctx.bop = self.match(Java8Parser.INSTANCEOF)
                        self.state = 1168
                        self.typeType()
                        pass

                    elif la_ == 17:
                        localctx = Java8Parser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1169
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 1170
                        self.match(Java8Parser.COLONCOLON)
                        self.state = 1172
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==Java8Parser.LT:
                            self.state = 1171
                            self.typeArguments()


                        self.state = 1174
                        self.match(Java8Parser.IDENTIFIER)
                        pass

             
                self.state = 1179
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,138,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 LambdaExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def lambdaParameters(self):
            return self.getTypedRuleContext(Java8Parser.LambdaParametersContext,0)


        def ARROW(self):
            return self.getToken(Java8Parser.ARROW, 0)

        def lambdaBody(self):
            return self.getTypedRuleContext(Java8Parser.LambdaBodyContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_lambdaExpression




    def lambdaExpression(self):

        localctx = Java8Parser.LambdaExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_lambdaExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1180
            self.lambdaParameters()
            self.state = 1181
            self.match(Java8Parser.ARROW)
            self.state = 1182
            self.lambdaBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LambdaParametersContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def LPAREN(self):
            return self.getToken(Java8Parser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(Java8Parser.RPAREN, 0)

        def formalParameterList(self):
            return self.getTypedRuleContext(Java8Parser.FormalParameterListContext,0)


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

        def getRuleIndex(self):
            return Java8Parser.RULE_lambdaParameters




    def lambdaParameters(self):

        localctx = Java8Parser.LambdaParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_lambdaParameters)
        self._la = 0 # Token type
        try:
            self.state = 1200
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,141,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1184
                self.match(Java8Parser.IDENTIFIER)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1185
                self.match(Java8Parser.LPAREN)
                self.state = 1187
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FINAL) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.LONG) | (1 << Java8Parser.SHORT))) != 0) or _la==Java8Parser.AT or _la==Java8Parser.IDENTIFIER:
                    self.state = 1186
                    self.formalParameterList()


                self.state = 1189
                self.match(Java8Parser.RPAREN)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1190
                self.match(Java8Parser.LPAREN)
                self.state = 1191
                self.match(Java8Parser.IDENTIFIER)
                self.state = 1196
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==Java8Parser.COMMA:
                    self.state = 1192
                    self.match(Java8Parser.COMMA)
                    self.state = 1193
                    self.match(Java8Parser.IDENTIFIER)
                    self.state = 1198
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1199
                self.match(Java8Parser.RPAREN)
                pass


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


    class LambdaBodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self):
            return self.getTypedRuleContext(Java8Parser.ExpressionContext,0)


        def block(self):
            return self.getTypedRuleContext(Java8Parser.BlockContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_lambdaBody




    def lambdaBody(self):

        localctx = Java8Parser.LambdaBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_lambdaBody)
        try:
            self.state = 1204
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.BOOLEAN, Java8Parser.BYTE, Java8Parser.CHAR, Java8Parser.DOUBLE, Java8Parser.FLOAT, Java8Parser.INT, Java8Parser.LONG, Java8Parser.NEW, Java8Parser.SHORT, Java8Parser.SUPER, Java8Parser.THIS, Java8Parser.VOID, Java8Parser.DECIMAL_LITERAL, Java8Parser.HEX_LITERAL, Java8Parser.OCT_LITERAL, Java8Parser.BINARY_LITERAL, Java8Parser.FLOAT_LITERAL, Java8Parser.HEX_FLOAT_LITERAL, Java8Parser.BOOL_LITERAL, Java8Parser.CHAR_LITERAL, Java8Parser.STRING_LITERAL, Java8Parser.NULL_LITERAL, Java8Parser.LPAREN, Java8Parser.LT, Java8Parser.BANG, Java8Parser.TILDE, Java8Parser.INC, Java8Parser.DEC, Java8Parser.ADD, Java8Parser.SUB, Java8Parser.AT, Java8Parser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1202
                self.expression(0)
                pass
            elif token in [Java8Parser.LBRACE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1203
                self.block()
                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 PrimaryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LPAREN(self):
            return self.getToken(Java8Parser.LPAREN, 0)

        def expression(self):
            return self.getTypedRuleContext(Java8Parser.ExpressionContext,0)


        def RPAREN(self):
            return self.getToken(Java8Parser.RPAREN, 0)

        def THIS(self):
            return self.getToken(Java8Parser.THIS, 0)

        def SUPER(self):
            return self.getToken(Java8Parser.SUPER, 0)

        def literal(self):
            return self.getTypedRuleContext(Java8Parser.LiteralContext,0)


        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def typeTypeOrVoid(self):
            return self.getTypedRuleContext(Java8Parser.TypeTypeOrVoidContext,0)


        def DOT(self):
            return self.getToken(Java8Parser.DOT, 0)

        def CLASS(self):
            return self.getToken(Java8Parser.CLASS, 0)

        def nonWildcardTypeArguments(self):
            return self.getTypedRuleContext(Java8Parser.NonWildcardTypeArgumentsContext,0)


        def explicitGenericInvocationSuffix(self):
            return self.getTypedRuleContext(Java8Parser.ExplicitGenericInvocationSuffixContext,0)


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


        def getRuleIndex(self):
            return Java8Parser.RULE_primary




    def primary(self):

        localctx = Java8Parser.PrimaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_primary)
        try:
            self.state = 1224
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,144,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1206
                self.match(Java8Parser.LPAREN)
                self.state = 1207
                self.expression(0)
                self.state = 1208
                self.match(Java8Parser.RPAREN)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1210
                self.match(Java8Parser.THIS)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1211
                self.match(Java8Parser.SUPER)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1212
                self.literal()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1213
                self.match(Java8Parser.IDENTIFIER)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1214
                self.typeTypeOrVoid()
                self.state = 1215
                self.match(Java8Parser.DOT)
                self.state = 1216
                self.match(Java8Parser.CLASS)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1218
                self.nonWildcardTypeArguments()
                self.state = 1222
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [Java8Parser.SUPER, Java8Parser.IDENTIFIER]:
                    self.state = 1219
                    self.explicitGenericInvocationSuffix()
                    pass
                elif token in [Java8Parser.THIS]:
                    self.state = 1220
                    self.match(Java8Parser.THIS)
                    self.state = 1221
                    self.arguments()
                    pass
                else:
                    raise NoViableAltException(self)

                pass


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


    class ClassTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def classOrInterfaceType(self):
            return self.getTypedRuleContext(Java8Parser.ClassOrInterfaceTypeContext,0)


        def DOT(self):
            return self.getToken(Java8Parser.DOT, 0)

        def annotation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.AnnotationContext)
            else:
                return self.getTypedRuleContext(Java8Parser.AnnotationContext,i)


        def typeArguments(self):
            return self.getTypedRuleContext(Java8Parser.TypeArgumentsContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_classType




    def classType(self):

        localctx = Java8Parser.ClassTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_classType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1229
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,145,self._ctx)
            if la_ == 1:
                self.state = 1226
                self.classOrInterfaceType()
                self.state = 1227
                self.match(Java8Parser.DOT)


            self.state = 1234
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.AT:
                self.state = 1231
                self.annotation()
                self.state = 1236
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1237
            self.match(Java8Parser.IDENTIFIER)
            self.state = 1239
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.LT:
                self.state = 1238
                self.typeArguments()


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


    class CreatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nonWildcardTypeArguments(self):
            return self.getTypedRuleContext(Java8Parser.NonWildcardTypeArgumentsContext,0)


        def createdName(self):
            return self.getTypedRuleContext(Java8Parser.CreatedNameContext,0)


        def classCreatorRest(self):
            return self.getTypedRuleContext(Java8Parser.ClassCreatorRestContext,0)


        def arrayCreatorRest(self):
            return self.getTypedRuleContext(Java8Parser.ArrayCreatorRestContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_creator




    def creator(self):

        localctx = Java8Parser.CreatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_creator)
        try:
            self.state = 1250
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.LT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1241
                self.nonWildcardTypeArguments()
                self.state = 1242
                self.createdName()
                self.state = 1243
                self.classCreatorRest()
                pass
            elif token in [Java8Parser.BOOLEAN, Java8Parser.BYTE, Java8Parser.CHAR, Java8Parser.DOUBLE, Java8Parser.FLOAT, Java8Parser.INT, Java8Parser.LONG, Java8Parser.SHORT, Java8Parser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1245
                self.createdName()
                self.state = 1248
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [Java8Parser.LBRACK]:
                    self.state = 1246
                    self.arrayCreatorRest()
                    pass
                elif token in [Java8Parser.LPAREN]:
                    self.state = 1247
                    self.classCreatorRest()
                    pass
                else:
                    raise NoViableAltException(self)

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

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

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

        def typeArgumentsOrDiamond(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.TypeArgumentsOrDiamondContext)
            else:
                return self.getTypedRuleContext(Java8Parser.TypeArgumentsOrDiamondContext,i)


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

        def primitiveType(self):
            return self.getTypedRuleContext(Java8Parser.PrimitiveTypeContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_createdName




    def createdName(self):

        localctx = Java8Parser.CreatedNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_createdName)
        self._la = 0 # Token type
        try:
            self.state = 1267
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1252
                self.match(Java8Parser.IDENTIFIER)
                self.state = 1254
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==Java8Parser.LT:
                    self.state = 1253
                    self.typeArgumentsOrDiamond()


                self.state = 1263
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==Java8Parser.DOT:
                    self.state = 1256
                    self.match(Java8Parser.DOT)
                    self.state = 1257
                    self.match(Java8Parser.IDENTIFIER)
                    self.state = 1259
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==Java8Parser.LT:
                        self.state = 1258
                        self.typeArgumentsOrDiamond()


                    self.state = 1265
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [Java8Parser.BOOLEAN, Java8Parser.BYTE, Java8Parser.CHAR, Java8Parser.DOUBLE, Java8Parser.FLOAT, Java8Parser.INT, Java8Parser.LONG, Java8Parser.SHORT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1266
                self.primitiveType()
                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 InnerCreatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def classCreatorRest(self):
            return self.getTypedRuleContext(Java8Parser.ClassCreatorRestContext,0)


        def nonWildcardTypeArgumentsOrDiamond(self):
            return self.getTypedRuleContext(Java8Parser.NonWildcardTypeArgumentsOrDiamondContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_innerCreator




    def innerCreator(self):

        localctx = Java8Parser.InnerCreatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_innerCreator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1269
            self.match(Java8Parser.IDENTIFIER)
            self.state = 1271
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.LT:
                self.state = 1270
                self.nonWildcardTypeArgumentsOrDiamond()


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


    class ArrayCreatorRestContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def arrayInitializer(self):
            return self.getTypedRuleContext(Java8Parser.ArrayInitializerContext,0)


        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.ExpressionContext)
            else:
                return self.getTypedRuleContext(Java8Parser.ExpressionContext,i)


        def getRuleIndex(self):
            return Java8Parser.RULE_arrayCreatorRest




    def arrayCreatorRest(self):

        localctx = Java8Parser.ArrayCreatorRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_arrayCreatorRest)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1275
            self.match(Java8Parser.LBRACK)
            self.state = 1303
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.RBRACK]:
                self.state = 1276
                self.match(Java8Parser.RBRACK)
                self.state = 1281
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==Java8Parser.LBRACK:
                    self.state = 1277
                    self.match(Java8Parser.LBRACK)
                    self.state = 1278
                    self.match(Java8Parser.RBRACK)
                    self.state = 1283
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1284
                self.arrayInitializer()
                pass
            elif token in [Java8Parser.BOOLEAN, Java8Parser.BYTE, Java8Parser.CHAR, Java8Parser.DOUBLE, Java8Parser.FLOAT, Java8Parser.INT, Java8Parser.LONG, Java8Parser.NEW, Java8Parser.SHORT, Java8Parser.SUPER, Java8Parser.THIS, Java8Parser.VOID, Java8Parser.DECIMAL_LITERAL, Java8Parser.HEX_LITERAL, Java8Parser.OCT_LITERAL, Java8Parser.BINARY_LITERAL, Java8Parser.FLOAT_LITERAL, Java8Parser.HEX_FLOAT_LITERAL, Java8Parser.BOOL_LITERAL, Java8Parser.CHAR_LITERAL, Java8Parser.STRING_LITERAL, Java8Parser.NULL_LITERAL, Java8Parser.LPAREN, Java8Parser.LT, Java8Parser.BANG, Java8Parser.TILDE, Java8Parser.INC, Java8Parser.DEC, Java8Parser.ADD, Java8Parser.SUB, Java8Parser.AT, Java8Parser.IDENTIFIER]:
                self.state = 1285
                self.expression(0)
                self.state = 1286
                self.match(Java8Parser.RBRACK)
                self.state = 1293
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,156,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1287
                        self.match(Java8Parser.LBRACK)
                        self.state = 1288
                        self.expression(0)
                        self.state = 1289
                        self.match(Java8Parser.RBRACK) 
                    self.state = 1295
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,156,self._ctx)

                self.state = 1300
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,157,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1296
                        self.match(Java8Parser.LBRACK)
                        self.state = 1297
                        self.match(Java8Parser.RBRACK) 
                    self.state = 1302
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,157,self._ctx)

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

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

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


        def classBody(self):
            return self.getTypedRuleContext(Java8Parser.ClassBodyContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_classCreatorRest




    def classCreatorRest(self):

        localctx = Java8Parser.ClassCreatorRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_classCreatorRest)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1305
            self.arguments()
            self.state = 1307
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,159,self._ctx)
            if la_ == 1:
                self.state = 1306
                self.classBody()


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


    class ExplicitGenericInvocationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nonWildcardTypeArguments(self):
            return self.getTypedRuleContext(Java8Parser.NonWildcardTypeArgumentsContext,0)


        def explicitGenericInvocationSuffix(self):
            return self.getTypedRuleContext(Java8Parser.ExplicitGenericInvocationSuffixContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_explicitGenericInvocation




    def explicitGenericInvocation(self):

        localctx = Java8Parser.ExplicitGenericInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_explicitGenericInvocation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1309
            self.nonWildcardTypeArguments()
            self.state = 1310
            self.explicitGenericInvocationSuffix()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeArgumentsOrDiamondContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LT(self):
            return self.getToken(Java8Parser.LT, 0)

        def GT(self):
            return self.getToken(Java8Parser.GT, 0)

        def typeArguments(self):
            return self.getTypedRuleContext(Java8Parser.TypeArgumentsContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_typeArgumentsOrDiamond




    def typeArgumentsOrDiamond(self):

        localctx = Java8Parser.TypeArgumentsOrDiamondContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_typeArgumentsOrDiamond)
        try:
            self.state = 1315
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1312
                self.match(Java8Parser.LT)
                self.state = 1313
                self.match(Java8Parser.GT)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1314
                self.typeArguments()
                pass


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


    class NonWildcardTypeArgumentsOrDiamondContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LT(self):
            return self.getToken(Java8Parser.LT, 0)

        def GT(self):
            return self.getToken(Java8Parser.GT, 0)

        def nonWildcardTypeArguments(self):
            return self.getTypedRuleContext(Java8Parser.NonWildcardTypeArgumentsContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_nonWildcardTypeArgumentsOrDiamond




    def nonWildcardTypeArgumentsOrDiamond(self):

        localctx = Java8Parser.NonWildcardTypeArgumentsOrDiamondContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_nonWildcardTypeArgumentsOrDiamond)
        try:
            self.state = 1320
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,161,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1317
                self.match(Java8Parser.LT)
                self.state = 1318
                self.match(Java8Parser.GT)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1319
                self.nonWildcardTypeArguments()
                pass


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


    class NonWildcardTypeArgumentsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LT(self):
            return self.getToken(Java8Parser.LT, 0)

        def typeList(self):
            return self.getTypedRuleContext(Java8Parser.TypeListContext,0)


        def GT(self):
            return self.getToken(Java8Parser.GT, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_nonWildcardTypeArguments




    def nonWildcardTypeArguments(self):

        localctx = Java8Parser.NonWildcardTypeArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_nonWildcardTypeArguments)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1322
            self.match(Java8Parser.LT)
            self.state = 1323
            self.typeList()
            self.state = 1324
            self.match(Java8Parser.GT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.TypeTypeContext)
            else:
                return self.getTypedRuleContext(Java8Parser.TypeTypeContext,i)


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

        def getRuleIndex(self):
            return Java8Parser.RULE_typeList




    def typeList(self):

        localctx = Java8Parser.TypeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_typeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1326
            self.typeType()
            self.state = 1331
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.COMMA:
                self.state = 1327
                self.match(Java8Parser.COMMA)
                self.state = 1328
                self.typeType()
                self.state = 1333
                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 TypeTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def classOrInterfaceType(self):
            return self.getTypedRuleContext(Java8Parser.ClassOrInterfaceTypeContext,0)


        def primitiveType(self):
            return self.getTypedRuleContext(Java8Parser.PrimitiveTypeContext,0)


        def annotation(self):
            return self.getTypedRuleContext(Java8Parser.AnnotationContext,0)


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

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

        def getRuleIndex(self):
            return Java8Parser.RULE_typeType




    def typeType(self):

        localctx = Java8Parser.TypeTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_typeType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1335
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==Java8Parser.AT:
                self.state = 1334
                self.annotation()


            self.state = 1339
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.IDENTIFIER]:
                self.state = 1337
                self.classOrInterfaceType()
                pass
            elif token in [Java8Parser.BOOLEAN, Java8Parser.BYTE, Java8Parser.CHAR, Java8Parser.DOUBLE, Java8Parser.FLOAT, Java8Parser.INT, Java8Parser.LONG, Java8Parser.SHORT]:
                self.state = 1338
                self.primitiveType()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1345
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,165,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1341
                    self.match(Java8Parser.LBRACK)
                    self.state = 1342
                    self.match(Java8Parser.RBRACK) 
                self.state = 1347
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,165,self._ctx)

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


    class PrimitiveTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BOOLEAN(self):
            return self.getToken(Java8Parser.BOOLEAN, 0)

        def CHAR(self):
            return self.getToken(Java8Parser.CHAR, 0)

        def BYTE(self):
            return self.getToken(Java8Parser.BYTE, 0)

        def SHORT(self):
            return self.getToken(Java8Parser.SHORT, 0)

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

        def LONG(self):
            return self.getToken(Java8Parser.LONG, 0)

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

        def DOUBLE(self):
            return self.getToken(Java8Parser.DOUBLE, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_primitiveType




    def primitiveType(self):

        localctx = Java8Parser.PrimitiveTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_primitiveType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1348
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.LONG) | (1 << Java8Parser.SHORT))) != 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 TypeArgumentsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LT(self):
            return self.getToken(Java8Parser.LT, 0)

        def typeArgument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Java8Parser.TypeArgumentContext)
            else:
                return self.getTypedRuleContext(Java8Parser.TypeArgumentContext,i)


        def GT(self):
            return self.getToken(Java8Parser.GT, 0)

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

        def getRuleIndex(self):
            return Java8Parser.RULE_typeArguments




    def typeArguments(self):

        localctx = Java8Parser.TypeArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_typeArguments)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1350
            self.match(Java8Parser.LT)
            self.state = 1351
            self.typeArgument()
            self.state = 1356
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==Java8Parser.COMMA:
                self.state = 1352
                self.match(Java8Parser.COMMA)
                self.state = 1353
                self.typeArgument()
                self.state = 1358
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1359
            self.match(Java8Parser.GT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SuperSuffixContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def DOT(self):
            return self.getToken(Java8Parser.DOT, 0)

        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return Java8Parser.RULE_superSuffix




    def superSuffix(self):

        localctx = Java8Parser.SuperSuffixContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_superSuffix)
        try:
            self.state = 1367
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.LPAREN]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1361
                self.arguments()
                pass
            elif token in [Java8Parser.DOT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1362
                self.match(Java8Parser.DOT)
                self.state = 1363
                self.match(Java8Parser.IDENTIFIER)
                self.state = 1365
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,167,self._ctx)
                if la_ == 1:
                    self.state = 1364
                    self.arguments()


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

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

        def SUPER(self):
            return self.getToken(Java8Parser.SUPER, 0)

        def superSuffix(self):
            return self.getTypedRuleContext(Java8Parser.SuperSuffixContext,0)


        def IDENTIFIER(self):
            return self.getToken(Java8Parser.IDENTIFIER, 0)

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


        def getRuleIndex(self):
            return Java8Parser.RULE_explicitGenericInvocationSuffix




    def explicitGenericInvocationSuffix(self):

        localctx = Java8Parser.ExplicitGenericInvocationSuffixContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_explicitGenericInvocationSuffix)
        try:
            self.state = 1373
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [Java8Parser.SUPER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1369
                self.match(Java8Parser.SUPER)
                self.state = 1370
                self.superSuffix()
                pass
            elif token in [Java8Parser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1371
                self.match(Java8Parser.IDENTIFIER)
                self.state = 1372
                self.arguments()
                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 ArgumentsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LPAREN(self):
            return self.getToken(Java8Parser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(Java8Parser.RPAREN, 0)

        def expressionList(self):
            return self.getTypedRuleContext(Java8Parser.ExpressionListContext,0)


        def getRuleIndex(self):
            return Java8Parser.RULE_arguments




    def arguments(self):

        localctx = Java8Parser.ArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_arguments)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1375
            self.match(Java8Parser.LPAREN)
            self.state = 1377
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << Java8Parser.BOOLEAN) | (1 << Java8Parser.BYTE) | (1 << Java8Parser.CHAR) | (1 << Java8Parser.DOUBLE) | (1 << Java8Parser.FLOAT) | (1 << Java8Parser.INT) | (1 << Java8Parser.LONG) | (1 << Java8Parser.NEW) | (1 << Java8Parser.SHORT) | (1 << Java8Parser.SUPER) | (1 << Java8Parser.THIS) | (1 << Java8Parser.VOID) | (1 << Java8Parser.DECIMAL_LITERAL) | (1 << Java8Parser.HEX_LITERAL) | (1 << Java8Parser.OCT_LITERAL) | (1 << Java8Parser.BINARY_LITERAL) | (1 << Java8Parser.FLOAT_LITERAL) | (1 << Java8Parser.HEX_FLOAT_LITERAL) | (1 << Java8Parser.BOOL_LITERAL) | (1 << Java8Parser.CHAR_LITERAL) | (1 << Java8Parser.STRING_LITERAL) | (1 << Java8Parser.NULL_LITERAL) | (1 << Java8Parser.LPAREN))) != 0) or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (Java8Parser.LT - 72)) | (1 << (Java8Parser.BANG - 72)) | (1 << (Java8Parser.TILDE - 72)) | (1 << (Java8Parser.INC - 72)) | (1 << (Java8Parser.DEC - 72)) | (1 << (Java8Parser.ADD - 72)) | (1 << (Java8Parser.SUB - 72)) | (1 << (Java8Parser.AT - 72)) | (1 << (Java8Parser.IDENTIFIER - 72)))) != 0):
                self.state = 1376
                self.expressionList()


            self.state = 1379
            self.match(Java8Parser.RPAREN)
        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[82] = self.expression_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 expression_sempred(self, localctx:ExpressionContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 17)
         

            if predIndex == 1:
                return self.precpred(self._ctx, 16)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 15)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 14)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 12)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 11)
         

            if predIndex == 6:
                return self.precpred(self._ctx, 10)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 9)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 7)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 11:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 12:
                return self.precpred(self._ctx, 25)
         

            if predIndex == 13:
                return self.precpred(self._ctx, 24)
         

            if predIndex == 14:
                return self.precpred(self._ctx, 20)
         

            if predIndex == 15:
                return self.precpred(self._ctx, 13)
         

            if predIndex == 16:
                return self.precpred(self._ctx, 3)
         




