// Code generated from Java8Parser.g4 by ANTLR 4.9.3. DO NOT EDIT.

package java8 // Java8Parser
import (
	"fmt"
	"reflect"
	"strconv"

	"github.com/antlr/antlr4/runtime/Go/antlr"
)

// Suppress unused import errors
var _ = fmt.Printf
var _ = reflect.Copy
var _ = strconv.Itoa

var parserATN = []uint16{
	3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 109, 2846,
	4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7,
	4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13,
	9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9,
	18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23,
	4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4,
	29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34,
	9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9,
	39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44,
	4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4,
	50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55,
	9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9,
	60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65,
	4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4,
	71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76,
	9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9,
	81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86,
	4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4,
	92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97,
	9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102,
	9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106,
	4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111,
	9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115,
	4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120,
	9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124,
	4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129,
	9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133,
	4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138,
	9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142,
	4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147,
	9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151,
	4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156,
	9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160,
	4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165,
	9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 4, 168, 9, 168, 4, 169, 9, 169,
	4, 170, 9, 170, 4, 171, 9, 171, 4, 172, 9, 172, 4, 173, 9, 173, 4, 174,
	9, 174, 4, 175, 9, 175, 4, 176, 9, 176, 4, 177, 9, 177, 4, 178, 9, 178,
	4, 179, 9, 179, 4, 180, 9, 180, 4, 181, 9, 181, 4, 182, 9, 182, 4, 183,
	9, 183, 4, 184, 9, 184, 4, 185, 9, 185, 4, 186, 9, 186, 4, 187, 9, 187,
	4, 188, 9, 188, 4, 189, 9, 189, 4, 190, 9, 190, 4, 191, 9, 191, 4, 192,
	9, 192, 4, 193, 9, 193, 4, 194, 9, 194, 4, 195, 9, 195, 4, 196, 9, 196,
	4, 197, 9, 197, 4, 198, 9, 198, 4, 199, 9, 199, 4, 200, 9, 200, 4, 201,
	9, 201, 4, 202, 9, 202, 4, 203, 9, 203, 4, 204, 9, 204, 4, 205, 9, 205,
	4, 206, 9, 206, 4, 207, 9, 207, 4, 208, 9, 208, 4, 209, 9, 209, 4, 210,
	9, 210, 4, 211, 9, 211, 4, 212, 9, 212, 4, 213, 9, 213, 4, 214, 9, 214,
	4, 215, 9, 215, 4, 216, 9, 216, 4, 217, 9, 217, 4, 218, 9, 218, 4, 219,
	9, 219, 4, 220, 9, 220, 4, 221, 9, 221, 4, 222, 9, 222, 4, 223, 9, 223,
	4, 224, 9, 224, 4, 225, 9, 225, 4, 226, 9, 226, 4, 227, 9, 227, 4, 228,
	9, 228, 4, 229, 9, 229, 4, 230, 9, 230, 4, 231, 9, 231, 4, 232, 9, 232,
	4, 233, 9, 233, 4, 234, 9, 234, 4, 235, 9, 235, 4, 236, 9, 236, 4, 237,
	9, 237, 3, 2, 3, 2, 3, 3, 7, 3, 478, 10, 3, 12, 3, 14, 3, 481, 11, 3, 3,
	3, 3, 3, 7, 3, 485, 10, 3, 12, 3, 14, 3, 488, 11, 3, 3, 3, 5, 3, 491, 10,
	3, 3, 4, 3, 4, 5, 4, 495, 10, 4, 3, 5, 3, 5, 3, 6, 3, 6, 3, 7, 3, 7, 3,
	7, 5, 7, 504, 10, 7, 3, 8, 3, 8, 5, 8, 508, 10, 8, 3, 8, 3, 8, 7, 8, 512,
	10, 8, 12, 8, 14, 8, 515, 11, 8, 3, 9, 7, 9, 518, 10, 9, 12, 9, 14, 9,
	521, 11, 9, 3, 9, 3, 9, 5, 9, 525, 10, 9, 3, 9, 3, 9, 3, 9, 7, 9, 530,
	10, 9, 12, 9, 14, 9, 533, 11, 9, 3, 9, 3, 9, 5, 9, 537, 10, 9, 5, 9, 539,
	10, 9, 3, 10, 3, 10, 7, 10, 543, 10, 10, 12, 10, 14, 10, 546, 11, 10, 3,
	10, 3, 10, 5, 10, 550, 10, 10, 3, 11, 7, 11, 553, 10, 11, 12, 11, 14, 11,
	556, 11, 11, 3, 11, 3, 11, 5, 11, 560, 10, 11, 3, 12, 3, 12, 3, 13, 3,
	13, 3, 14, 3, 14, 3, 15, 7, 15, 569, 10, 15, 12, 15, 14, 15, 572, 11, 15,
	3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3,
	16, 5, 16, 585, 10, 16, 3, 17, 7, 17, 588, 10, 17, 12, 17, 14, 17, 591,
	11, 17, 3, 17, 3, 17, 3, 17, 7, 17, 596, 10, 17, 12, 17, 14, 17, 599, 11,
	17, 3, 17, 3, 17, 7, 17, 603, 10, 17, 12, 17, 14, 17, 606, 11, 17, 3, 18,
	7, 18, 609, 10, 18, 12, 18, 14, 18, 612, 11, 18, 3, 18, 3, 18, 5, 18, 616,
	10, 18, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 7, 20, 625, 10,
	20, 12, 20, 14, 20, 628, 11, 20, 5, 20, 630, 10, 20, 3, 21, 3, 21, 3, 21,
	3, 22, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 7, 23, 642, 10, 23, 12,
	23, 14, 23, 645, 11, 23, 3, 24, 3, 24, 5, 24, 649, 10, 24, 3, 25, 7, 25,
	652, 10, 25, 12, 25, 14, 25, 655, 11, 25, 3, 25, 3, 25, 5, 25, 659, 10,
	25, 3, 26, 3, 26, 3, 26, 3, 26, 5, 26, 665, 10, 26, 3, 27, 3, 27, 3, 27,
	3, 27, 3, 27, 3, 27, 7, 27, 673, 10, 27, 12, 27, 14, 27, 676, 11, 27, 3,
	28, 3, 28, 3, 28, 3, 28, 3, 28, 5, 28, 683, 10, 28, 3, 29, 3, 29, 3, 29,
	3, 29, 3, 29, 3, 29, 7, 29, 691, 10, 29, 12, 29, 14, 29, 694, 11, 29, 3,
	30, 3, 30, 3, 30, 3, 30, 3, 30, 5, 30, 701, 10, 30, 3, 31, 3, 31, 3, 32,
	3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 7, 32, 711, 10, 32, 12, 32, 14, 32,
	714, 11, 32, 3, 33, 5, 33, 717, 10, 33, 3, 33, 7, 33, 720, 10, 33, 12,
	33, 14, 33, 723, 11, 33, 3, 33, 7, 33, 726, 10, 33, 12, 33, 14, 33, 729,
	11, 33, 3, 33, 3, 33, 3, 34, 7, 34, 734, 10, 34, 12, 34, 14, 34, 737, 11,
	34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 36, 3, 36, 3, 36, 3, 36,
	5, 36, 749, 10, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3,
	38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 40,
	3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 41, 3, 41, 3, 41, 5, 41, 778,
	10, 41, 3, 42, 3, 42, 5, 42, 782, 10, 42, 3, 43, 7, 43, 785, 10, 43, 12,
	43, 14, 43, 788, 11, 43, 3, 43, 3, 43, 3, 43, 5, 43, 793, 10, 43, 3, 43,
	5, 43, 796, 10, 43, 3, 43, 5, 43, 799, 10, 43, 3, 43, 3, 43, 3, 44, 3,
	44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 5, 44, 811, 10, 44, 3, 45,
	3, 45, 3, 45, 3, 45, 3, 46, 3, 46, 3, 46, 7, 46, 820, 10, 46, 12, 46, 14,
	46, 823, 11, 46, 3, 47, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 3, 49, 3, 49,
	3, 49, 7, 49, 834, 10, 49, 12, 49, 14, 49, 837, 11, 49, 3, 50, 3, 50, 7,
	50, 841, 10, 50, 12, 50, 14, 50, 844, 11, 50, 3, 50, 3, 50, 3, 51, 3, 51,
	3, 51, 3, 51, 5, 51, 852, 10, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 5,
	52, 859, 10, 52, 3, 53, 7, 53, 862, 10, 53, 12, 53, 14, 53, 865, 11, 53,
	3, 53, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3,
	54, 3, 54, 5, 54, 879, 10, 54, 3, 55, 3, 55, 3, 55, 7, 55, 884, 10, 55,
	12, 55, 14, 55, 887, 11, 55, 3, 56, 3, 56, 3, 56, 5, 56, 892, 10, 56, 3,
	57, 3, 57, 5, 57, 896, 10, 57, 3, 58, 3, 58, 5, 58, 900, 10, 58, 3, 59,
	3, 59, 5, 59, 904, 10, 59, 3, 60, 3, 60, 5, 60, 908, 10, 60, 3, 61, 3,
	61, 3, 61, 5, 61, 913, 10, 61, 3, 62, 3, 62, 5, 62, 917, 10, 62, 3, 62,
	3, 62, 7, 62, 921, 10, 62, 12, 62, 14, 62, 924, 11, 62, 3, 63, 3, 63, 5,
	63, 928, 10, 63, 3, 63, 3, 63, 3, 63, 7, 63, 933, 10, 63, 12, 63, 14, 63,
	936, 11, 63, 3, 63, 3, 63, 5, 63, 940, 10, 63, 5, 63, 942, 10, 63, 3, 64,
	3, 64, 7, 64, 946, 10, 64, 12, 64, 14, 64, 949, 11, 64, 3, 64, 3, 64, 5,
	64, 953, 10, 64, 3, 65, 3, 65, 5, 65, 957, 10, 65, 3, 66, 3, 66, 3, 67,
	3, 67, 3, 68, 3, 68, 3, 69, 3, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3,
	70, 3, 70, 3, 70, 3, 70, 5, 70, 976, 10, 70, 3, 71, 7, 71, 979, 10, 71,
	12, 71, 14, 71, 982, 11, 71, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 72,
	3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 5, 72, 997, 10, 72, 3,
	73, 3, 73, 3, 73, 5, 73, 1002, 10, 73, 3, 73, 3, 73, 7, 73, 1006, 10, 73,
	12, 73, 14, 73, 1009, 11, 73, 3, 73, 3, 73, 3, 73, 5, 73, 1014, 10, 73,
	5, 73, 1016, 10, 73, 3, 74, 3, 74, 5, 74, 1020, 10, 74, 3, 75, 3, 75, 3,
	75, 5, 75, 1025, 10, 75, 3, 75, 3, 75, 5, 75, 1029, 10, 75, 3, 76, 3, 76,
	3, 76, 3, 76, 3, 76, 3, 76, 5, 76, 1037, 10, 76, 3, 77, 3, 77, 3, 77, 7,
	77, 1042, 10, 77, 12, 77, 14, 77, 1045, 11, 77, 3, 77, 3, 77, 3, 77, 7,
	77, 1050, 10, 77, 12, 77, 14, 77, 1053, 11, 77, 5, 77, 1055, 10, 77, 3,
	78, 7, 78, 1058, 10, 78, 12, 78, 14, 78, 1061, 11, 78, 3, 78, 3, 78, 3,
	78, 3, 79, 3, 79, 5, 79, 1068, 10, 79, 3, 80, 7, 80, 1071, 10, 80, 12,
	80, 14, 80, 1074, 11, 80, 3, 80, 3, 80, 7, 80, 1078, 10, 80, 12, 80, 14,
	80, 1081, 11, 80, 3, 80, 3, 80, 3, 80, 3, 80, 5, 80, 1087, 10, 80, 3, 81,
	7, 81, 1090, 10, 81, 12, 81, 14, 81, 1093, 11, 81, 3, 81, 3, 81, 3, 81,
	5, 81, 1098, 10, 81, 3, 81, 3, 81, 3, 82, 3, 82, 3, 82, 3, 83, 3, 83, 3,
	83, 7, 83, 1108, 10, 83, 12, 83, 14, 83, 1111, 11, 83, 3, 84, 3, 84, 5,
	84, 1115, 10, 84, 3, 85, 3, 85, 5, 85, 1119, 10, 85, 3, 86, 3, 86, 3, 87,
	3, 87, 3, 87, 3, 88, 7, 88, 1127, 10, 88, 12, 88, 14, 88, 1130, 11, 88,
	3, 88, 3, 88, 5, 88, 1134, 10, 88, 3, 88, 3, 88, 3, 89, 3, 89, 3, 89, 3,
	89, 5, 89, 1142, 10, 89, 3, 90, 5, 90, 1145, 10, 90, 3, 90, 3, 90, 3, 90,
	5, 90, 1150, 10, 90, 3, 90, 3, 90, 3, 91, 3, 91, 3, 92, 3, 92, 5, 92, 1158,
	10, 92, 3, 92, 5, 92, 1161, 10, 92, 3, 92, 3, 92, 3, 93, 5, 93, 1166, 10,
	93, 3, 93, 3, 93, 3, 93, 5, 93, 1171, 10, 93, 3, 93, 3, 93, 3, 93, 5, 93,
	1176, 10, 93, 3, 93, 3, 93, 3, 93, 5, 93, 1181, 10, 93, 3, 93, 3, 93, 3,
	93, 3, 93, 3, 93, 5, 93, 1188, 10, 93, 3, 93, 3, 93, 3, 93, 5, 93, 1193,
	10, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 5, 93, 1201, 10, 93,
	3, 93, 3, 93, 3, 93, 5, 93, 1206, 10, 93, 3, 93, 3, 93, 3, 93, 5, 93, 1211,
	10, 93, 3, 94, 7, 94, 1214, 10, 94, 12, 94, 14, 94, 1217, 11, 94, 3, 94,
	3, 94, 3, 94, 5, 94, 1222, 10, 94, 3, 94, 3, 94, 3, 95, 3, 95, 5, 95, 1228,
	10, 95, 3, 95, 5, 95, 1231, 10, 95, 3, 95, 5, 95, 1234, 10, 95, 3, 95,
	3, 95, 3, 96, 3, 96, 3, 96, 7, 96, 1241, 10, 96, 12, 96, 14, 96, 1244,
	11, 96, 3, 97, 7, 97, 1247, 10, 97, 12, 97, 14, 97, 1250, 11, 97, 3, 97,
	3, 97, 3, 97, 5, 97, 1255, 10, 97, 3, 97, 5, 97, 1258, 10, 97, 3, 97, 5,
	97, 1261, 10, 97, 3, 98, 3, 98, 3, 99, 3, 99, 7, 99, 1267, 10, 99, 12,
	99, 14, 99, 1270, 11, 99, 3, 100, 3, 100, 5, 100, 1274, 10, 100, 3, 101,
	7, 101, 1277, 10, 101, 12, 101, 14, 101, 1280, 11, 101, 3, 101, 3, 101,
	3, 101, 5, 101, 1285, 10, 101, 3, 101, 5, 101, 1288, 10, 101, 3, 101, 3,
	101, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 5, 102, 1299,
	10, 102, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 7, 104, 1306, 10, 104,
	12, 104, 14, 104, 1309, 11, 104, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105,
	3, 105, 3, 105, 5, 105, 1318, 10, 105, 3, 106, 7, 106, 1321, 10, 106, 12,
	106, 14, 106, 1324, 11, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 107, 3,
	107, 3, 107, 3, 107, 5, 107, 1334, 10, 107, 3, 108, 7, 108, 1337, 10, 108,
	12, 108, 14, 108, 1340, 11, 108, 3, 108, 3, 108, 3, 108, 3, 109, 3, 109,
	3, 109, 3, 109, 3, 109, 3, 109, 5, 109, 1351, 10, 109, 3, 110, 7, 110,
	1354, 10, 110, 12, 110, 14, 110, 1357, 11, 110, 3, 110, 3, 110, 3, 110,
	3, 110, 3, 110, 3, 111, 3, 111, 7, 111, 1366, 10, 111, 12, 111, 14, 111,
	1369, 11, 111, 3, 111, 3, 111, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112,
	5, 112, 1378, 10, 112, 3, 113, 7, 113, 1381, 10, 113, 12, 113, 14, 113,
	1384, 11, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 5, 113, 1391, 10,
	113, 3, 113, 5, 113, 1394, 10, 113, 3, 113, 3, 113, 3, 114, 3, 114, 3,
	114, 5, 114, 1401, 10, 114, 3, 115, 3, 115, 3, 115, 3, 116, 3, 116, 3,
	116, 5, 116, 1409, 10, 116, 3, 117, 3, 117, 3, 117, 3, 117, 5, 117, 1415,
	10, 117, 3, 117, 3, 117, 3, 118, 3, 118, 3, 118, 7, 118, 1422, 10, 118,
	12, 118, 14, 118, 1425, 11, 118, 3, 119, 3, 119, 3, 119, 3, 119, 3, 120,
	3, 120, 3, 120, 5, 120, 1434, 10, 120, 3, 121, 3, 121, 5, 121, 1438, 10,
	121, 3, 121, 5, 121, 1441, 10, 121, 3, 121, 3, 121, 3, 122, 3, 122, 3,
	122, 7, 122, 1448, 10, 122, 12, 122, 14, 122, 1451, 11, 122, 3, 123, 3,
	123, 3, 123, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 125, 3,
	125, 5, 125, 1464, 10, 125, 3, 125, 5, 125, 1467, 10, 125, 3, 125, 3, 125,
	3, 126, 3, 126, 3, 126, 7, 126, 1474, 10, 126, 12, 126, 14, 126, 1477,
	11, 126, 3, 127, 3, 127, 5, 127, 1481, 10, 127, 3, 127, 3, 127, 3, 128,
	6, 128, 1486, 10, 128, 13, 128, 14, 128, 1487, 3, 129, 3, 129, 3, 129,
	5, 129, 1493, 10, 129, 3, 130, 3, 130, 3, 130, 3, 131, 7, 131, 1499, 10,
	131, 12, 131, 14, 131, 1502, 11, 131, 3, 131, 3, 131, 3, 131, 3, 132, 3,
	132, 3, 132, 3, 132, 3, 132, 3, 132, 5, 132, 1513, 10, 132, 3, 133, 3,
	133, 3, 133, 3, 133, 3, 133, 5, 133, 1520, 10, 133, 3, 134, 3, 134, 3,
	134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3,
	134, 5, 134, 1534, 10, 134, 3, 135, 3, 135, 3, 136, 3, 136, 3, 136, 3,
	136, 3, 137, 3, 137, 3, 137, 3, 137, 3, 138, 3, 138, 3, 138, 3, 139, 3,
	139, 3, 139, 3, 139, 3, 139, 3, 139, 3, 139, 5, 139, 1556, 10, 139, 3,
	140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 141, 3, 141, 3, 141, 3,
	141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 142, 3, 142, 3, 142, 3, 142, 3,
	142, 3, 142, 3, 142, 3, 142, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3,
	143, 3, 143, 3, 143, 3, 143, 3, 143, 5, 143, 1590, 10, 143, 3, 144, 3,
	144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 145, 3, 145, 7, 145, 1600, 10,
	145, 12, 145, 14, 145, 1603, 11, 145, 3, 145, 7, 145, 1606, 10, 145, 12,
	145, 14, 145, 1609, 11, 145, 3, 145, 3, 145, 3, 146, 3, 146, 3, 146, 3,
	147, 3, 147, 7, 147, 1618, 10, 147, 12, 147, 14, 147, 1621, 11, 147, 3,
	148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3,
	148, 5, 148, 1633, 10, 148, 3, 149, 3, 149, 3, 150, 3, 150, 3, 150, 3,
	150, 3, 150, 3, 150, 3, 151, 3, 151, 3, 151, 3, 151, 3, 151, 3, 151, 3,
	152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 152, 3, 153, 3,
	153, 5, 153, 1659, 10, 153, 3, 154, 3, 154, 5, 154, 1663, 10, 154, 3, 155,
	3, 155, 3, 155, 5, 155, 1668, 10, 155, 3, 155, 3, 155, 5, 155, 1672, 10,
	155, 3, 155, 3, 155, 5, 155, 1676, 10, 155, 3, 155, 3, 155, 3, 155, 3,
	156, 3, 156, 3, 156, 5, 156, 1684, 10, 156, 3, 156, 3, 156, 5, 156, 1688,
	10, 156, 3, 156, 3, 156, 5, 156, 1692, 10, 156, 3, 156, 3, 156, 3, 156,
	3, 157, 3, 157, 5, 157, 1699, 10, 157, 3, 158, 3, 158, 3, 159, 3, 159,
	3, 159, 7, 159, 1706, 10, 159, 12, 159, 14, 159, 1709, 11, 159, 3, 160,
	3, 160, 3, 160, 7, 160, 1714, 10, 160, 12, 160, 14, 160, 1717, 11, 160,
	3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 161, 3, 161,
	3, 161, 7, 161, 1729, 10, 161, 12, 161, 14, 161, 1732, 11, 161, 3, 161,
	3, 161, 3, 161, 3, 161, 3, 161, 3, 161, 3, 161, 3, 162, 3, 162, 5, 162,
	1743, 10, 162, 3, 162, 3, 162, 3, 163, 3, 163, 5, 163, 1749, 10, 163, 3,
	163, 3, 163, 3, 164, 3, 164, 5, 164, 1755, 10, 164, 3, 164, 3, 164, 3,
	165, 3, 165, 3, 165, 3, 165, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3,
	166, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 5, 167, 1776,
	10, 167, 3, 167, 3, 167, 3, 167, 5, 167, 1781, 10, 167, 3, 168, 3, 168,
	7, 168, 1785, 10, 168, 12, 168, 14, 168, 1788, 11, 168, 3, 169, 3, 169,
	3, 169, 3, 169, 3, 169, 3, 169, 3, 170, 7, 170, 1797, 10, 170, 12, 170,
	14, 170, 1800, 11, 170, 3, 170, 3, 170, 3, 170, 3, 171, 3, 171, 3, 171,
	7, 171, 1808, 10, 171, 12, 171, 14, 171, 1811, 11, 171, 3, 172, 3, 172,
	3, 172, 3, 173, 3, 173, 3, 173, 3, 173, 5, 173, 1820, 10, 173, 3, 173,
	5, 173, 1823, 10, 173, 3, 174, 3, 174, 3, 174, 5, 174, 1828, 10, 174, 3,
	174, 3, 174, 3, 175, 3, 175, 3, 175, 7, 175, 1835, 10, 175, 12, 175, 14,
	175, 1838, 11, 175, 3, 176, 7, 176, 1841, 10, 176, 12, 176, 14, 176, 1844,
	11, 176, 3, 176, 3, 176, 3, 176, 3, 176, 3, 176, 3, 177, 3, 177, 5, 177,
	1853, 10, 177, 3, 177, 7, 177, 1856, 10, 177, 12, 177, 14, 177, 1859, 11,
	177, 3, 178, 3, 178, 3, 178, 3, 178, 7, 178, 1865, 10, 178, 12, 178, 14,
	178, 1868, 11, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3,
	178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3,
	178, 3, 178, 3, 178, 3, 178, 3, 178, 5, 178, 1890, 10, 178, 3, 179, 3,
	179, 3, 180, 3, 180, 3, 180, 3, 180, 7, 180, 1898, 10, 180, 12, 180, 14,
	180, 1901, 11, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3,
	180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3,
	180, 3, 180, 3, 180, 3, 180, 5, 180, 1922, 10, 180, 3, 181, 3, 181, 3,
	181, 3, 181, 3, 181, 5, 181, 1929, 10, 181, 3, 182, 3, 182, 3, 183, 3,
	183, 3, 183, 3, 183, 5, 183, 1937, 10, 183, 3, 184, 3, 184, 3, 184, 3,
	184, 7, 184, 1943, 10, 184, 12, 184, 14, 184, 1946, 11, 184, 3, 184, 3,
	184, 3, 184, 3, 184, 3, 184, 3, 184, 7, 184, 1954, 10, 184, 12, 184, 14,
	184, 1957, 11, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3,
	184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3,
	184, 3, 184, 3, 184, 3, 184, 3, 184, 5, 184, 1979, 10, 184, 3, 185, 3,
	185, 3, 186, 3, 186, 3, 186, 3, 186, 7, 186, 1987, 10, 186, 12, 186, 14,
	186, 1990, 11, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 7,
	186, 1998, 10, 186, 12, 186, 14, 186, 2001, 11, 186, 3, 186, 3, 186, 3,
	186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3,
	186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 5, 186, 2022,
	10, 186, 3, 187, 3, 187, 5, 187, 2026, 10, 187, 3, 187, 7, 187, 2029, 10,
	187, 12, 187, 14, 187, 2032, 11, 187, 3, 187, 3, 187, 3, 187, 7, 187, 2037,
	10, 187, 12, 187, 14, 187, 2040, 11, 187, 3, 187, 7, 187, 2043, 10, 187,
	12, 187, 14, 187, 2046, 11, 187, 3, 187, 5, 187, 2049, 10, 187, 3, 187,
	3, 187, 5, 187, 2053, 10, 187, 3, 187, 3, 187, 5, 187, 2057, 10, 187, 3,
	187, 3, 187, 3, 187, 3, 187, 5, 187, 2063, 10, 187, 3, 187, 7, 187, 2066,
	10, 187, 12, 187, 14, 187, 2069, 11, 187, 3, 187, 3, 187, 5, 187, 2073,
	10, 187, 3, 187, 3, 187, 5, 187, 2077, 10, 187, 3, 187, 3, 187, 5, 187,
	2081, 10, 187, 3, 187, 3, 187, 3, 187, 3, 187, 5, 187, 2087, 10, 187, 3,
	187, 7, 187, 2090, 10, 187, 12, 187, 14, 187, 2093, 11, 187, 3, 187, 3,
	187, 5, 187, 2097, 10, 187, 3, 187, 3, 187, 5, 187, 2101, 10, 187, 3, 187,
	3, 187, 5, 187, 2105, 10, 187, 5, 187, 2107, 10, 187, 3, 188, 3, 188, 3,
	188, 5, 188, 2112, 10, 188, 3, 188, 7, 188, 2115, 10, 188, 12, 188, 14,
	188, 2118, 11, 188, 3, 188, 3, 188, 5, 188, 2122, 10, 188, 3, 188, 3, 188,
	5, 188, 2126, 10, 188, 3, 188, 3, 188, 5, 188, 2130, 10, 188, 3, 189, 3,
	189, 5, 189, 2134, 10, 189, 3, 189, 7, 189, 2137, 10, 189, 12, 189, 14,
	189, 2140, 11, 189, 3, 189, 3, 189, 3, 189, 7, 189, 2145, 10, 189, 12,
	189, 14, 189, 2148, 11, 189, 3, 189, 7, 189, 2151, 10, 189, 12, 189, 14,
	189, 2154, 11, 189, 3, 189, 5, 189, 2157, 10, 189, 3, 189, 3, 189, 5, 189,
	2161, 10, 189, 3, 189, 3, 189, 5, 189, 2165, 10, 189, 3, 189, 3, 189, 3,
	189, 3, 189, 5, 189, 2171, 10, 189, 3, 189, 7, 189, 2174, 10, 189, 12,
	189, 14, 189, 2177, 11, 189, 3, 189, 3, 189, 5, 189, 2181, 10, 189, 3,
	189, 3, 189, 5, 189, 2185, 10, 189, 3, 189, 3, 189, 5, 189, 2189, 10, 189,
	5, 189, 2191, 10, 189, 3, 190, 3, 190, 3, 190, 5, 190, 2196, 10, 190, 3,
	191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3,
	191, 3, 191, 3, 191, 3, 191, 5, 191, 2211, 10, 191, 3, 192, 3, 192, 3,
	192, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3,
	193, 5, 193, 2225, 10, 193, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3,
	194, 3, 194, 3, 194, 3, 194, 3, 194, 5, 194, 2237, 10, 194, 3, 194, 3,
	194, 3, 194, 3, 194, 3, 194, 7, 194, 2244, 10, 194, 12, 194, 14, 194, 2247,
	11, 194, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195,
	3, 195, 3, 195, 7, 195, 2259, 10, 195, 12, 195, 14, 195, 2262, 11, 195,
	3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196,
	3, 196, 5, 196, 2274, 10, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196,
	7, 196, 2281, 10, 196, 12, 196, 14, 196, 2284, 11, 196, 3, 197, 3, 197,
	3, 197, 5, 197, 2289, 10, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197,
	5, 197, 2296, 10, 197, 3, 197, 3, 197, 3, 197, 5, 197, 2301, 10, 197, 3,
	197, 3, 197, 3, 197, 3, 197, 3, 197, 5, 197, 2308, 10, 197, 3, 197, 3,
	197, 3, 197, 5, 197, 2313, 10, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3,
	197, 5, 197, 2320, 10, 197, 3, 197, 3, 197, 3, 197, 5, 197, 2325, 10, 197,
	3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 5, 197, 2332, 10, 197, 3, 197,
	3, 197, 3, 197, 5, 197, 2337, 10, 197, 3, 197, 3, 197, 3, 197, 3, 197,
	3, 197, 3, 197, 5, 197, 2345, 10, 197, 3, 197, 3, 197, 3, 197, 5, 197,
	2350, 10, 197, 3, 197, 3, 197, 5, 197, 2354, 10, 197, 3, 198, 3, 198, 5,
	198, 2358, 10, 198, 3, 198, 3, 198, 3, 198, 5, 198, 2363, 10, 198, 3, 198,
	3, 198, 3, 199, 3, 199, 3, 199, 5, 199, 2370, 10, 199, 3, 199, 3, 199,
	3, 199, 3, 199, 3, 199, 5, 199, 2377, 10, 199, 3, 199, 3, 199, 3, 199,
	5, 199, 2382, 10, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 5, 199,
	2389, 10, 199, 3, 199, 3, 199, 3, 199, 5, 199, 2394, 10, 199, 3, 199, 3,
	199, 3, 199, 3, 199, 3, 199, 5, 199, 2401, 10, 199, 3, 199, 3, 199, 3,
	199, 5, 199, 2406, 10, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3,
	199, 5, 199, 2414, 10, 199, 3, 199, 3, 199, 3, 199, 5, 199, 2419, 10, 199,
	3, 199, 3, 199, 5, 199, 2423, 10, 199, 3, 200, 3, 200, 3, 200, 7, 200,
	2428, 10, 200, 12, 200, 14, 200, 2431, 11, 200, 3, 201, 3, 201, 3, 201,
	5, 201, 2436, 10, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 5, 201,
	2443, 10, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 5, 201, 2450, 10,
	201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 5, 201, 2457, 10, 201, 3,
	201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 5, 201, 2465, 10, 201, 3,
	201, 3, 201, 3, 201, 3, 201, 3, 201, 5, 201, 2472, 10, 201, 3, 201, 3,
	201, 3, 201, 3, 201, 3, 201, 3, 201, 5, 201, 2480, 10, 201, 3, 202, 3,
	202, 5, 202, 2484, 10, 202, 3, 202, 3, 202, 3, 203, 3, 203, 3, 203, 5,
	203, 2491, 10, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 5, 203, 2498,
	10, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 5, 203, 2505, 10, 203,
	3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 5, 203, 2513, 10, 203,
	3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 5, 203, 2520, 10, 203, 3, 203,
	3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 5, 203, 2528, 10, 203, 3, 204,
	3, 204, 3, 204, 3, 204, 5, 204, 2534, 10, 204, 3, 204, 3, 204, 3, 204,
	3, 204, 5, 204, 2540, 10, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204,
	3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 5, 204, 2552, 10, 204, 3, 205,
	3, 205, 7, 205, 2556, 10, 205, 12, 205, 14, 205, 2559, 11, 205, 3, 206,
	7, 206, 2562, 10, 206, 12, 206, 14, 206, 2565, 11, 206, 3, 206, 3, 206,
	3, 206, 3, 206, 3, 207, 3, 207, 3, 208, 3, 208, 5, 208, 2575, 10, 208,
	3, 209, 3, 209, 3, 209, 3, 209, 3, 210, 3, 210, 3, 210, 5, 210, 2584, 10,
	210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 5, 210, 2591, 10, 210, 3,
	211, 3, 211, 3, 211, 7, 211, 2596, 10, 211, 12, 211, 14, 211, 2599, 11,
	211, 3, 212, 3, 212, 5, 212, 2603, 10, 212, 3, 213, 3, 213, 5, 213, 2607,
	10, 213, 3, 214, 3, 214, 3, 214, 3, 214, 3, 215, 3, 215, 3, 215, 5, 215,
	2616, 10, 215, 3, 216, 3, 216, 3, 217, 3, 217, 3, 217, 3, 217, 3, 217,
	3, 217, 3, 217, 5, 217, 2627, 10, 217, 3, 218, 3, 218, 3, 218, 3, 218,
	3, 218, 3, 218, 7, 218, 2635, 10, 218, 12, 218, 14, 218, 2638, 11, 218,
	3, 219, 3, 219, 3, 219, 3, 219, 3, 219, 3, 219, 7, 219, 2646, 10, 219,
	12, 219, 14, 219, 2649, 11, 219, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220,
	3, 220, 7, 220, 2657, 10, 220, 12, 220, 14, 220, 2660, 11, 220, 3, 221,
	3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 7, 221, 2668, 10, 221, 12, 221,
	14, 221, 2671, 11, 221, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222,
	7, 222, 2679, 10, 222, 12, 222, 14, 222, 2682, 11, 222, 3, 223, 3, 223,
	3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 7, 223, 2693, 10,
	223, 12, 223, 14, 223, 2696, 11, 223, 3, 224, 3, 224, 3, 224, 3, 224, 3,
	224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3,
	224, 3, 224, 3, 224, 3, 224, 3, 224, 7, 224, 2716, 10, 224, 12, 224, 14,
	224, 2719, 11, 224, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3,
	225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3,
	225, 7, 225, 2737, 10, 225, 12, 225, 14, 225, 2740, 11, 225, 3, 226, 3,
	226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 7, 226, 2751,
	10, 226, 12, 226, 14, 226, 2754, 11, 226, 3, 227, 3, 227, 3, 227, 3, 227,
	3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 7, 227,
	2768, 10, 227, 12, 227, 14, 227, 2771, 11, 227, 3, 228, 3, 228, 3, 228,
	3, 228, 3, 228, 3, 228, 3, 228, 5, 228, 2780, 10, 228, 3, 229, 3, 229,
	3, 229, 3, 230, 3, 230, 3, 230, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231,
	3, 231, 5, 231, 2794, 10, 231, 3, 232, 3, 232, 5, 232, 2798, 10, 232, 3,
	232, 3, 232, 7, 232, 2802, 10, 232, 12, 232, 14, 232, 2805, 11, 232, 3,
	233, 3, 233, 3, 233, 3, 234, 3, 234, 3, 235, 3, 235, 3, 235, 3, 236, 3,
	236, 3, 237, 3, 237, 3, 237, 3, 237, 3, 237, 3, 237, 3, 237, 3, 237, 7,
	237, 2825, 10, 237, 12, 237, 14, 237, 2828, 11, 237, 3, 237, 3, 237, 3,
	237, 3, 237, 3, 237, 3, 237, 7, 237, 2836, 10, 237, 12, 237, 14, 237, 2839,
	11, 237, 3, 237, 3, 237, 3, 237, 5, 237, 2844, 10, 237, 3, 237, 2, 15,
	52, 56, 62, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 238, 2, 4,
	6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42,
	44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78,
	80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112,
	114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142,
	144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172,
	174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202,
	204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232,
	234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262,
	264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292,
	294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322,
	324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352,
	354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382,
	384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412,
	414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442,
	444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472,
	2, 6, 3, 2, 53, 58, 7, 2, 7, 7, 10, 10, 29, 29, 31, 31, 39, 39, 4, 2, 16,
	16, 22, 22, 4, 2, 68, 68, 93, 103, 2, 3087, 2, 474, 3, 2, 2, 2, 4, 490,
	3, 2, 2, 2, 6, 494, 3, 2, 2, 2, 8, 496, 3, 2, 2, 2, 10, 498, 3, 2, 2, 2,
	12, 503, 3, 2, 2, 2, 14, 507, 3, 2, 2, 2, 16, 538, 3, 2, 2, 2, 18, 540,
	3, 2, 2, 2, 20, 554, 3, 2, 2, 2, 22, 561, 3, 2, 2, 2, 24, 563, 3, 2, 2,
	2, 26, 565, 3, 2, 2, 2, 28, 570, 3, 2, 2, 2, 30, 584, 3, 2, 2, 2, 32, 589,
	3, 2, 2, 2, 34, 610, 3, 2, 2, 2, 36, 617, 3, 2, 2, 2, 38, 629, 3, 2, 2,
	2, 40, 631, 3, 2, 2, 2, 42, 634, 3, 2, 2, 2, 44, 638, 3, 2, 2, 2, 46, 648,
	3, 2, 2, 2, 48, 653, 3, 2, 2, 2, 50, 664, 3, 2, 2, 2, 52, 666, 3, 2, 2,
	2, 54, 682, 3, 2, 2, 2, 56, 684, 3, 2, 2, 2, 58, 700, 3, 2, 2, 2, 60, 702,
	3, 2, 2, 2, 62, 704, 3, 2, 2, 2, 64, 716, 3, 2, 2, 2, 66, 735, 3, 2, 2,
	2, 68, 742, 3, 2, 2, 2, 70, 748, 3, 2, 2, 2, 72, 750, 3, 2, 2, 2, 74, 754,
	3, 2, 2, 2, 76, 760, 3, 2, 2, 2, 78, 767, 3, 2, 2, 2, 80, 777, 3, 2, 2,
	2, 82, 781, 3, 2, 2, 2, 84, 786, 3, 2, 2, 2, 86, 810, 3, 2, 2, 2, 88, 812,
	3, 2, 2, 2, 90, 816, 3, 2, 2, 2, 92, 824, 3, 2, 2, 2, 94, 827, 3, 2, 2,
	2, 96, 830, 3, 2, 2, 2, 98, 838, 3, 2, 2, 2, 100, 851, 3, 2, 2, 2, 102,
	858, 3, 2, 2, 2, 104, 863, 3, 2, 2, 2, 106, 878, 3, 2, 2, 2, 108, 880,
	3, 2, 2, 2, 110, 888, 3, 2, 2, 2, 112, 893, 3, 2, 2, 2, 114, 899, 3, 2,
	2, 2, 116, 903, 3, 2, 2, 2, 118, 907, 3, 2, 2, 2, 120, 912, 3, 2, 2, 2,
	122, 916, 3, 2, 2, 2, 124, 941, 3, 2, 2, 2, 126, 943, 3, 2, 2, 2, 128,
	954, 3, 2, 2, 2, 130, 958, 3, 2, 2, 2, 132, 960, 3, 2, 2, 2, 134, 962,
	3, 2, 2, 2, 136, 964, 3, 2, 2, 2, 138, 975, 3, 2, 2, 2, 140, 980, 3, 2,
	2, 2, 142, 996, 3, 2, 2, 2, 144, 1015, 3, 2, 2, 2, 146, 1019, 3, 2, 2,
	2, 148, 1021, 3, 2, 2, 2, 150, 1036, 3, 2, 2, 2, 152, 1054, 3, 2, 2, 2,
	154, 1059, 3, 2, 2, 2, 156, 1067, 3, 2, 2, 2, 158, 1086, 3, 2, 2, 2, 160,
	1091, 3, 2, 2, 2, 162, 1101, 3, 2, 2, 2, 164, 1104, 3, 2, 2, 2, 166, 1114,
	3, 2, 2, 2, 168, 1118, 3, 2, 2, 2, 170, 1120, 3, 2, 2, 2, 172, 1122, 3,
	2, 2, 2, 174, 1128, 3, 2, 2, 2, 176, 1141, 3, 2, 2, 2, 178, 1144, 3, 2,
	2, 2, 180, 1153, 3, 2, 2, 2, 182, 1155, 3, 2, 2, 2, 184, 1210, 3, 2, 2,
	2, 186, 1215, 3, 2, 2, 2, 188, 1225, 3, 2, 2, 2, 190, 1237, 3, 2, 2, 2,
	192, 1248, 3, 2, 2, 2, 194, 1262, 3, 2, 2, 2, 196, 1264, 3, 2, 2, 2, 198,
	1273, 3, 2, 2, 2, 200, 1278, 3, 2, 2, 2, 202, 1298, 3, 2, 2, 2, 204, 1300,
	3, 2, 2, 2, 206, 1303, 3, 2, 2, 2, 208, 1317, 3, 2, 2, 2, 210, 1322, 3,
	2, 2, 2, 212, 1333, 3, 2, 2, 2, 214, 1338, 3, 2, 2, 2, 216, 1350, 3, 2,
	2, 2, 218, 1355, 3, 2, 2, 2, 220, 1363, 3, 2, 2, 2, 222, 1377, 3, 2, 2,
	2, 224, 1382, 3, 2, 2, 2, 226, 1400, 3, 2, 2, 2, 228, 1402, 3, 2, 2, 2,
	230, 1408, 3, 2, 2, 2, 232, 1410, 3, 2, 2, 2, 234, 1418, 3, 2, 2, 2, 236,
	1426, 3, 2, 2, 2, 238, 1433, 3, 2, 2, 2, 240, 1435, 3, 2, 2, 2, 242, 1444,
	3, 2, 2, 2, 244, 1452, 3, 2, 2, 2, 246, 1455, 3, 2, 2, 2, 248, 1461, 3,
	2, 2, 2, 250, 1470, 3, 2, 2, 2, 252, 1478, 3, 2, 2, 2, 254, 1485, 3, 2,
	2, 2, 256, 1492, 3, 2, 2, 2, 258, 1494, 3, 2, 2, 2, 260, 1500, 3, 2, 2,
	2, 262, 1512, 3, 2, 2, 2, 264, 1519, 3, 2, 2, 2, 266, 1533, 3, 2, 2, 2,
	268, 1535, 3, 2, 2, 2, 270, 1537, 3, 2, 2, 2, 272, 1541, 3, 2, 2, 2, 274,
	1545, 3, 2, 2, 2, 276, 1555, 3, 2, 2, 2, 278, 1557, 3, 2, 2, 2, 280, 1563,
	3, 2, 2, 2, 282, 1571, 3, 2, 2, 2, 284, 1589, 3, 2, 2, 2, 286, 1591, 3,
	2, 2, 2, 288, 1597, 3, 2, 2, 2, 290, 1612, 3, 2, 2, 2, 292, 1615, 3, 2,
	2, 2, 294, 1632, 3, 2, 2, 2, 296, 1634, 3, 2, 2, 2, 298, 1636, 3, 2, 2,
	2, 300, 1642, 3, 2, 2, 2, 302, 1648, 3, 2, 2, 2, 304, 1658, 3, 2, 2, 2,
	306, 1662, 3, 2, 2, 2, 308, 1664, 3, 2, 2, 2, 310, 1680, 3, 2, 2, 2, 312,
	1698, 3, 2, 2, 2, 314, 1700, 3, 2, 2, 2, 316, 1702, 3, 2, 2, 2, 318, 1710,
	3, 2, 2, 2, 320, 1725, 3, 2, 2, 2, 322, 1740, 3, 2, 2, 2, 324, 1746, 3,
	2, 2, 2, 326, 1752, 3, 2, 2, 2, 328, 1758, 3, 2, 2, 2, 330, 1762, 3, 2,
	2, 2, 332, 1780, 3, 2, 2, 2, 334, 1782, 3, 2, 2, 2, 336, 1789, 3, 2, 2,
	2, 338, 1798, 3, 2, 2, 2, 340, 1804, 3, 2, 2, 2, 342, 1812, 3, 2, 2, 2,
	344, 1815, 3, 2, 2, 2, 346, 1824, 3, 2, 2, 2, 348, 1831, 3, 2, 2, 2, 350,
	1842, 3, 2, 2, 2, 352, 1852, 3, 2, 2, 2, 354, 1889, 3, 2, 2, 2, 356, 1891,
	3, 2, 2, 2, 358, 1921, 3, 2, 2, 2, 360, 1928, 3, 2, 2, 2, 362, 1930, 3,
	2, 2, 2, 364, 1936, 3, 2, 2, 2, 366, 1978, 3, 2, 2, 2, 368, 1980, 3, 2,
	2, 2, 370, 2021, 3, 2, 2, 2, 372, 2106, 3, 2, 2, 2, 374, 2108, 3, 2, 2,
	2, 376, 2190, 3, 2, 2, 2, 378, 2195, 3, 2, 2, 2, 380, 2210, 3, 2, 2, 2,
	382, 2212, 3, 2, 2, 2, 384, 2224, 3, 2, 2, 2, 386, 2236, 3, 2, 2, 2, 388,
	2248, 3, 2, 2, 2, 390, 2273, 3, 2, 2, 2, 392, 2353, 3, 2, 2, 2, 394, 2355,
	3, 2, 2, 2, 396, 2422, 3, 2, 2, 2, 398, 2424, 3, 2, 2, 2, 400, 2479, 3,
	2, 2, 2, 402, 2481, 3, 2, 2, 2, 404, 2527, 3, 2, 2, 2, 406, 2551, 3, 2,
	2, 2, 408, 2553, 3, 2, 2, 2, 410, 2563, 3, 2, 2, 2, 412, 2570, 3, 2, 2,
	2, 414, 2574, 3, 2, 2, 2, 416, 2576, 3, 2, 2, 2, 418, 2590, 3, 2, 2, 2,
	420, 2592, 3, 2, 2, 2, 422, 2602, 3, 2, 2, 2, 424, 2606, 3, 2, 2, 2, 426,
	2608, 3, 2, 2, 2, 428, 2615, 3, 2, 2, 2, 430, 2617, 3, 2, 2, 2, 432, 2626,
	3, 2, 2, 2, 434, 2628, 3, 2, 2, 2, 436, 2639, 3, 2, 2, 2, 438, 2650, 3,
	2, 2, 2, 440, 2661, 3, 2, 2, 2, 442, 2672, 3, 2, 2, 2, 444, 2683, 3, 2,
	2, 2, 446, 2697, 3, 2, 2, 2, 448, 2720, 3, 2, 2, 2, 450, 2741, 3, 2, 2,
	2, 452, 2755, 3, 2, 2, 2, 454, 2779, 3, 2, 2, 2, 456, 2781, 3, 2, 2, 2,
	458, 2784, 3, 2, 2, 2, 460, 2793, 3, 2, 2, 2, 462, 2797, 3, 2, 2, 2, 464,
	2806, 3, 2, 2, 2, 466, 2809, 3, 2, 2, 2, 468, 2811, 3, 2, 2, 2, 470, 2814,
	3, 2, 2, 2, 472, 2843, 3, 2, 2, 2, 474, 475, 9, 2, 2, 2, 475, 3, 3, 2,
	2, 2, 476, 478, 5, 230, 116, 2, 477, 476, 3, 2, 2, 2, 478, 481, 3, 2, 2,
	2, 479, 477, 3, 2, 2, 2, 479, 480, 3, 2, 2, 2, 480, 482, 3, 2, 2, 2, 481,
	479, 3, 2, 2, 2, 482, 491, 5, 6, 4, 2, 483, 485, 5, 230, 116, 2, 484, 483,
	3, 2, 2, 2, 485, 488, 3, 2, 2, 2, 486, 484, 3, 2, 2, 2, 486, 487, 3, 2,
	2, 2, 487, 489, 3, 2, 2, 2, 488, 486, 3, 2, 2, 2, 489, 491, 7, 5, 2, 2,
	490, 479, 3, 2, 2, 2, 490, 486, 3, 2, 2, 2, 491, 5, 3, 2, 2, 2, 492, 495,
	5, 8, 5, 2, 493, 495, 5, 10, 6, 2, 494, 492, 3, 2, 2, 2, 494, 493, 3, 2,
	2, 2, 495, 7, 3, 2, 2, 2, 496, 497, 9, 3, 2, 2, 497, 9, 3, 2, 2, 2, 498,
	499, 9, 4, 2, 2, 499, 11, 3, 2, 2, 2, 500, 504, 5, 14, 8, 2, 501, 504,
	5, 28, 15, 2, 502, 504, 5, 30, 16, 2, 503, 500, 3, 2, 2, 2, 503, 501, 3,
	2, 2, 2, 503, 502, 3, 2, 2, 2, 504, 13, 3, 2, 2, 2, 505, 508, 5, 20, 11,
	2, 506, 508, 5, 26, 14, 2, 507, 505, 3, 2, 2, 2, 507, 506, 3, 2, 2, 2,
	508, 513, 3, 2, 2, 2, 509, 512, 5, 18, 10, 2, 510, 512, 5, 24, 13, 2, 511,
	509, 3, 2, 2, 2, 511, 510, 3, 2, 2, 2, 512, 515, 3, 2, 2, 2, 513, 511,
	3, 2, 2, 2, 513, 514, 3, 2, 2, 2, 514, 15, 3, 2, 2, 2, 515, 513, 3, 2,
	2, 2, 516, 518, 5, 230, 116, 2, 517, 516, 3, 2, 2, 2, 518, 521, 3, 2, 2,
	2, 519, 517, 3, 2, 2, 2, 519, 520, 3, 2, 2, 2, 520, 522, 3, 2, 2, 2, 521,
	519, 3, 2, 2, 2, 522, 524, 7, 104, 2, 2, 523, 525, 5, 42, 22, 2, 524, 523,
	3, 2, 2, 2, 524, 525, 3, 2, 2, 2, 525, 539, 3, 2, 2, 2, 526, 527, 5, 14,
	8, 2, 527, 531, 7, 67, 2, 2, 528, 530, 5, 230, 116, 2, 529, 528, 3, 2,
	2, 2, 530, 533, 3, 2, 2, 2, 531, 529, 3, 2, 2, 2, 531, 532, 3, 2, 2, 2,
	532, 534, 3, 2, 2, 2, 533, 531, 3, 2, 2, 2, 534, 536, 7, 104, 2, 2, 535,
	537, 5, 42, 22, 2, 536, 535, 3, 2, 2, 2, 536, 537, 3, 2, 2, 2, 537, 539,
	3, 2, 2, 2, 538, 519, 3, 2, 2, 2, 538, 526, 3, 2, 2, 2, 539, 17, 3, 2,
	2, 2, 540, 544, 7, 67, 2, 2, 541, 543, 5, 230, 116, 2, 542, 541, 3, 2,
	2, 2, 543, 546, 3, 2, 2, 2, 544, 542, 3, 2, 2, 2, 544, 545, 3, 2, 2, 2,
	545, 547, 3, 2, 2, 2, 546, 544, 3, 2, 2, 2, 547, 549, 7, 104, 2, 2, 548,
	550, 5, 42, 22, 2, 549, 548, 3, 2, 2, 2, 549, 550, 3, 2, 2, 2, 550, 19,
	3, 2, 2, 2, 551, 553, 5, 230, 116, 2, 552, 551, 3, 2, 2, 2, 553, 556, 3,
	2, 2, 2, 554, 552, 3, 2, 2, 2, 554, 555, 3, 2, 2, 2, 555, 557, 3, 2, 2,
	2, 556, 554, 3, 2, 2, 2, 557, 559, 7, 104, 2, 2, 558, 560, 5, 42, 22, 2,
	559, 558, 3, 2, 2, 2, 559, 560, 3, 2, 2, 2, 560, 21, 3, 2, 2, 2, 561, 562,
	5, 16, 9, 2, 562, 23, 3, 2, 2, 2, 563, 564, 5, 18, 10, 2, 564, 25, 3, 2,
	2, 2, 565, 566, 5, 20, 11, 2, 566, 27, 3, 2, 2, 2, 567, 569, 5, 230, 116,
	2, 568, 567, 3, 2, 2, 2, 569, 572, 3, 2, 2, 2, 570, 568, 3, 2, 2, 2, 570,
	571, 3, 2, 2, 2, 571, 573, 3, 2, 2, 2, 572, 570, 3, 2, 2, 2, 573, 574,
	7, 104, 2, 2, 574, 29, 3, 2, 2, 2, 575, 576, 5, 4, 3, 2, 576, 577, 5, 32,
	17, 2, 577, 585, 3, 2, 2, 2, 578, 579, 5, 14, 8, 2, 579, 580, 5, 32, 17,
	2, 580, 585, 3, 2, 2, 2, 581, 582, 5, 28, 15, 2, 582, 583, 5, 32, 17, 2,
	583, 585, 3, 2, 2, 2, 584, 575, 3, 2, 2, 2, 584, 578, 3, 2, 2, 2, 584,
	581, 3, 2, 2, 2, 585, 31, 3, 2, 2, 2, 586, 588, 5, 230, 116, 2, 587, 586,
	3, 2, 2, 2, 588, 591, 3, 2, 2, 2, 589, 587, 3, 2, 2, 2, 589, 590, 3, 2,
	2, 2, 590, 592, 3, 2, 2, 2, 591, 589, 3, 2, 2, 2, 592, 593, 7, 63, 2, 2,
	593, 604, 7, 64, 2, 2, 594, 596, 5, 230, 116, 2, 595, 594, 3, 2, 2, 2,
	596, 599, 3, 2, 2, 2, 597, 595, 3, 2, 2, 2, 597, 598, 3, 2, 2, 2, 598,
	600, 3, 2, 2, 2, 599, 597, 3, 2, 2, 2, 600, 601, 7, 63, 2, 2, 601, 603,
	7, 64, 2, 2, 602, 597, 3, 2, 2, 2, 603, 606, 3, 2, 2, 2, 604, 602, 3, 2,
	2, 2, 604, 605, 3, 2, 2, 2, 605, 33, 3, 2, 2, 2, 606, 604, 3, 2, 2, 2,
	607, 609, 5, 36, 19, 2, 608, 607, 3, 2, 2, 2, 609, 612, 3, 2, 2, 2, 610,
	608, 3, 2, 2, 2, 610, 611, 3, 2, 2, 2, 611, 613, 3, 2, 2, 2, 612, 610,
	3, 2, 2, 2, 613, 615, 7, 104, 2, 2, 614, 616, 5, 38, 20, 2, 615, 614, 3,
	2, 2, 2, 615, 616, 3, 2, 2, 2, 616, 35, 3, 2, 2, 2, 617, 618, 5, 230, 116,
	2, 618, 37, 3, 2, 2, 2, 619, 620, 7, 19, 2, 2, 620, 630, 5, 28, 15, 2,
	621, 622, 7, 19, 2, 2, 622, 626, 5, 14, 8, 2, 623, 625, 5, 40, 21, 2, 624,
	623, 3, 2, 2, 2, 625, 628, 3, 2, 2, 2, 626, 624, 3, 2, 2, 2, 626, 627,
	3, 2, 2, 2, 627, 630, 3, 2, 2, 2, 628, 626, 3, 2, 2, 2, 629, 619, 3, 2,
	2, 2, 629, 621, 3, 2, 2, 2, 630, 39, 3, 2, 2, 2, 631, 632, 7, 87, 2, 2,
	632, 633, 5, 22, 12, 2, 633, 41, 3, 2, 2, 2, 634, 635, 7, 70, 2, 2, 635,
	636, 5, 44, 23, 2, 636, 637, 7, 69, 2, 2, 637, 43, 3, 2, 2, 2, 638, 643,
	5, 46, 24, 2, 639, 640, 7, 66, 2, 2, 640, 642, 5, 46, 24, 2, 641, 639,
	3, 2, 2, 2, 642, 645, 3, 2, 2, 2, 643, 641, 3, 2, 2, 2, 643, 644, 3, 2,
	2, 2, 644, 45, 3, 2, 2, 2, 645, 643, 3, 2, 2, 2, 646, 649, 5, 12, 7, 2,
	647, 649, 5, 48, 25, 2, 648, 646, 3, 2, 2, 2, 648, 647, 3, 2, 2, 2, 649,
	47, 3, 2, 2, 2, 650, 652, 5, 230, 116, 2, 651, 650, 3, 2, 2, 2, 652, 655,
	3, 2, 2, 2, 653, 651, 3, 2, 2, 2, 653, 654, 3, 2, 2, 2, 654, 656, 3, 2,
	2, 2, 655, 653, 3, 2, 2, 2, 656, 658, 7, 73, 2, 2, 657, 659, 5, 50, 26,
	2, 658, 657, 3, 2, 2, 2, 658, 659, 3, 2, 2, 2, 659, 49, 3, 2, 2, 2, 660,
	661, 7, 19, 2, 2, 661, 665, 5, 12, 7, 2, 662, 663, 7, 42, 2, 2, 663, 665,
	5, 12, 7, 2, 664, 660, 3, 2, 2, 2, 664, 662, 3, 2, 2, 2, 665, 51, 3, 2,
	2, 2, 666, 667, 8, 27, 1, 2, 667, 668, 7, 104, 2, 2, 668, 674, 3, 2, 2,
	2, 669, 670, 12, 3, 2, 2, 670, 671, 7, 67, 2, 2, 671, 673, 7, 104, 2, 2,
	672, 669, 3, 2, 2, 2, 673, 676, 3, 2, 2, 2, 674, 672, 3, 2, 2, 2, 674,
	675, 3, 2, 2, 2, 675, 53, 3, 2, 2, 2, 676, 674, 3, 2, 2, 2, 677, 683, 7,
	104, 2, 2, 678, 679, 5, 56, 29, 2, 679, 680, 7, 67, 2, 2, 680, 681, 7,
	104, 2, 2, 681, 683, 3, 2, 2, 2, 682, 677, 3, 2, 2, 2, 682, 678, 3, 2,
	2, 2, 683, 55, 3, 2, 2, 2, 684, 685, 8, 29, 1, 2, 685, 686, 7, 104, 2,
	2, 686, 692, 3, 2, 2, 2, 687, 688, 12, 3, 2, 2, 688, 689, 7, 67, 2, 2,
	689, 691, 7, 104, 2, 2, 690, 687, 3, 2, 2, 2, 691, 694, 3, 2, 2, 2, 692,
	690, 3, 2, 2, 2, 692, 693, 3, 2, 2, 2, 693, 57, 3, 2, 2, 2, 694, 692, 3,
	2, 2, 2, 695, 701, 7, 104, 2, 2, 696, 697, 5, 62, 32, 2, 697, 698, 7, 67,
	2, 2, 698, 699, 7, 104, 2, 2, 699, 701, 3, 2, 2, 2, 700, 695, 3, 2, 2,
	2, 700, 696, 3, 2, 2, 2, 701, 59, 3, 2, 2, 2, 702, 703, 7, 104, 2, 2, 703,
	61, 3, 2, 2, 2, 704, 705, 8, 32, 1, 2, 705, 706, 7, 104, 2, 2, 706, 712,
	3, 2, 2, 2, 707, 708, 12, 3, 2, 2, 708, 709, 7, 67, 2, 2, 709, 711, 7,
	104, 2, 2, 710, 707, 3, 2, 2, 2, 711, 714, 3, 2, 2, 2, 712, 710, 3, 2,
	2, 2, 712, 713, 3, 2, 2, 2, 713, 63, 3, 2, 2, 2, 714, 712, 3, 2, 2, 2,
	715, 717, 5, 66, 34, 2, 716, 715, 3, 2, 2, 2, 716, 717, 3, 2, 2, 2, 717,
	721, 3, 2, 2, 2, 718, 720, 5, 70, 36, 2, 719, 718, 3, 2, 2, 2, 720, 723,
	3, 2, 2, 2, 721, 719, 3, 2, 2, 2, 721, 722, 3, 2, 2, 2, 722, 727, 3, 2,
	2, 2, 723, 721, 3, 2, 2, 2, 724, 726, 5, 80, 41, 2, 725, 724, 3, 2, 2,
	2, 726, 729, 3, 2, 2, 2, 727, 725, 3, 2, 2, 2, 727, 728, 3, 2, 2, 2, 728,
	730, 3, 2, 2, 2, 729, 727, 3, 2, 2, 2, 730, 731, 7, 2, 2, 3, 731, 65, 3,
	2, 2, 2, 732, 734, 5, 68, 35, 2, 733, 732, 3, 2, 2, 2, 734, 737, 3, 2,
	2, 2, 735, 733, 3, 2, 2, 2, 735, 736, 3, 2, 2, 2, 736, 738, 3, 2, 2, 2,
	737, 735, 3, 2, 2, 2, 738, 739, 7, 34, 2, 2, 739, 740, 5, 52, 27, 2, 740,
	741, 7, 65, 2, 2, 741, 67, 3, 2, 2, 2, 742, 743, 5, 230, 116, 2, 743, 69,
	3, 2, 2, 2, 744, 749, 5, 72, 37, 2, 745, 749, 5, 74, 38, 2, 746, 749, 5,
	76, 39, 2, 747, 749, 5, 78, 40, 2, 748, 744, 3, 2, 2, 2, 748, 745, 3, 2,
	2, 2, 748, 746, 3, 2, 2, 2, 748, 747, 3, 2, 2, 2, 749, 71, 3, 2, 2, 2,
	750, 751, 7, 27, 2, 2, 751, 752, 5, 54, 28, 2, 752, 753, 7, 65, 2, 2, 753,
	73, 3, 2, 2, 2, 754, 755, 7, 27, 2, 2, 755, 756, 5, 56, 29, 2, 756, 757,
	7, 67, 2, 2, 757, 758, 7, 85, 2, 2, 758, 759, 7, 65, 2, 2, 759, 75, 3,
	2, 2, 2, 760, 761, 7, 27, 2, 2, 761, 762, 7, 40, 2, 2, 762, 763, 5, 54,
	28, 2, 763, 764, 7, 67, 2, 2, 764, 765, 7, 104, 2, 2, 765, 766, 7, 65,
	2, 2, 766, 77, 3, 2, 2, 2, 767, 768, 7, 27, 2, 2, 768, 769, 7, 40, 2, 2,
	769, 770, 5, 54, 28, 2, 770, 771, 7, 67, 2, 2, 771, 772, 7, 85, 2, 2, 772,
	773, 7, 65, 2, 2, 773, 79, 3, 2, 2, 2, 774, 778, 5, 82, 42, 2, 775, 778,
	5, 198, 100, 2, 776, 778, 7, 65, 2, 2, 777, 774, 3, 2, 2, 2, 777, 775,
	3, 2, 2, 2, 777, 776, 3, 2, 2, 2, 778, 81, 3, 2, 2, 2, 779, 782, 5, 84,
	43, 2, 780, 782, 5, 186, 94, 2, 781, 779, 3, 2, 2, 2, 781, 780, 3, 2, 2,
	2, 782, 83, 3, 2, 2, 2, 783, 785, 5, 86, 44, 2, 784, 783, 3, 2, 2, 2, 785,
	788, 3, 2, 2, 2, 786, 784, 3, 2, 2, 2, 786, 787, 3, 2, 2, 2, 787, 789,
	3, 2, 2, 2, 788, 786, 3, 2, 2, 2, 789, 790, 7, 11, 2, 2, 790, 792, 7, 104,
	2, 2, 791, 793, 5, 88, 45, 2, 792, 791, 3, 2, 2, 2, 792, 793, 3, 2, 2,
	2, 793, 795, 3, 2, 2, 2, 794, 796, 5, 92, 47, 2, 795, 794, 3, 2, 2, 2,
	795, 796, 3, 2, 2, 2, 796, 798, 3, 2, 2, 2, 797, 799, 5, 94, 48, 2, 798,
	797, 3, 2, 2, 2, 798, 799, 3, 2, 2, 2, 799, 800, 3, 2, 2, 2, 800, 801,
	5, 98, 50, 2, 801, 85, 3, 2, 2, 2, 802, 811, 5, 230, 116, 2, 803, 811,
	7, 37, 2, 2, 804, 811, 7, 36, 2, 2, 805, 811, 7, 35, 2, 2, 806, 811, 7,
	3, 2, 2, 807, 811, 7, 40, 2, 2, 808, 811, 7, 20, 2, 2, 809, 811, 7, 41,
	2, 2, 810, 802, 3, 2, 2, 2, 810, 803, 3, 2, 2, 2, 810, 804, 3, 2, 2, 2,
	810, 805, 3, 2, 2, 2, 810, 806, 3, 2, 2, 2, 810, 807, 3, 2, 2, 2, 810,
	808, 3, 2, 2, 2, 810, 809, 3, 2, 2, 2, 811, 87, 3, 2, 2, 2, 812, 813, 7,
	70, 2, 2, 813, 814, 5, 90, 46, 2, 814, 815, 7, 69, 2, 2, 815, 89, 3, 2,
	2, 2, 816, 821, 5, 34, 18, 2, 817, 818, 7, 66, 2, 2, 818, 820, 5, 34, 18,
	2, 819, 817, 3, 2, 2, 2, 820, 823, 3, 2, 2, 2, 821, 819, 3, 2, 2, 2, 821,
	822, 3, 2, 2, 2, 822, 91, 3, 2, 2, 2, 823, 821, 3, 2, 2, 2, 824, 825, 7,
	19, 2, 2, 825, 826, 5, 16, 9, 2, 826, 93, 3, 2, 2, 2, 827, 828, 7, 26,
	2, 2, 828, 829, 5, 96, 49, 2, 829, 95, 3, 2, 2, 2, 830, 835, 5, 22, 12,
	2, 831, 832, 7, 66, 2, 2, 832, 834, 5, 22, 12, 2, 833, 831, 3, 2, 2, 2,
	834, 837, 3, 2, 2, 2, 835, 833, 3, 2, 2, 2, 835, 836, 3, 2, 2, 2, 836,
	97, 3, 2, 2, 2, 837, 835, 3, 2, 2, 2, 838, 842, 7, 61, 2, 2, 839, 841,
	5, 100, 51, 2, 840, 839, 3, 2, 2, 2, 841, 844, 3, 2, 2, 2, 842, 840, 3,
	2, 2, 2, 842, 843, 3, 2, 2, 2, 843, 845, 3, 2, 2, 2, 844, 842, 3, 2, 2,
	2, 845, 846, 7, 62, 2, 2, 846, 99, 3, 2, 2, 2, 847, 852, 5, 102, 52, 2,
	848, 852, 5, 170, 86, 2, 849, 852, 5, 172, 87, 2, 850, 852, 5, 174, 88,
	2, 851, 847, 3, 2, 2, 2, 851, 848, 3, 2, 2, 2, 851, 849, 3, 2, 2, 2, 851,
	850, 3, 2, 2, 2, 852, 101, 3, 2, 2, 2, 853, 859, 5, 104, 53, 2, 854, 859,
	5, 140, 71, 2, 855, 859, 5, 82, 42, 2, 856, 859, 5, 198, 100, 2, 857, 859,
	7, 65, 2, 2, 858, 853, 3, 2, 2, 2, 858, 854, 3, 2, 2, 2, 858, 855, 3, 2,
	2, 2, 858, 856, 3, 2, 2, 2, 858, 857, 3, 2, 2, 2, 859, 103, 3, 2, 2, 2,
	860, 862, 5, 106, 54, 2, 861, 860, 3, 2, 2, 2, 862, 865, 3, 2, 2, 2, 863,
	861, 3, 2, 2, 2, 863, 864, 3, 2, 2, 2, 864, 866, 3, 2, 2, 2, 865, 863,
	3, 2, 2, 2, 866, 867, 5, 116, 59, 2, 867, 868, 5, 108, 55, 2, 868, 869,
	7, 65, 2, 2, 869, 105, 3, 2, 2, 2, 870, 879, 5, 230, 116, 2, 871, 879,
	7, 37, 2, 2, 872, 879, 7, 36, 2, 2, 873, 879, 7, 35, 2, 2, 874, 879, 7,
	40, 2, 2, 875, 879, 7, 20, 2, 2, 876, 879, 7, 48, 2, 2, 877, 879, 7, 51,
	2, 2, 878, 870, 3, 2, 2, 2, 878, 871, 3, 2, 2, 2, 878, 872, 3, 2, 2, 2,
	878, 873, 3, 2, 2, 2, 878, 874, 3, 2, 2, 2, 878, 875, 3, 2, 2, 2, 878,
	876, 3, 2, 2, 2, 878, 877, 3, 2, 2, 2, 879, 107, 3, 2, 2, 2, 880, 885,
	5, 110, 56, 2, 881, 882, 7, 66, 2, 2, 882, 884, 5, 110, 56, 2, 883, 881,
	3, 2, 2, 2, 884, 887, 3, 2, 2, 2, 885, 883, 3, 2, 2, 2, 885, 886, 3, 2,
	2, 2, 886, 109, 3, 2, 2, 2, 887, 885, 3, 2, 2, 2, 888, 891, 5, 112, 57,
	2, 889, 890, 7, 68, 2, 2, 890, 892, 5, 114, 58, 2, 891, 889, 3, 2, 2, 2,
	891, 892, 3, 2, 2, 2, 892, 111, 3, 2, 2, 2, 893, 895, 7, 104, 2, 2, 894,
	896, 5, 32, 17, 2, 895, 894, 3, 2, 2, 2, 895, 896, 3, 2, 2, 2, 896, 113,
	3, 2, 2, 2, 897, 900, 5, 414, 208, 2, 898, 900, 5, 248, 125, 2, 899, 897,
	3, 2, 2, 2, 899, 898, 3, 2, 2, 2, 900, 115, 3, 2, 2, 2, 901, 904, 5, 118,
	60, 2, 902, 904, 5, 120, 61, 2, 903, 901, 3, 2, 2, 2, 903, 902, 3, 2, 2,
	2, 904, 117, 3, 2, 2, 2, 905, 908, 5, 6, 4, 2, 906, 908, 7, 5, 2, 2, 907,
	905, 3, 2, 2, 2, 907, 906, 3, 2, 2, 2, 908, 119, 3, 2, 2, 2, 909, 913,
	5, 122, 62, 2, 910, 913, 5, 136, 69, 2, 911, 913, 5, 138, 70, 2, 912, 909,
	3, 2, 2, 2, 912, 910, 3, 2, 2, 2, 912, 911, 3, 2, 2, 2, 913, 121, 3, 2,
	2, 2, 914, 917, 5, 128, 65, 2, 915, 917, 5, 134, 68, 2, 916, 914, 3, 2,
	2, 2, 916, 915, 3, 2, 2, 2, 917, 922, 3, 2, 2, 2, 918, 921, 5, 126, 64,
	2, 919, 921, 5, 132, 67, 2, 920, 918, 3, 2, 2, 2, 920, 919, 3, 2, 2, 2,
	921, 924, 3, 2, 2, 2, 922, 920, 3, 2, 2, 2, 922, 923, 3, 2, 2, 2, 923,
	123, 3, 2, 2, 2, 924, 922, 3, 2, 2, 2, 925, 927, 7, 104, 2, 2, 926, 928,
	5, 42, 22, 2, 927, 926, 3, 2, 2, 2, 927, 928, 3, 2, 2, 2, 928, 942, 3,
	2, 2, 2, 929, 930, 5, 122, 62, 2, 930, 934, 7, 67, 2, 2, 931, 933, 5, 230,
	116, 2, 932, 931, 3, 2, 2, 2, 933, 936, 3, 2, 2, 2, 934, 932, 3, 2, 2,
	2, 934, 935, 3, 2, 2, 2, 935, 937, 3, 2, 2, 2, 936, 934, 3, 2, 2, 2, 937,
	939, 7, 104, 2, 2, 938, 940, 5, 42, 22, 2, 939, 938, 3, 2, 2, 2, 939, 940,
	3, 2, 2, 2, 940, 942, 3, 2, 2, 2, 941, 925, 3, 2, 2, 2, 941, 929, 3, 2,
	2, 2, 942, 125, 3, 2, 2, 2, 943, 947, 7, 67, 2, 2, 944, 946, 5, 230, 116,
	2, 945, 944, 3, 2, 2, 2, 946, 949, 3, 2, 2, 2, 947, 945, 3, 2, 2, 2, 947,
	948, 3, 2, 2, 2, 948, 950, 3, 2, 2, 2, 949, 947, 3, 2, 2, 2, 950, 952,
	7, 104, 2, 2, 951, 953, 5, 42, 22, 2, 952, 951, 3, 2, 2, 2, 952, 953, 3,
	2, 2, 2, 953, 127, 3, 2, 2, 2, 954, 956, 7, 104, 2, 2, 955, 957, 5, 42,
	22, 2, 956, 955, 3, 2, 2, 2, 956, 957, 3, 2, 2, 2, 957, 129, 3, 2, 2, 2,
	958, 959, 5, 124, 63, 2, 959, 131, 3, 2, 2, 2, 960, 961, 5, 126, 64, 2,
	961, 133, 3, 2, 2, 2, 962, 963, 5, 128, 65, 2, 963, 135, 3, 2, 2, 2, 964,
	965, 7, 104, 2, 2, 965, 137, 3, 2, 2, 2, 966, 967, 5, 118, 60, 2, 967,
	968, 5, 32, 17, 2, 968, 976, 3, 2, 2, 2, 969, 970, 5, 122, 62, 2, 970,
	971, 5, 32, 17, 2, 971, 976, 3, 2, 2, 2, 972, 973, 5, 136, 69, 2, 973,
	974, 5, 32, 17, 2, 974, 976, 3, 2, 2, 2, 975, 966, 3, 2, 2, 2, 975, 969,
	3, 2, 2, 2, 975, 972, 3, 2, 2, 2, 976, 139, 3, 2, 2, 2, 977, 979, 5, 142,
	72, 2, 978, 977, 3, 2, 2, 2, 979, 982, 3, 2, 2, 2, 980, 978, 3, 2, 2, 2,
	980, 981, 3, 2, 2, 2, 981, 983, 3, 2, 2, 2, 982, 980, 3, 2, 2, 2, 983,
	984, 5, 144, 73, 2, 984, 985, 5, 168, 85, 2, 985, 141, 3, 2, 2, 2, 986,
	997, 5, 230, 116, 2, 987, 997, 7, 37, 2, 2, 988, 997, 7, 36, 2, 2, 989,
	997, 7, 35, 2, 2, 990, 997, 7, 3, 2, 2, 991, 997, 7, 40, 2, 2, 992, 997,
	7, 20, 2, 2, 993, 997, 7, 44, 2, 2, 994, 997, 7, 32, 2, 2, 995, 997, 7,
	41, 2, 2, 996, 986, 3, 2, 2, 2, 996, 987, 3, 2, 2, 2, 996, 988, 3, 2, 2,
	2, 996, 989, 3, 2, 2, 2, 996, 990, 3, 2, 2, 2, 996, 991, 3, 2, 2, 2, 996,
	992, 3, 2, 2, 2, 996, 993, 3, 2, 2, 2, 996, 994, 3, 2, 2, 2, 996, 995,
	3, 2, 2, 2, 997, 143, 3, 2, 2, 2, 998, 999, 5, 146, 74, 2, 999, 1001, 5,
	148, 75, 2, 1000, 1002, 5, 162, 82, 2, 1001, 1000, 3, 2, 2, 2, 1001, 1002,
	3, 2, 2, 2, 1002, 1016, 3, 2, 2, 2, 1003, 1007, 5, 88, 45, 2, 1004, 1006,
	5, 230, 116, 2, 1005, 1004, 3, 2, 2, 2, 1006, 1009, 3, 2, 2, 2, 1007, 1005,
	3, 2, 2, 2, 1007, 1008, 3, 2, 2, 2, 1008, 1010, 3, 2, 2, 2, 1009, 1007,
	3, 2, 2, 2, 1010, 1011, 5, 146, 74, 2, 1011, 1013, 5, 148, 75, 2, 1012,
	1014, 5, 162, 82, 2, 1013, 1012, 3, 2, 2, 2, 1013, 1014, 3, 2, 2, 2, 1014,
	1016, 3, 2, 2, 2, 1015, 998, 3, 2, 2, 2, 1015, 1003, 3, 2, 2, 2, 1016,
	145, 3, 2, 2, 2, 1017, 1020, 5, 116, 59, 2, 1018, 1020, 7, 50, 2, 2, 1019,
	1017, 3, 2, 2, 2, 1019, 1018, 3, 2, 2, 2, 1020, 147, 3, 2, 2, 2, 1021,
	1022, 7, 104, 2, 2, 1022, 1024, 7, 59, 2, 2, 1023, 1025, 5, 150, 76, 2,
	1024, 1023, 3, 2, 2, 2, 1024, 1025, 3, 2, 2, 2, 1025, 1026, 3, 2, 2, 2,
	1026, 1028, 7, 60, 2, 2, 1027, 1029, 5, 32, 17, 2, 1028, 1027, 3, 2, 2,
	2, 1028, 1029, 3, 2, 2, 2, 1029, 149, 3, 2, 2, 2, 1030, 1037, 5, 160, 81,
	2, 1031, 1032, 5, 152, 77, 2, 1032, 1033, 7, 66, 2, 2, 1033, 1034, 5, 158,
	80, 2, 1034, 1037, 3, 2, 2, 2, 1035, 1037, 5, 158, 80, 2, 1036, 1030, 3,
	2, 2, 2, 1036, 1031, 3, 2, 2, 2, 1036, 1035, 3, 2, 2, 2, 1037, 151, 3,
	2, 2, 2, 1038, 1043, 5, 154, 78, 2, 1039, 1040, 7, 66, 2, 2, 1040, 1042,
	5, 154, 78, 2, 1041, 1039, 3, 2, 2, 2, 1042, 1045, 3, 2, 2, 2, 1043, 1041,
	3, 2, 2, 2, 1043, 1044, 3, 2, 2, 2, 1044, 1055, 3, 2, 2, 2, 1045, 1043,
	3, 2, 2, 2, 1046, 1051, 5, 160, 81, 2, 1047, 1048, 7, 66, 2, 2, 1048, 1050,
	5, 154, 78, 2, 1049, 1047, 3, 2, 2, 2, 1050, 1053, 3, 2, 2, 2, 1051, 1049,
	3, 2, 2, 2, 1051, 1052, 3, 2, 2, 2, 1052, 1055, 3, 2, 2, 2, 1053, 1051,
	3, 2, 2, 2, 1054, 1038, 3, 2, 2, 2, 1054, 1046, 3, 2, 2, 2, 1055, 153,
	3, 2, 2, 2, 1056, 1058, 5, 156, 79, 2, 1057, 1056, 3, 2, 2, 2, 1058, 1061,
	3, 2, 2, 2, 1059, 1057, 3, 2, 2, 2, 1059, 1060, 3, 2, 2, 2, 1060, 1062,
	3, 2, 2, 2, 1061, 1059, 3, 2, 2, 2, 1062, 1063, 5, 116, 59, 2, 1063, 1064,
	5, 112, 57, 2, 1064, 155, 3, 2, 2, 2, 1065, 1068, 5, 230, 116, 2, 1066,
	1068, 7, 20, 2, 2, 1067, 1065, 3, 2, 2, 2, 1067, 1066, 3, 2, 2, 2, 1068,
	157, 3, 2, 2, 2, 1069, 1071, 5, 156, 79, 2, 1070, 1069, 3, 2, 2, 2, 1071,
	1074, 3, 2, 2, 2, 1072, 1070, 3, 2, 2, 2, 1072, 1073, 3, 2, 2, 2, 1073,
	1075, 3, 2, 2, 2, 1074, 1072, 3, 2, 2, 2, 1075, 1079, 5, 116, 59, 2, 1076,
	1078, 5, 230, 116, 2, 1077, 1076, 3, 2, 2, 2, 1078, 1081, 3, 2, 2, 2, 1079,
	1077, 3, 2, 2, 2, 1079, 1080, 3, 2, 2, 2, 1080, 1082, 3, 2, 2, 2, 1081,
	1079, 3, 2, 2, 2, 1082, 1083, 7, 106, 2, 2, 1083, 1084, 5, 112, 57, 2,
	1084, 1087, 3, 2, 2, 2, 1085, 1087, 5, 154, 78, 2, 1086, 1072, 3, 2, 2,
	2, 1086, 1085, 3, 2, 2, 2, 1087, 159, 3, 2, 2, 2, 1088, 1090, 5, 230, 116,
	2, 1089, 1088, 3, 2, 2, 2, 1090, 1093, 3, 2, 2, 2, 1091, 1089, 3, 2, 2,
	2, 1091, 1092, 3, 2, 2, 2, 1092, 1094, 3, 2, 2, 2, 1093, 1091, 3, 2, 2,
	2, 1094, 1097, 5, 116, 59, 2, 1095, 1096, 7, 104, 2, 2, 1096, 1098, 7,
	67, 2, 2, 1097, 1095, 3, 2, 2, 2, 1097, 1098, 3, 2, 2, 2, 1098, 1099, 3,
	2, 2, 2, 1099, 1100, 7, 45, 2, 2, 1100, 161, 3, 2, 2, 2, 1101, 1102, 7,
	47, 2, 2, 1102, 1103, 5, 164, 83, 2, 1103, 163, 3, 2, 2, 2, 1104, 1109,
	5, 166, 84, 2, 1105, 1106, 7, 66, 2, 2, 1106, 1108, 5, 166, 84, 2, 1107,
	1105, 3, 2, 2, 2, 1108, 1111, 3, 2, 2, 2, 1109, 1107, 3, 2, 2, 2, 1109,
	1110, 3, 2, 2, 2, 1110, 165, 3, 2, 2, 2, 1111, 1109, 3, 2, 2, 2, 1112,
	1115, 5, 16, 9, 2, 1113, 1115, 5, 28, 15, 2, 1114, 1112, 3, 2, 2, 2, 1114,
	1113, 3, 2, 2, 2, 1115, 167, 3, 2, 2, 2, 1116, 1119, 5, 252, 127, 2, 1117,
	1119, 7, 65, 2, 2, 1118, 1116, 3, 2, 2, 2, 1118, 1117, 3, 2, 2, 2, 1119,
	169, 3, 2, 2, 2, 1120, 1121, 5, 252, 127, 2, 1121, 171, 3, 2, 2, 2, 1122,
	1123, 7, 40, 2, 2, 1123, 1124, 5, 252, 127, 2, 1124, 173, 3, 2, 2, 2, 1125,
	1127, 5, 176, 89, 2, 1126, 1125, 3, 2, 2, 2, 1127, 1130, 3, 2, 2, 2, 1128,
	1126, 3, 2, 2, 2, 1128, 1129, 3, 2, 2, 2, 1129, 1131, 3, 2, 2, 2, 1130,
	1128, 3, 2, 2, 2, 1131, 1133, 5, 178, 90, 2, 1132, 1134, 5, 162, 82, 2,
	1133, 1132, 3, 2, 2, 2, 1133, 1134, 3, 2, 2, 2, 1134, 1135, 3, 2, 2, 2,
	1135, 1136, 5, 182, 92, 2, 1136, 175, 3, 2, 2, 2, 1137, 1142, 5, 230, 116,
	2, 1138, 1142, 7, 37, 2, 2, 1139, 1142, 7, 36, 2, 2, 1140, 1142, 7, 35,
	2, 2, 1141, 1137, 3, 2, 2, 2, 1141, 1138, 3, 2, 2, 2, 1141, 1139, 3, 2,
	2, 2, 1141, 1140, 3, 2, 2, 2, 1142, 177, 3, 2, 2, 2, 1143, 1145, 5, 88,
	45, 2, 1144, 1143, 3, 2, 2, 2, 1144, 1145, 3, 2, 2, 2, 1145, 1146, 3, 2,
	2, 2, 1146, 1147, 5, 180, 91, 2, 1147, 1149, 7, 59, 2, 2, 1148, 1150, 5,
	150, 76, 2, 1149, 1148, 3, 2, 2, 2, 1149, 1150, 3, 2, 2, 2, 1150, 1151,
	3, 2, 2, 2, 1151, 1152, 7, 60, 2, 2, 1152, 179, 3, 2, 2, 2, 1153, 1154,
	7, 104, 2, 2, 1154, 181, 3, 2, 2, 2, 1155, 1157, 7, 61, 2, 2, 1156, 1158,
	5, 184, 93, 2, 1157, 1156, 3, 2, 2, 2, 1157, 1158, 3, 2, 2, 2, 1158, 1160,
	3, 2, 2, 2, 1159, 1161, 5, 254, 128, 2, 1160, 1159, 3, 2, 2, 2, 1160, 1161,
	3, 2, 2, 2, 1161, 1162, 3, 2, 2, 2, 1162, 1163, 7, 62, 2, 2, 1163, 183,
	3, 2, 2, 2, 1164, 1166, 5, 42, 22, 2, 1165, 1164, 3, 2, 2, 2, 1165, 1166,
	3, 2, 2, 2, 1166, 1167, 3, 2, 2, 2, 1167, 1168, 7, 45, 2, 2, 1168, 1170,
	7, 59, 2, 2, 1169, 1171, 5, 398, 200, 2, 1170, 1169, 3, 2, 2, 2, 1170,
	1171, 3, 2, 2, 2, 1171, 1172, 3, 2, 2, 2, 1172, 1173, 7, 60, 2, 2, 1173,
	1211, 7, 65, 2, 2, 1174, 1176, 5, 42, 22, 2, 1175, 1174, 3, 2, 2, 2, 1175,
	1176, 3, 2, 2, 2, 1176, 1177, 3, 2, 2, 2, 1177, 1178, 7, 42, 2, 2, 1178,
	1180, 7, 59, 2, 2, 1179, 1181, 5, 398, 200, 2, 1180, 1179, 3, 2, 2, 2,
	1180, 1181, 3, 2, 2, 2, 1181, 1182, 3, 2, 2, 2, 1182, 1183, 7, 60, 2, 2,
	1183, 1211, 7, 65, 2, 2, 1184, 1185, 5, 58, 30, 2, 1185, 1187, 7, 67, 2,
	2, 1186, 1188, 5, 42, 22, 2, 1187, 1186, 3, 2, 2, 2, 1187, 1188, 3, 2,
	2, 2, 1188, 1189, 3, 2, 2, 2, 1189, 1190, 7, 42, 2, 2, 1190, 1192, 7, 59,
	2, 2, 1191, 1193, 5, 398, 200, 2, 1192, 1191, 3, 2, 2, 2, 1192, 1193, 3,
	2, 2, 2, 1193, 1194, 3, 2, 2, 2, 1194, 1195, 7, 60, 2, 2, 1195, 1196, 7,
	65, 2, 2, 1196, 1211, 3, 2, 2, 2, 1197, 1198, 5, 352, 177, 2, 1198, 1200,
	7, 67, 2, 2, 1199, 1201, 5, 42, 22, 2, 1200, 1199, 3, 2, 2, 2, 1200, 1201,
	3, 2, 2, 2, 1201, 1202, 3, 2, 2, 2, 1202, 1203, 7, 42, 2, 2, 1203, 1205,
	7, 59, 2, 2, 1204, 1206, 5, 398, 200, 2, 1205, 1204, 3, 2, 2, 2, 1205,
	1206, 3, 2, 2, 2, 1206, 1207, 3, 2, 2, 2, 1207, 1208, 7, 60, 2, 2, 1208,
	1209, 7, 65, 2, 2, 1209, 1211, 3, 2, 2, 2, 1210, 1165, 3, 2, 2, 2, 1210,
	1175, 3, 2, 2, 2, 1210, 1184, 3, 2, 2, 2, 1210, 1197, 3, 2, 2, 2, 1211,
	185, 3, 2, 2, 2, 1212, 1214, 5, 86, 44, 2, 1213, 1212, 3, 2, 2, 2, 1214,
	1217, 3, 2, 2, 2, 1215, 1213, 3, 2, 2, 2, 1215, 1216, 3, 2, 2, 2, 1216,
	1218, 3, 2, 2, 2, 1217, 1215, 3, 2, 2, 2, 1218, 1219, 7, 18, 2, 2, 1219,
	1221, 7, 104, 2, 2, 1220, 1222, 5, 94, 48, 2, 1221, 1220, 3, 2, 2, 2, 1221,
	1222, 3, 2, 2, 2, 1222, 1223, 3, 2, 2, 2, 1223, 1224, 5, 188, 95, 2, 1224,
	187, 3, 2, 2, 2, 1225, 1227, 7, 61, 2, 2, 1226, 1228, 5, 190, 96, 2, 1227,
	1226, 3, 2, 2, 2, 1227, 1228, 3, 2, 2, 2, 1228, 1230, 3, 2, 2, 2, 1229,
	1231, 7, 66, 2, 2, 1230, 1229, 3, 2, 2, 2, 1230, 1231, 3, 2, 2, 2, 1231,
	1233, 3, 2, 2, 2, 1232, 1234, 5, 196, 99, 2, 1233, 1232, 3, 2, 2, 2, 1233,
	1234, 3, 2, 2, 2, 1234, 1235, 3, 2, 2, 2, 1235, 1236, 7, 62, 2, 2, 1236,
	189, 3, 2, 2, 2, 1237, 1242, 5, 192, 97, 2, 1238, 1239, 7, 66, 2, 2, 1239,
	1241, 5, 192, 97, 2, 1240, 1238, 3, 2, 2, 2, 1241, 1244, 3, 2, 2, 2, 1242,
	1240, 3, 2, 2, 2, 1242, 1243, 3, 2, 2, 2, 1243, 191, 3, 2, 2, 2, 1244,
	1242, 3, 2, 2, 2, 1245, 1247, 5, 194, 98, 2, 1246, 1245, 3, 2, 2, 2, 1247,
	1250, 3, 2, 2, 2, 1248, 1246, 3, 2, 2, 2, 1248, 1249, 3, 2, 2, 2, 1249,
	1251, 3, 2, 2, 2, 1250, 1248, 3, 2, 2, 2, 1251, 1257, 7, 104, 2, 2, 1252,
	1254, 7, 59, 2, 2, 1253, 1255, 5, 398, 200, 2, 1254, 1253, 3, 2, 2, 2,
	1254, 1255, 3, 2, 2, 2, 1255, 1256, 3, 2, 2, 2, 1256, 1258, 7, 60, 2, 2,
	1257, 1252, 3, 2, 2, 2, 1257, 1258, 3, 2, 2, 2, 1258, 1260, 3, 2, 2, 2,
	1259, 1261, 5, 98, 50, 2, 1260, 1259, 3, 2, 2, 2, 1260, 1261, 3, 2, 2,
	2, 1261, 193, 3, 2, 2, 2, 1262, 1263, 5, 230, 116, 2, 1263, 195, 3, 2,
	2, 2, 1264, 1268, 7, 65, 2, 2, 1265, 1267, 5, 100, 51, 2, 1266, 1265, 3,
	2, 2, 2, 1267, 1270, 3, 2, 2, 2, 1268, 1266, 3, 2, 2, 2, 1268, 1269, 3,
	2, 2, 2, 1269, 197, 3, 2, 2, 2, 1270, 1268, 3, 2, 2, 2, 1271, 1274, 5,
	200, 101, 2, 1272, 1274, 5, 218, 110, 2, 1273, 1271, 3, 2, 2, 2, 1273,
	1272, 3, 2, 2, 2, 1274, 199, 3, 2, 2, 2, 1275, 1277, 5, 202, 102, 2, 1276,
	1275, 3, 2, 2, 2, 1277, 1280, 3, 2, 2, 2, 1278, 1276, 3, 2, 2, 2, 1278,
	1279, 3, 2, 2, 2, 1279, 1281, 3, 2, 2, 2, 1280, 1278, 3, 2, 2, 2, 1281,
	1282, 7, 30, 2, 2, 1282, 1284, 7, 104, 2, 2, 1283, 1285, 5, 88, 45, 2,
	1284, 1283, 3, 2, 2, 2, 1284, 1285, 3, 2, 2, 2, 1285, 1287, 3, 2, 2, 2,
	1286, 1288, 5, 204, 103, 2, 1287, 1286, 3, 2, 2, 2, 1287, 1288, 3, 2, 2,
	2, 1288, 1289, 3, 2, 2, 2, 1289, 1290, 5, 206, 104, 2, 1290, 201, 3, 2,
	2, 2, 1291, 1299, 5, 230, 116, 2, 1292, 1299, 7, 37, 2, 2, 1293, 1299,
	7, 36, 2, 2, 1294, 1299, 7, 35, 2, 2, 1295, 1299, 7, 3, 2, 2, 1296, 1299,
	7, 40, 2, 2, 1297, 1299, 7, 41, 2, 2, 1298, 1291, 3, 2, 2, 2, 1298, 1292,
	3, 2, 2, 2, 1298, 1293, 3, 2, 2, 2, 1298, 1294, 3, 2, 2, 2, 1298, 1295,
	3, 2, 2, 2, 1298, 1296, 3, 2, 2, 2, 1298, 1297, 3, 2, 2, 2, 1299, 203,
	3, 2, 2, 2, 1300, 1301, 7, 19, 2, 2, 1301, 1302, 5, 96, 49, 2, 1302, 205,
	3, 2, 2, 2, 1303, 1307, 7, 61, 2, 2, 1304, 1306, 5, 208, 105, 2, 1305,
	1304, 3, 2, 2, 2, 1306, 1309, 3, 2, 2, 2, 1307, 1305, 3, 2, 2, 2, 1307,
	1308, 3, 2, 2, 2, 1308, 1310, 3, 2, 2, 2, 1309, 1307, 3, 2, 2, 2, 1310,
	1311, 7, 62, 2, 2, 1311, 207, 3, 2, 2, 2, 1312, 1318, 5, 210, 106, 2, 1313,
	1318, 5, 214, 108, 2, 1314, 1318, 5, 82, 42, 2, 1315, 1318, 5, 198, 100,
	2, 1316, 1318, 7, 65, 2, 2, 1317, 1312, 3, 2, 2, 2, 1317, 1313, 3, 2, 2,
	2, 1317, 1314, 3, 2, 2, 2, 1317, 1315, 3, 2, 2, 2, 1317, 1316, 3, 2, 2,
	2, 1318, 209, 3, 2, 2, 2, 1319, 1321, 5, 212, 107, 2, 1320, 1319, 3, 2,
	2, 2, 1321, 1324, 3, 2, 2, 2, 1322, 1320, 3, 2, 2, 2, 1322, 1323, 3, 2,
	2, 2, 1323, 1325, 3, 2, 2, 2, 1324, 1322, 3, 2, 2, 2, 1325, 1326, 5, 116,
	59, 2, 1326, 1327, 5, 108, 55, 2, 1327, 1328, 7, 65, 2, 2, 1328, 211, 3,
	2, 2, 2, 1329, 1334, 5, 230, 116, 2, 1330, 1334, 7, 37, 2, 2, 1331, 1334,
	7, 40, 2, 2, 1332, 1334, 7, 20, 2, 2, 1333, 1329, 3, 2, 2, 2, 1333, 1330,
	3, 2, 2, 2, 1333, 1331, 3, 2, 2, 2, 1333, 1332, 3, 2, 2, 2, 1334, 213,
	3, 2, 2, 2, 1335, 1337, 5, 216, 109, 2, 1336, 1335, 3, 2, 2, 2, 1337, 1340,
	3, 2, 2, 2, 1338, 1336, 3, 2, 2, 2, 1338, 1339, 3, 2, 2, 2, 1339, 1341,
	3, 2, 2, 2, 1340, 1338, 3, 2, 2, 2, 1341, 1342, 5, 144, 73, 2, 1342, 1343,
	5, 168, 85, 2, 1343, 215, 3, 2, 2, 2, 1344, 1351, 5, 230, 116, 2, 1345,
	1351, 7, 37, 2, 2, 1346, 1351, 7, 3, 2, 2, 1347, 1351, 7, 14, 2, 2, 1348,
	1351, 7, 40, 2, 2, 1349, 1351, 7, 41, 2, 2, 1350, 1344, 3, 2, 2, 2, 1350,
	1345, 3, 2, 2, 2, 1350, 1346, 3, 2, 2, 2, 1350, 1347, 3, 2, 2, 2, 1350,
	1348, 3, 2, 2, 2, 1350, 1349, 3, 2, 2, 2, 1351, 217, 3, 2, 2, 2, 1352,
	1354, 5, 202, 102, 2, 1353, 1352, 3, 2, 2, 2, 1354, 1357, 3, 2, 2, 2, 1355,
	1353, 3, 2, 2, 2, 1355, 1356, 3, 2, 2, 2, 1356, 1358, 3, 2, 2, 2, 1357,
	1355, 3, 2, 2, 2, 1358, 1359, 7, 105, 2, 2, 1359, 1360, 7, 30, 2, 2, 1360,
	1361, 7, 104, 2, 2, 1361, 1362, 5, 220, 111, 2, 1362, 219, 3, 2, 2, 2,
	1363, 1367, 7, 61, 2, 2, 1364, 1366, 5, 222, 112, 2, 1365, 1364, 3, 2,
	2, 2, 1366, 1369, 3, 2, 2, 2, 1367, 1365, 3, 2, 2, 2, 1367, 1368, 3, 2,
	2, 2, 1368, 1370, 3, 2, 2, 2, 1369, 1367, 3, 2, 2, 2, 1370, 1371, 7, 62,
	2, 2, 1371, 221, 3, 2, 2, 2, 1372, 1378, 5, 224, 113, 2, 1373, 1378, 5,
	210, 106, 2, 1374, 1378, 5, 82, 42, 2, 1375, 1378, 5, 198, 100, 2, 1376,
	1378, 7, 65, 2, 2, 1377, 1372, 3, 2, 2, 2, 1377, 1373, 3, 2, 2, 2, 1377,
	1374, 3, 2, 2, 2, 1377, 1375, 3, 2, 2, 2, 1377, 1376, 3, 2, 2, 2, 1378,
	223, 3, 2, 2, 2, 1379, 1381, 5, 226, 114, 2, 1380, 1379, 3, 2, 2, 2, 1381,
	1384, 3, 2, 2, 2, 1382, 1380, 3, 2, 2, 2, 1382, 1383, 3, 2, 2, 2, 1383,
	1385, 3, 2, 2, 2, 1384, 1382, 3, 2, 2, 2, 1385, 1386, 5, 116, 59, 2, 1386,
	1387, 7, 104, 2, 2, 1387, 1388, 7, 59, 2, 2, 1388, 1390, 7, 60, 2, 2, 1389,
	1391, 5, 32, 17, 2, 1390, 1389, 3, 2, 2, 2, 1390, 1391, 3, 2, 2, 2, 1391,
	1393, 3, 2, 2, 2, 1392, 1394, 5, 228, 115, 2, 1393, 1392, 3, 2, 2, 2, 1393,
	1394, 3, 2, 2, 2, 1394, 1395, 3, 2, 2, 2, 1395, 1396, 7, 65, 2, 2, 1396,
	225, 3, 2, 2, 2, 1397, 1401, 5, 230, 116, 2, 1398, 1401, 7, 37, 2, 2, 1399,
	1401, 7, 3, 2, 2, 1400, 1397, 3, 2, 2, 2, 1400, 1398, 3, 2, 2, 2, 1400,
	1399, 3, 2, 2, 2, 1401, 227, 3, 2, 2, 2, 1402, 1403, 7, 14, 2, 2, 1403,
	1404, 5, 238, 120, 2, 1404, 229, 3, 2, 2, 2, 1405, 1409, 5, 232, 117, 2,
	1406, 1409, 5, 244, 123, 2, 1407, 1409, 5, 246, 124, 2, 1408, 1405, 3,
	2, 2, 2, 1408, 1406, 3, 2, 2, 2, 1408, 1407, 3, 2, 2, 2, 1409, 231, 3,
	2, 2, 2, 1410, 1411, 7, 105, 2, 2, 1411, 1412, 5, 54, 28, 2, 1412, 1414,
	7, 59, 2, 2, 1413, 1415, 5, 234, 118, 2, 1414, 1413, 3, 2, 2, 2, 1414,
	1415, 3, 2, 2, 2, 1415, 1416, 3, 2, 2, 2, 1416, 1417, 7, 60, 2, 2, 1417,
	233, 3, 2, 2, 2, 1418, 1423, 5, 236, 119, 2, 1419, 1420, 7, 66, 2, 2, 1420,
	1422, 5, 236, 119, 2, 1421, 1419, 3, 2, 2, 2, 1422, 1425, 3, 2, 2, 2, 1423,
	1421, 3, 2, 2, 2, 1423, 1424, 3, 2, 2, 2, 1424, 235, 3, 2, 2, 2, 1425,
	1423, 3, 2, 2, 2, 1426, 1427, 7, 104, 2, 2, 1427, 1428, 7, 68, 2, 2, 1428,
	1429, 5, 238, 120, 2, 1429, 237, 3, 2, 2, 2, 1430, 1434, 5, 432, 217, 2,
	1431, 1434, 5, 240, 121, 2, 1432, 1434, 5, 230, 116, 2, 1433, 1430, 3,
	2, 2, 2, 1433, 1431, 3, 2, 2, 2, 1433, 1432, 3, 2, 2, 2, 1434, 239, 3,
	2, 2, 2, 1435, 1437, 7, 61, 2, 2, 1436, 1438, 5, 242, 122, 2, 1437, 1436,
	3, 2, 2, 2, 1437, 1438, 3, 2, 2, 2, 1438, 1440, 3, 2, 2, 2, 1439, 1441,
	7, 66, 2, 2, 1440, 1439, 3, 2, 2, 2, 1440, 1441, 3, 2, 2, 2, 1441, 1442,
	3, 2, 2, 2, 1442, 1443, 7, 62, 2, 2, 1443, 241, 3, 2, 2, 2, 1444, 1449,
	5, 238, 120, 2, 1445, 1446, 7, 66, 2, 2, 1446, 1448, 5, 238, 120, 2, 1447,
	1445, 3, 2, 2, 2, 1448, 1451, 3, 2, 2, 2, 1449, 1447, 3, 2, 2, 2, 1449,
	1450, 3, 2, 2, 2, 1450, 243, 3, 2, 2, 2, 1451, 1449, 3, 2, 2, 2, 1452,
	1453, 7, 105, 2, 2, 1453, 1454, 5, 54, 28, 2, 1454, 245, 3, 2, 2, 2, 1455,
	1456, 7, 105, 2, 2, 1456, 1457, 5, 54, 28, 2, 1457, 1458, 7, 59, 2, 2,
	1458, 1459, 5, 238, 120, 2, 1459, 1460, 7, 60, 2, 2, 1460, 247, 3, 2, 2,
	2, 1461, 1463, 7, 61, 2, 2, 1462, 1464, 5, 250, 126, 2, 1463, 1462, 3,
	2, 2, 2, 1463, 1464, 3, 2, 2, 2, 1464, 1466, 3, 2, 2, 2, 1465, 1467, 7,
	66, 2, 2, 1466, 1465, 3, 2, 2, 2, 1466, 1467, 3, 2, 2, 2, 1467, 1468, 3,
	2, 2, 2, 1468, 1469, 7, 62, 2, 2, 1469, 249, 3, 2, 2, 2, 1470, 1475, 5,
	114, 58, 2, 1471, 1472, 7, 66, 2, 2, 1472, 1474, 5, 114, 58, 2, 1473, 1471,
	3, 2, 2, 2, 1474, 1477, 3, 2, 2, 2, 1475, 1473, 3, 2, 2, 2, 1475, 1476,
	3, 2, 2, 2, 1476, 251, 3, 2, 2, 2, 1477, 1475, 3, 2, 2, 2, 1478, 1480,
	7, 61, 2, 2, 1479, 1481, 5, 254, 128, 2, 1480, 1479, 3, 2, 2, 2, 1480,
	1481, 3, 2, 2, 2, 1481, 1482, 3, 2, 2, 2, 1482, 1483, 7, 62, 2, 2, 1483,
	253, 3, 2, 2, 2, 1484, 1486, 5, 256, 129, 2, 1485, 1484, 3, 2, 2, 2, 1486,
	1487, 3, 2, 2, 2, 1487, 1485, 3, 2, 2, 2, 1487, 1488, 3, 2, 2, 2, 1488,
	255, 3, 2, 2, 2, 1489, 1493, 5, 258, 130, 2, 1490, 1493, 5, 82, 42, 2,
	1491, 1493, 5, 262, 132, 2, 1492, 1489, 3, 2, 2, 2, 1492, 1490, 3, 2, 2,
	2, 1492, 1491, 3, 2, 2, 2, 1493, 257, 3, 2, 2, 2, 1494, 1495, 5, 260, 131,
	2, 1495, 1496, 7, 65, 2, 2, 1496, 259, 3, 2, 2, 2, 1497, 1499, 5, 156,
	79, 2, 1498, 1497, 3, 2, 2, 2, 1499, 1502, 3, 2, 2, 2, 1500, 1498, 3, 2,
	2, 2, 1500, 1501, 3, 2, 2, 2, 1501, 1503, 3, 2, 2, 2, 1502, 1500, 3, 2,
	2, 2, 1503, 1504, 5, 116, 59, 2, 1504, 1505, 5, 108, 55, 2, 1505, 261,
	3, 2, 2, 2, 1506, 1513, 5, 266, 134, 2, 1507, 1513, 5, 270, 136, 2, 1508,
	1513, 5, 278, 140, 2, 1509, 1513, 5, 280, 141, 2, 1510, 1513, 5, 298, 150,
	2, 1511, 1513, 5, 304, 153, 2, 1512, 1506, 3, 2, 2, 2, 1512, 1507, 3, 2,
	2, 2, 1512, 1508, 3, 2, 2, 2, 1512, 1509, 3, 2, 2, 2, 1512, 1510, 3, 2,
	2, 2, 1512, 1511, 3, 2, 2, 2, 1513, 263, 3, 2, 2, 2, 1514, 1520, 5, 266,
	134, 2, 1515, 1520, 5, 272, 137, 2, 1516, 1520, 5, 282, 142, 2, 1517, 1520,
	5, 300, 151, 2, 1518, 1520, 5, 306, 154, 2, 1519, 1514, 3, 2, 2, 2, 1519,
	1515, 3, 2, 2, 2, 1519, 1516, 3, 2, 2, 2, 1519, 1517, 3, 2, 2, 2, 1519,
	1518, 3, 2, 2, 2, 1520, 265, 3, 2, 2, 2, 1521, 1534, 5, 252, 127, 2, 1522,
	1534, 5, 268, 135, 2, 1523, 1534, 5, 274, 138, 2, 1524, 1534, 5, 284, 143,
	2, 1525, 1534, 5, 286, 144, 2, 1526, 1534, 5, 302, 152, 2, 1527, 1534,
	5, 322, 162, 2, 1528, 1534, 5, 324, 163, 2, 1529, 1534, 5, 326, 164, 2,
	1530, 1534, 5, 330, 166, 2, 1531, 1534, 5, 328, 165, 2, 1532, 1534, 5,
	332, 167, 2, 1533, 1521, 3, 2, 2, 2, 1533, 1522, 3, 2, 2, 2, 1533, 1523,
	3, 2, 2, 2, 1533, 1524, 3, 2, 2, 2, 1533, 1525, 3, 2, 2, 2, 1533, 1526,
	3, 2, 2, 2, 1533, 1527, 3, 2, 2, 2, 1533, 1528, 3, 2, 2, 2, 1533, 1529,
	3, 2, 2, 2, 1533, 1530, 3, 2, 2, 2, 1533, 1531, 3, 2, 2, 2, 1533, 1532,
	3, 2, 2, 2, 1534, 267, 3, 2, 2, 2, 1535, 1536, 7, 65, 2, 2, 1536, 269,
	3, 2, 2, 2, 1537, 1538, 7, 104, 2, 2, 1538, 1539, 7, 74, 2, 2, 1539, 1540,
	5, 262, 132, 2, 1540, 271, 3, 2, 2, 2, 1541, 1542, 7, 104, 2, 2, 1542,
	1543, 7, 74, 2, 2, 1543, 1544, 5, 264, 133, 2, 1544, 273, 3, 2, 2, 2, 1545,
	1546, 5, 276, 139, 2, 1546, 1547, 7, 65, 2, 2, 1547, 275, 3, 2, 2, 2, 1548,
	1556, 5, 426, 214, 2, 1549, 1556, 5, 456, 229, 2, 1550, 1556, 5, 458, 230,
	2, 1551, 1556, 5, 464, 233, 2, 1552, 1556, 5, 468, 235, 2, 1553, 1556,
	5, 392, 197, 2, 1554, 1556, 5, 372, 187, 2, 1555, 1548, 3, 2, 2, 2, 1555,
	1549, 3, 2, 2, 2, 1555, 1550, 3, 2, 2, 2, 1555, 1551, 3, 2, 2, 2, 1555,
	1552, 3, 2, 2, 2, 1555, 1553, 3, 2, 2, 2, 1555, 1554, 3, 2, 2, 2, 1556,
	277, 3, 2, 2, 2, 1557, 1558, 7, 24, 2, 2, 1558, 1559, 7, 59, 2, 2, 1559,
	1560, 5, 414, 208, 2, 1560, 1561, 7, 60, 2, 2, 1561, 1562, 5, 262, 132,
	2, 1562, 279, 3, 2, 2, 2, 1563, 1564, 7, 24, 2, 2, 1564, 1565, 7, 59, 2,
	2, 1565, 1566, 5, 414, 208, 2, 1566, 1567, 7, 60, 2, 2, 1567, 1568, 5,
	264, 133, 2, 1568, 1569, 7, 17, 2, 2, 1569, 1570, 5, 262, 132, 2, 1570,
	281, 3, 2, 2, 2, 1571, 1572, 7, 24, 2, 2, 1572, 1573, 7, 59, 2, 2, 1573,
	1574, 5, 414, 208, 2, 1574, 1575, 7, 60, 2, 2, 1575, 1576, 5, 264, 133,
	2, 1576, 1577, 7, 17, 2, 2, 1577, 1578, 5, 264, 133, 2, 1578, 283, 3, 2,
	2, 2, 1579, 1580, 7, 4, 2, 2, 1580, 1581, 5, 414, 208, 2, 1581, 1582, 7,
	65, 2, 2, 1582, 1590, 3, 2, 2, 2, 1583, 1584, 7, 4, 2, 2, 1584, 1585, 5,
	414, 208, 2, 1585, 1586, 7, 74, 2, 2, 1586, 1587, 5, 414, 208, 2, 1587,
	1588, 7, 65, 2, 2, 1588, 1590, 3, 2, 2, 2, 1589, 1579, 3, 2, 2, 2, 1589,
	1583, 3, 2, 2, 2, 1590, 285, 3, 2, 2, 2, 1591, 1592, 7, 43, 2, 2, 1592,
	1593, 7, 59, 2, 2, 1593, 1594, 5, 414, 208, 2, 1594, 1595, 7, 60, 2, 2,
	1595, 1596, 5, 288, 145, 2, 1596, 287, 3, 2, 2, 2, 1597, 1601, 7, 61, 2,
	2, 1598, 1600, 5, 290, 146, 2, 1599, 1598, 3, 2, 2, 2, 1600, 1603, 3, 2,
	2, 2, 1601, 1599, 3, 2, 2, 2, 1601, 1602, 3, 2, 2, 2, 1602, 1607, 3, 2,
	2, 2, 1603, 1601, 3, 2, 2, 2, 1604, 1606, 5, 294, 148, 2, 1605, 1604, 3,
	2, 2, 2, 1606, 1609, 3, 2, 2, 2, 1607, 1605, 3, 2, 2, 2, 1607, 1608, 3,
	2, 2, 2, 1608, 1610, 3, 2, 2, 2, 1609, 1607, 3, 2, 2, 2, 1610, 1611, 7,
	62, 2, 2, 1611, 289, 3, 2, 2, 2, 1612, 1613, 5, 292, 147, 2, 1613, 1614,
	5, 254, 128, 2, 1614, 291, 3, 2, 2, 2, 1615, 1619, 5, 294, 148, 2, 1616,
	1618, 5, 294, 148, 2, 1617, 1616, 3, 2, 2, 2, 1618, 1621, 3, 2, 2, 2, 1619,
	1617, 3, 2, 2, 2, 1619, 1620, 3, 2, 2, 2, 1620, 293, 3, 2, 2, 2, 1621,
	1619, 3, 2, 2, 2, 1622, 1623, 7, 8, 2, 2, 1623, 1624, 5, 412, 207, 2, 1624,
	1625, 7, 74, 2, 2, 1625, 1633, 3, 2, 2, 2, 1626, 1627, 7, 8, 2, 2, 1627,
	1628, 5, 296, 149, 2, 1628, 1629, 7, 74, 2, 2, 1629, 1633, 3, 2, 2, 2,
	1630, 1631, 7, 14, 2, 2, 1631, 1633, 7, 74, 2, 2, 1632, 1622, 3, 2, 2,
	2, 1632, 1626, 3, 2, 2, 2, 1632, 1630, 3, 2, 2, 2, 1633, 295, 3, 2, 2,
	2, 1634, 1635, 7, 104, 2, 2, 1635, 297, 3, 2, 2, 2, 1636, 1637, 7, 52,
	2, 2, 1637, 1638, 7, 59, 2, 2, 1638, 1639, 5, 414, 208, 2, 1639, 1640,
	7, 60, 2, 2, 1640, 1641, 5, 262, 132, 2, 1641, 299, 3, 2, 2, 2, 1642, 1643,
	7, 52, 2, 2, 1643, 1644, 7, 59, 2, 2, 1644, 1645, 5, 414, 208, 2, 1645,
	1646, 7, 60, 2, 2, 1646, 1647, 5, 264, 133, 2, 1647, 301, 3, 2, 2, 2, 1648,
	1649, 7, 15, 2, 2, 1649, 1650, 5, 262, 132, 2, 1650, 1651, 7, 52, 2, 2,
	1651, 1652, 7, 59, 2, 2, 1652, 1653, 5, 414, 208, 2, 1653, 1654, 7, 60,
	2, 2, 1654, 1655, 7, 65, 2, 2, 1655, 303, 3, 2, 2, 2, 1656, 1659, 5, 308,
	155, 2, 1657, 1659, 5, 318, 160, 2, 1658, 1656, 3, 2, 2, 2, 1658, 1657,
	3, 2, 2, 2, 1659, 305, 3, 2, 2, 2, 1660, 1663, 5, 310, 156, 2, 1661, 1663,
	5, 320, 161, 2, 1662, 1660, 3, 2, 2, 2, 1662, 1661, 3, 2, 2, 2, 1663, 307,
	3, 2, 2, 2, 1664, 1665, 7, 23, 2, 2, 1665, 1667, 7, 59, 2, 2, 1666, 1668,
	5, 312, 157, 2, 1667, 1666, 3, 2, 2, 2, 1667, 1668, 3, 2, 2, 2, 1668, 1669,
	3, 2, 2, 2, 1669, 1671, 7, 65, 2, 2, 1670, 1672, 5, 414, 208, 2, 1671,
	1670, 3, 2, 2, 2, 1671, 1672, 3, 2, 2, 2, 1672, 1673, 3, 2, 2, 2, 1673,
	1675, 7, 65, 2, 2, 1674, 1676, 5, 314, 158, 2, 1675, 1674, 3, 2, 2, 2,
	1675, 1676, 3, 2, 2, 2, 1676, 1677, 3, 2, 2, 2, 1677, 1678, 7, 60, 2, 2,
	1678, 1679, 5, 262, 132, 2, 1679, 309, 3, 2, 2, 2, 1680, 1681, 7, 23, 2,
	2, 1681, 1683, 7, 59, 2, 2, 1682, 1684, 5, 312, 157, 2, 1683, 1682, 3,
	2, 2, 2, 1683, 1684, 3, 2, 2, 2, 1684, 1685, 3, 2, 2, 2, 1685, 1687, 7,
	65, 2, 2, 1686, 1688, 5, 414, 208, 2, 1687, 1686, 3, 2, 2, 2, 1687, 1688,
	3, 2, 2, 2, 1688, 1689, 3, 2, 2, 2, 1689, 1691, 7, 65, 2, 2, 1690, 1692,
	5, 314, 158, 2, 1691, 1690, 3, 2, 2, 2, 1691, 1692, 3, 2, 2, 2, 1692, 1693,
	3, 2, 2, 2, 1693, 1694, 7, 60, 2, 2, 1694, 1695, 5, 264, 133, 2, 1695,
	311, 3, 2, 2, 2, 1696, 1699, 5, 316, 159, 2, 1697, 1699, 5, 260, 131, 2,
	1698, 1696, 3, 2, 2, 2, 1698, 1697, 3, 2, 2, 2, 1699, 313, 3, 2, 2, 2,
	1700, 1701, 5, 316, 159, 2, 1701, 315, 3, 2, 2, 2, 1702, 1707, 5, 276,
	139, 2, 1703, 1704, 7, 66, 2, 2, 1704, 1706, 5, 276, 139, 2, 1705, 1703,
	3, 2, 2, 2, 1706, 1709, 3, 2, 2, 2, 1707, 1705, 3, 2, 2, 2, 1707, 1708,
	3, 2, 2, 2, 1708, 317, 3, 2, 2, 2, 1709, 1707, 3, 2, 2, 2, 1710, 1711,
	7, 23, 2, 2, 1711, 1715, 7, 59, 2, 2, 1712, 1714, 5, 156, 79, 2, 1713,
	1712, 3, 2, 2, 2, 1714, 1717, 3, 2, 2, 2, 1715, 1713, 3, 2, 2, 2, 1715,
	1716, 3, 2, 2, 2, 1716, 1718, 3, 2, 2, 2, 1717, 1715, 3, 2, 2, 2, 1718,
	1719, 5, 116, 59, 2, 1719, 1720, 5, 112, 57, 2, 1720, 1721, 7, 74, 2, 2,
	1721, 1722, 5, 414, 208, 2, 1722, 1723, 7, 60, 2, 2, 1723, 1724, 5, 262,
	132, 2, 1724, 319, 3, 2, 2, 2, 1725, 1726, 7, 23, 2, 2, 1726, 1730, 7,
	59, 2, 2, 1727, 1729, 5, 156, 79, 2, 1728, 1727, 3, 2, 2, 2, 1729, 1732,
	3, 2, 2, 2, 1730, 1728, 3, 2, 2, 2, 1730, 1731, 3, 2, 2, 2, 1731, 1733,
	3, 2, 2, 2, 1732, 1730, 3, 2, 2, 2, 1733, 1734, 5, 116, 59, 2, 1734, 1735,
	5, 112, 57, 2, 1735, 1736, 7, 74, 2, 2, 1736, 1737, 5, 414, 208, 2, 1737,
	1738, 7, 60, 2, 2, 1738, 1739, 5, 264, 133, 2, 1739, 321, 3, 2, 2, 2, 1740,
	1742, 7, 6, 2, 2, 1741, 1743, 7, 104, 2, 2, 1742, 1741, 3, 2, 2, 2, 1742,
	1743, 3, 2, 2, 2, 1743, 1744, 3, 2, 2, 2, 1744, 1745, 7, 65, 2, 2, 1745,
	323, 3, 2, 2, 2, 1746, 1748, 7, 13, 2, 2, 1747, 1749, 7, 104, 2, 2, 1748,
	1747, 3, 2, 2, 2, 1748, 1749, 3, 2, 2, 2, 1749, 1750, 3, 2, 2, 2, 1750,
	1751, 7, 65, 2, 2, 1751, 325, 3, 2, 2, 2, 1752, 1754, 7, 38, 2, 2, 1753,
	1755, 5, 414, 208, 2, 1754, 1753, 3, 2, 2, 2, 1754, 1755, 3, 2, 2, 2, 1755,
	1756, 3, 2, 2, 2, 1756, 1757, 7, 65, 2, 2, 1757, 327, 3, 2, 2, 2, 1758,
	1759, 7, 46, 2, 2, 1759, 1760, 5, 414, 208, 2, 1760, 1761, 7, 65, 2, 2,
	1761, 329, 3, 2, 2, 2, 1762, 1763, 7, 44, 2, 2, 1763, 1764, 7, 59, 2, 2,
	1764, 1765, 5, 414, 208, 2, 1765, 1766, 7, 60, 2, 2, 1766, 1767, 5, 252,
	127, 2, 1767, 331, 3, 2, 2, 2, 1768, 1769, 7, 49, 2, 2, 1769, 1770, 5,
	252, 127, 2, 1770, 1771, 5, 334, 168, 2, 1771, 1781, 3, 2, 2, 2, 1772,
	1773, 7, 49, 2, 2, 1773, 1775, 5, 252, 127, 2, 1774, 1776, 5, 334, 168,
	2, 1775, 1774, 3, 2, 2, 2, 1775, 1776, 3, 2, 2, 2, 1776, 1777, 3, 2, 2,
	2, 1777, 1778, 5, 342, 172, 2, 1778, 1781, 3, 2, 2, 2, 1779, 1781, 5, 344,
	173, 2, 1780, 1768, 3, 2, 2, 2, 1780, 1772, 3, 2, 2, 2, 1780, 1779, 3,
	2, 2, 2, 1781, 333, 3, 2, 2, 2, 1782, 1786, 5, 336, 169, 2, 1783, 1785,
	5, 336, 169, 2, 1784, 1783, 3, 2, 2, 2, 1785, 1788, 3, 2, 2, 2, 1786, 1784,
	3, 2, 2, 2, 1786, 1787, 3, 2, 2, 2, 1787, 335, 3, 2, 2, 2, 1788, 1786,
	3, 2, 2, 2, 1789, 1790, 7, 9, 2, 2, 1790, 1791, 7, 59, 2, 2, 1791, 1792,
	5, 338, 170, 2, 1792, 1793, 7, 60, 2, 2, 1793, 1794, 5, 252, 127, 2, 1794,
	337, 3, 2, 2, 2, 1795, 1797, 5, 156, 79, 2, 1796, 1795, 3, 2, 2, 2, 1797,
	1800, 3, 2, 2, 2, 1798, 1796, 3, 2, 2, 2, 1798, 1799, 3, 2, 2, 2, 1799,
	1801, 3, 2, 2, 2, 1800, 1798, 3, 2, 2, 2, 1801, 1802, 5, 340, 171, 2, 1802,
	1803, 5, 112, 57, 2, 1803, 339, 3, 2, 2, 2, 1804, 1809, 5, 124, 63, 2,
	1805, 1806, 7, 88, 2, 2, 1806, 1808, 5, 16, 9, 2, 1807, 1805, 3, 2, 2,
	2, 1808, 1811, 3, 2, 2, 2, 1809, 1807, 3, 2, 2, 2, 1809, 1810, 3, 2, 2,
	2, 1810, 341, 3, 2, 2, 2, 1811, 1809, 3, 2, 2, 2, 1812, 1813, 7, 21, 2,
	2, 1813, 1814, 5, 252, 127, 2, 1814, 343, 3, 2, 2, 2, 1815, 1816, 7, 49,
	2, 2, 1816, 1817, 5, 346, 174, 2, 1817, 1819, 5, 252, 127, 2, 1818, 1820,
	5, 334, 168, 2, 1819, 1818, 3, 2, 2, 2, 1819, 1820, 3, 2, 2, 2, 1820, 1822,
	3, 2, 2, 2, 1821, 1823, 5, 342, 172, 2, 1822, 1821, 3, 2, 2, 2, 1822, 1823,
	3, 2, 2, 2, 1823, 345, 3, 2, 2, 2, 1824, 1825, 7, 59, 2, 2, 1825, 1827,
	5, 348, 175, 2, 1826, 1828, 7, 65, 2, 2, 1827, 1826, 3, 2, 2, 2, 1827,
	1828, 3, 2, 2, 2, 1828, 1829, 3, 2, 2, 2, 1829, 1830, 7, 60, 2, 2, 1830,
	347, 3, 2, 2, 2, 1831, 1836, 5, 350, 176, 2, 1832, 1833, 7, 65, 2, 2, 1833,
	1835, 5, 350, 176, 2, 1834, 1832, 3, 2, 2, 2, 1835, 1838, 3, 2, 2, 2, 1836,
	1834, 3, 2, 2, 2, 1836, 1837, 3, 2, 2, 2, 1837, 349, 3, 2, 2, 2, 1838,
	1836, 3, 2, 2, 2, 1839, 1841, 5, 156, 79, 2, 1840, 1839, 3, 2, 2, 2, 1841,
	1844, 3, 2, 2, 2, 1842, 1840, 3, 2, 2, 2, 1842, 1843, 3, 2, 2, 2, 1843,
	1845, 3, 2, 2, 2, 1844, 1842, 3, 2, 2, 2, 1845, 1846, 5, 116, 59, 2, 1846,
	1847, 5, 112, 57, 2, 1847, 1848, 7, 68, 2, 2, 1848, 1849, 5, 414, 208,
	2, 1849, 351, 3, 2, 2, 2, 1850, 1853, 5, 366, 184, 2, 1851, 1853, 5, 406,
	204, 2, 1852, 1850, 3, 2, 2, 2, 1852, 1851, 3, 2, 2, 2, 1853, 1857, 3,
	2, 2, 2, 1854, 1856, 5, 360, 181, 2, 1855, 1854, 3, 2, 2, 2, 1856, 1859,
	3, 2, 2, 2, 1857, 1855, 3, 2, 2, 2, 1857, 1858, 3, 2, 2, 2, 1858, 353,
	3, 2, 2, 2, 1859, 1857, 3, 2, 2, 2, 1860, 1890, 5, 2, 2, 2, 1861, 1866,
	5, 54, 28, 2, 1862, 1863, 7, 63, 2, 2, 1863, 1865, 7, 64, 2, 2, 1864, 1862,
	3, 2, 2, 2, 1865, 1868, 3, 2, 2, 2, 1866, 1864, 3, 2, 2, 2, 1866, 1867,
	3, 2, 2, 2, 1867, 1869, 3, 2, 2, 2, 1868, 1866, 3, 2, 2, 2, 1869, 1870,
	7, 67, 2, 2, 1870, 1871, 7, 11, 2, 2, 1871, 1890, 3, 2, 2, 2, 1872, 1873,
	7, 50, 2, 2, 1873, 1874, 7, 67, 2, 2, 1874, 1890, 7, 11, 2, 2, 1875, 1890,
	7, 45, 2, 2, 1876, 1877, 5, 54, 28, 2, 1877, 1878, 7, 67, 2, 2, 1878, 1879,
	7, 45, 2, 2, 1879, 1890, 3, 2, 2, 2, 1880, 1881, 7, 59, 2, 2, 1881, 1882,
	5, 414, 208, 2, 1882, 1883, 7, 60, 2, 2, 1883, 1890, 3, 2, 2, 2, 1884,
	1890, 5, 372, 187, 2, 1885, 1890, 5, 380, 191, 2, 1886, 1890, 5, 386, 194,
	2, 1887, 1890, 5, 392, 197, 2, 1888, 1890, 5, 400, 201, 2, 1889, 1860,
	3, 2, 2, 2, 1889, 1861, 3, 2, 2, 2, 1889, 1872, 3, 2, 2, 2, 1889, 1875,
	3, 2, 2, 2, 1889, 1876, 3, 2, 2, 2, 1889, 1880, 3, 2, 2, 2, 1889, 1884,
	3, 2, 2, 2, 1889, 1885, 3, 2, 2, 2, 1889, 1886, 3, 2, 2, 2, 1889, 1887,
	3, 2, 2, 2, 1889, 1888, 3, 2, 2, 2, 1890, 355, 3, 2, 2, 2, 1891, 1892,
	3, 2, 2, 2, 1892, 357, 3, 2, 2, 2, 1893, 1922, 5, 2, 2, 2, 1894, 1899,
	5, 54, 28, 2, 1895, 1896, 7, 63, 2, 2, 1896, 1898, 7, 64, 2, 2, 1897, 1895,
	3, 2, 2, 2, 1898, 1901, 3, 2, 2, 2, 1899, 1897, 3, 2, 2, 2, 1899, 1900,
	3, 2, 2, 2, 1900, 1902, 3, 2, 2, 2, 1901, 1899, 3, 2, 2, 2, 1902, 1903,
	7, 67, 2, 2, 1903, 1904, 7, 11, 2, 2, 1904, 1922, 3, 2, 2, 2, 1905, 1906,
	7, 50, 2, 2, 1906, 1907, 7, 67, 2, 2, 1907, 1922, 7, 11, 2, 2, 1908, 1922,
	7, 45, 2, 2, 1909, 1910, 5, 54, 28, 2, 1910, 1911, 7, 67, 2, 2, 1911, 1912,
	7, 45, 2, 2, 1912, 1922, 3, 2, 2, 2, 1913, 1914, 7, 59, 2, 2, 1914, 1915,
	5, 414, 208, 2, 1915, 1916, 7, 60, 2, 2, 1916, 1922, 3, 2, 2, 2, 1917,
	1922, 5, 372, 187, 2, 1918, 1922, 5, 380, 191, 2, 1919, 1922, 5, 392, 197,
	2, 1920, 1922, 5, 400, 201, 2, 1921, 1893, 3, 2, 2, 2, 1921, 1894, 3, 2,
	2, 2, 1921, 1905, 3, 2, 2, 2, 1921, 1908, 3, 2, 2, 2, 1921, 1909, 3, 2,
	2, 2, 1921, 1913, 3, 2, 2, 2, 1921, 1917, 3, 2, 2, 2, 1921, 1918, 3, 2,
	2, 2, 1921, 1919, 3, 2, 2, 2, 1921, 1920, 3, 2, 2, 2, 1922, 359, 3, 2,
	2, 2, 1923, 1929, 5, 374, 188, 2, 1924, 1929, 5, 382, 192, 2, 1925, 1929,
	5, 388, 195, 2, 1926, 1929, 5, 394, 198, 2, 1927, 1929, 5, 402, 202, 2,
	1928, 1923, 3, 2, 2, 2, 1928, 1924, 3, 2, 2, 2, 1928, 1925, 3, 2, 2, 2,
	1928, 1926, 3, 2, 2, 2, 1928, 1927, 3, 2, 2, 2, 1929, 361, 3, 2, 2, 2,
	1930, 1931, 3, 2, 2, 2, 1931, 363, 3, 2, 2, 2, 1932, 1937, 5, 374, 188,
	2, 1933, 1937, 5, 382, 192, 2, 1934, 1937, 5, 394, 198, 2, 1935, 1937,
	5, 402, 202, 2, 1936, 1932, 3, 2, 2, 2, 1936, 1933, 3, 2, 2, 2, 1936, 1934,
	3, 2, 2, 2, 1936, 1935, 3, 2, 2, 2, 1937, 365, 3, 2, 2, 2, 1938, 1979,
	5, 2, 2, 2, 1939, 1944, 5, 54, 28, 2, 1940, 1941, 7, 63, 2, 2, 1941, 1943,
	7, 64, 2, 2, 1942, 1940, 3, 2, 2, 2, 1943, 1946, 3, 2, 2, 2, 1944, 1942,
	3, 2, 2, 2, 1944, 1945, 3, 2, 2, 2, 1945, 1947, 3, 2, 2, 2, 1946, 1944,
	3, 2, 2, 2, 1947, 1948, 7, 67, 2, 2, 1948, 1949, 7, 11, 2, 2, 1949, 1979,
	3, 2, 2, 2, 1950, 1955, 5, 118, 60, 2, 1951, 1952, 7, 63, 2, 2, 1952, 1954,
	7, 64, 2, 2, 1953, 1951, 3, 2, 2, 2, 1954, 1957, 3, 2, 2, 2, 1955, 1953,
	3, 2, 2, 2, 1955, 1956, 3, 2, 2, 2, 1956, 1958, 3, 2, 2, 2, 1957, 1955,
	3, 2, 2, 2, 1958, 1959, 7, 67, 2, 2, 1959, 1960, 7, 11, 2, 2, 1960, 1979,
	3, 2, 2, 2, 1961, 1962, 7, 50, 2, 2, 1962, 1963, 7, 67, 2, 2, 1963, 1979,
	7, 11, 2, 2, 1964, 1979, 7, 45, 2, 2, 1965, 1966, 5, 54, 28, 2, 1966, 1967,
	7, 67, 2, 2, 1967, 1968, 7, 45, 2, 2, 1968, 1979, 3, 2, 2, 2, 1969, 1970,
	7, 59, 2, 2, 1970, 1971, 5, 414, 208, 2, 1971, 1972, 7, 60, 2, 2, 1972,
	1979, 3, 2, 2, 2, 1973, 1979, 5, 376, 189, 2, 1974, 1979, 5, 384, 193,
	2, 1975, 1979, 5, 390, 196, 2, 1976, 1979, 5, 396, 199, 2, 1977, 1979,
	5, 404, 203, 2, 1978, 1938, 3, 2, 2, 2, 1978, 1939, 3, 2, 2, 2, 1978, 1950,
	3, 2, 2, 2, 1978, 1961, 3, 2, 2, 2, 1978, 1964, 3, 2, 2, 2, 1978, 1965,
	3, 2, 2, 2, 1978, 1969, 3, 2, 2, 2, 1978, 1973, 3, 2, 2, 2, 1978, 1974,
	3, 2, 2, 2, 1978, 1975, 3, 2, 2, 2, 1978, 1976, 3, 2, 2, 2, 1978, 1977,
	3, 2, 2, 2, 1979, 367, 3, 2, 2, 2, 1980, 1981, 3, 2, 2, 2, 1981, 369, 3,
	2, 2, 2, 1982, 2022, 5, 2, 2, 2, 1983, 1988, 5, 54, 28, 2, 1984, 1985,
	7, 63, 2, 2, 1985, 1987, 7, 64, 2, 2, 1986, 1984, 3, 2, 2, 2, 1987, 1990,
	3, 2, 2, 2, 1988, 1986, 3, 2, 2, 2, 1988, 1989, 3, 2, 2, 2, 1989, 1991,
	3, 2, 2, 2, 1990, 1988, 3, 2, 2, 2, 1991, 1992, 7, 67, 2, 2, 1992, 1993,
	7, 11, 2, 2, 1993, 2022, 3, 2, 2, 2, 1994, 1999, 5, 118, 60, 2, 1995, 1996,
	7, 63, 2, 2, 1996, 1998, 7, 64, 2, 2, 1997, 1995, 3, 2, 2, 2, 1998, 2001,
	3, 2, 2, 2, 1999, 1997, 3, 2, 2, 2, 1999, 2000, 3, 2, 2, 2, 2000, 2002,
	3, 2, 2, 2, 2001, 1999, 3, 2, 2, 2, 2002, 2003, 7, 67, 2, 2, 2003, 2004,
	7, 11, 2, 2, 2004, 2022, 3, 2, 2, 2, 2005, 2006, 7, 50, 2, 2, 2006, 2007,
	7, 67, 2, 2, 2007, 2022, 7, 11, 2, 2, 2008, 2022, 7, 45, 2, 2, 2009, 2010,
	5, 54, 28, 2, 2010, 2011, 7, 67, 2, 2, 2011, 2012, 7, 45, 2, 2, 2012, 2022,
	3, 2, 2, 2, 2013, 2014, 7, 59, 2, 2, 2014, 2015, 5, 414, 208, 2, 2015,
	2016, 7, 60, 2, 2, 2016, 2022, 3, 2, 2, 2, 2017, 2022, 5, 376, 189, 2,
	2018, 2022, 5, 384, 193, 2, 2019, 2022, 5, 396, 199, 2, 2020, 2022, 5,
	404, 203, 2, 2021, 1982, 3, 2, 2, 2, 2021, 1983, 3, 2, 2, 2, 2021, 1994,
	3, 2, 2, 2, 2021, 2005, 3, 2, 2, 2, 2021, 2008, 3, 2, 2, 2, 2021, 2009,
	3, 2, 2, 2, 2021, 2013, 3, 2, 2, 2, 2021, 2017, 3, 2, 2, 2, 2021, 2018,
	3, 2, 2, 2, 2021, 2019, 3, 2, 2, 2, 2021, 2020, 3, 2, 2, 2, 2022, 371,
	3, 2, 2, 2, 2023, 2025, 7, 33, 2, 2, 2024, 2026, 5, 42, 22, 2, 2025, 2024,
	3, 2, 2, 2, 2025, 2026, 3, 2, 2, 2, 2026, 2030, 3, 2, 2, 2, 2027, 2029,
	5, 230, 116, 2, 2028, 2027, 3, 2, 2, 2, 2029, 2032, 3, 2, 2, 2, 2030, 2028,
	3, 2, 2, 2, 2030, 2031, 3, 2, 2, 2, 2031, 2033, 3, 2, 2, 2, 2032, 2030,
	3, 2, 2, 2, 2033, 2044, 7, 104, 2, 2, 2034, 2038, 7, 67, 2, 2, 2035, 2037,
	5, 230, 116, 2, 2036, 2035, 3, 2, 2, 2, 2037, 2040, 3, 2, 2, 2, 2038, 2036,
	3, 2, 2, 2, 2038, 2039, 3, 2, 2, 2, 2039, 2041, 3, 2, 2, 2, 2040, 2038,
	3, 2, 2, 2, 2041, 2043, 7, 104, 2, 2, 2042, 2034, 3, 2, 2, 2, 2043, 2046,
	3, 2, 2, 2, 2044, 2042, 3, 2, 2, 2, 2044, 2045, 3, 2, 2, 2, 2045, 2048,
	3, 2, 2, 2, 2046, 2044, 3, 2, 2, 2, 2047, 2049, 5, 378, 190, 2, 2048, 2047,
	3, 2, 2, 2, 2048, 2049, 3, 2, 2, 2, 2049, 2050, 3, 2, 2, 2, 2050, 2052,
	7, 59, 2, 2, 2051, 2053, 5, 398, 200, 2, 2052, 2051, 3, 2, 2, 2, 2052,
	2053, 3, 2, 2, 2, 2053, 2054, 3, 2, 2, 2, 2054, 2056, 7, 60, 2, 2, 2055,
	2057, 5, 98, 50, 2, 2056, 2055, 3, 2, 2, 2, 2056, 2057, 3, 2, 2, 2, 2057,
	2107, 3, 2, 2, 2, 2058, 2059, 5, 58, 30, 2, 2059, 2060, 7, 67, 2, 2, 2060,
	2062, 7, 33, 2, 2, 2061, 2063, 5, 42, 22, 2, 2062, 2061, 3, 2, 2, 2, 2062,
	2063, 3, 2, 2, 2, 2063, 2067, 3, 2, 2, 2, 2064, 2066, 5, 230, 116, 2, 2065,
	2064, 3, 2, 2, 2, 2066, 2069, 3, 2, 2, 2, 2067, 2065, 3, 2, 2, 2, 2067,
	2068, 3, 2, 2, 2, 2068, 2070, 3, 2, 2, 2, 2069, 2067, 3, 2, 2, 2, 2070,
	2072, 7, 104, 2, 2, 2071, 2073, 5, 378, 190, 2, 2072, 2071, 3, 2, 2, 2,
	2072, 2073, 3, 2, 2, 2, 2073, 2074, 3, 2, 2, 2, 2074, 2076, 7, 59, 2, 2,
	2075, 2077, 5, 398, 200, 2, 2076, 2075, 3, 2, 2, 2, 2076, 2077, 3, 2, 2,
	2, 2077, 2078, 3, 2, 2, 2, 2078, 2080, 7, 60, 2, 2, 2079, 2081, 5, 98,
	50, 2, 2080, 2079, 3, 2, 2, 2, 2080, 2081, 3, 2, 2, 2, 2081, 2107, 3, 2,
	2, 2, 2082, 2083, 5, 352, 177, 2, 2083, 2084, 7, 67, 2, 2, 2084, 2086,
	7, 33, 2, 2, 2085, 2087, 5, 42, 22, 2, 2086, 2085, 3, 2, 2, 2, 2086, 2087,
	3, 2, 2, 2, 2087, 2091, 3, 2, 2, 2, 2088, 2090, 5, 230, 116, 2, 2089, 2088,
	3, 2, 2, 2, 2090, 2093, 3, 2, 2, 2, 2091, 2089, 3, 2, 2, 2, 2091, 2092,
	3, 2, 2, 2, 2092, 2094, 3, 2, 2, 2, 2093, 2091, 3, 2, 2, 2, 2094, 2096,
	7, 104, 2, 2, 2095, 2097, 5, 378, 190, 2, 2096, 2095, 3, 2, 2, 2, 2096,
	2097, 3, 2, 2, 2, 2097, 2098, 3, 2, 2, 2, 2098, 2100, 7, 59, 2, 2, 2099,
	2101, 5, 398, 200, 2, 2100, 2099, 3, 2, 2, 2, 2100, 2101, 3, 2, 2, 2, 2101,
	2102, 3, 2, 2, 2, 2102, 2104, 7, 60, 2, 2, 2103, 2105, 5, 98, 50, 2, 2104,
	2103, 3, 2, 2, 2, 2104, 2105, 3, 2, 2, 2, 2105, 2107, 3, 2, 2, 2, 2106,
	2023, 3, 2, 2, 2, 2106, 2058, 3, 2, 2, 2, 2106, 2082, 3, 2, 2, 2, 2107,
	373, 3, 2, 2, 2, 2108, 2109, 7, 67, 2, 2, 2109, 2111, 7, 33, 2, 2, 2110,
	2112, 5, 42, 22, 2, 2111, 2110, 3, 2, 2, 2, 2111, 2112, 3, 2, 2, 2, 2112,
	2116, 3, 2, 2, 2, 2113, 2115, 5, 230, 116, 2, 2114, 2113, 3, 2, 2, 2, 2115,
	2118, 3, 2, 2, 2, 2116, 2114, 3, 2, 2, 2, 2116, 2117, 3, 2, 2, 2, 2117,
	2119, 3, 2, 2, 2, 2118, 2116, 3, 2, 2, 2, 2119, 2121, 7, 104, 2, 2, 2120,
	2122, 5, 378, 190, 2, 2121, 2120, 3, 2, 2, 2, 2121, 2122, 3, 2, 2, 2, 2122,
	2123, 3, 2, 2, 2, 2123, 2125, 7, 59, 2, 2, 2124, 2126, 5, 398, 200, 2,
	2125, 2124, 3, 2, 2, 2, 2125, 2126, 3, 2, 2, 2, 2126, 2127, 3, 2, 2, 2,
	2127, 2129, 7, 60, 2, 2, 2128, 2130, 5, 98, 50, 2, 2129, 2128, 3, 2, 2,
	2, 2129, 2130, 3, 2, 2, 2, 2130, 375, 3, 2, 2, 2, 2131, 2133, 7, 33, 2,
	2, 2132, 2134, 5, 42, 22, 2, 2133, 2132, 3, 2, 2, 2, 2133, 2134, 3, 2,
	2, 2, 2134, 2138, 3, 2, 2, 2, 2135, 2137, 5, 230, 116, 2, 2136, 2135, 3,
	2, 2, 2, 2137, 2140, 3, 2, 2, 2, 2138, 2136, 3, 2, 2, 2, 2138, 2139, 3,
	2, 2, 2, 2139, 2141, 3, 2, 2, 2, 2140, 2138, 3, 2, 2, 2, 2141, 2152, 7,
	104, 2, 2, 2142, 2146, 7, 67, 2, 2, 2143, 2145, 5, 230, 116, 2, 2144, 2143,
	3, 2, 2, 2, 2145, 2148, 3, 2, 2, 2, 2146, 2144, 3, 2, 2, 2, 2146, 2147,
	3, 2, 2, 2, 2147, 2149, 3, 2, 2, 2, 2148, 2146, 3, 2, 2, 2, 2149, 2151,
	7, 104, 2, 2, 2150, 2142, 3, 2, 2, 2, 2151, 2154, 3, 2, 2, 2, 2152, 2150,
	3, 2, 2, 2, 2152, 2153, 3, 2, 2, 2, 2153, 2156, 3, 2, 2, 2, 2154, 2152,
	3, 2, 2, 2, 2155, 2157, 5, 378, 190, 2, 2156, 2155, 3, 2, 2, 2, 2156, 2157,
	3, 2, 2, 2, 2157, 2158, 3, 2, 2, 2, 2158, 2160, 7, 59, 2, 2, 2159, 2161,
	5, 398, 200, 2, 2160, 2159, 3, 2, 2, 2, 2160, 2161, 3, 2, 2, 2, 2161, 2162,
	3, 2, 2, 2, 2162, 2164, 7, 60, 2, 2, 2163, 2165, 5, 98, 50, 2, 2164, 2163,
	3, 2, 2, 2, 2164, 2165, 3, 2, 2, 2, 2165, 2191, 3, 2, 2, 2, 2166, 2167,
	5, 58, 30, 2, 2167, 2168, 7, 67, 2, 2, 2168, 2170, 7, 33, 2, 2, 2169, 2171,
	5, 42, 22, 2, 2170, 2169, 3, 2, 2, 2, 2170, 2171, 3, 2, 2, 2, 2171, 2175,
	3, 2, 2, 2, 2172, 2174, 5, 230, 116, 2, 2173, 2172, 3, 2, 2, 2, 2174, 2177,
	3, 2, 2, 2, 2175, 2173, 3, 2, 2, 2, 2175, 2176, 3, 2, 2, 2, 2176, 2178,
	3, 2, 2, 2, 2177, 2175, 3, 2, 2, 2, 2178, 2180, 7, 104, 2, 2, 2179, 2181,
	5, 378, 190, 2, 2180, 2179, 3, 2, 2, 2, 2180, 2181, 3, 2, 2, 2, 2181, 2182,
	3, 2, 2, 2, 2182, 2184, 7, 59, 2, 2, 2183, 2185, 5, 398, 200, 2, 2184,
	2183, 3, 2, 2, 2, 2184, 2185, 3, 2, 2, 2, 2185, 2186, 3, 2, 2, 2, 2186,
	2188, 7, 60, 2, 2, 2187, 2189, 5, 98, 50, 2, 2188, 2187, 3, 2, 2, 2, 2188,
	2189, 3, 2, 2, 2, 2189, 2191, 3, 2, 2, 2, 2190, 2131, 3, 2, 2, 2, 2190,
	2166, 3, 2, 2, 2, 2191, 377, 3, 2, 2, 2, 2192, 2196, 5, 42, 22, 2, 2193,
	2194, 7, 70, 2, 2, 2194, 2196, 7, 69, 2, 2, 2195, 2192, 3, 2, 2, 2, 2195,
	2193, 3, 2, 2, 2, 2196, 379, 3, 2, 2, 2, 2197, 2198, 5, 352, 177, 2, 2198,
	2199, 7, 67, 2, 2, 2199, 2200, 7, 104, 2, 2, 2200, 2211, 3, 2, 2, 2, 2201,
	2202, 7, 42, 2, 2, 2202, 2203, 7, 67, 2, 2, 2203, 2211, 7, 104, 2, 2, 2204,
	2205, 5, 54, 28, 2, 2205, 2206, 7, 67, 2, 2, 2206, 2207, 7, 42, 2, 2, 2207,
	2208, 7, 67, 2, 2, 2208, 2209, 7, 104, 2, 2, 2209, 2211, 3, 2, 2, 2, 2210,
	2197, 3, 2, 2, 2, 2210, 2201, 3, 2, 2, 2, 2210, 2204, 3, 2, 2, 2, 2211,
	381, 3, 2, 2, 2, 2212, 2213, 7, 67, 2, 2, 2213, 2214, 7, 104, 2, 2, 2214,
	383, 3, 2, 2, 2, 2215, 2216, 7, 42, 2, 2, 2216, 2217, 7, 67, 2, 2, 2217,
	2225, 7, 104, 2, 2, 2218, 2219, 5, 54, 28, 2, 2219, 2220, 7, 67, 2, 2,
	2220, 2221, 7, 42, 2, 2, 2221, 2222, 7, 67, 2, 2, 2222, 2223, 7, 104, 2,
	2, 2223, 2225, 3, 2, 2, 2, 2224, 2215, 3, 2, 2, 2, 2224, 2218, 3, 2, 2,
	2, 2225, 385, 3, 2, 2, 2, 2226, 2227, 5, 58, 30, 2, 2227, 2228, 7, 63,
	2, 2, 2228, 2229, 5, 414, 208, 2, 2229, 2230, 7, 64, 2, 2, 2230, 2237,
	3, 2, 2, 2, 2231, 2232, 5, 358, 180, 2, 2232, 2233, 7, 63, 2, 2, 2233,
	2234, 5, 414, 208, 2, 2234, 2235, 7, 64, 2, 2, 2235, 2237, 3, 2, 2, 2,
	2236, 2226, 3, 2, 2, 2, 2236, 2231, 3, 2, 2, 2, 2237, 2245, 3, 2, 2, 2,
	2238, 2239, 5, 356, 179, 2, 2239, 2240, 7, 63, 2, 2, 2240, 2241, 5, 414,
	208, 2, 2241, 2242, 7, 64, 2, 2, 2242, 2244, 3, 2, 2, 2, 2243, 2238, 3,
	2, 2, 2, 2244, 2247, 3, 2, 2, 2, 2245, 2243, 3, 2, 2, 2, 2245, 2246, 3,
	2, 2, 2, 2246, 387, 3, 2, 2, 2, 2247, 2245, 3, 2, 2, 2, 2248, 2249, 5,
	364, 183, 2, 2249, 2250, 7, 63, 2, 2, 2250, 2251, 5, 414, 208, 2, 2251,
	2252, 7, 64, 2, 2, 2252, 2260, 3, 2, 2, 2, 2253, 2254, 5, 362, 182, 2,
	2254, 2255, 7, 63, 2, 2, 2255, 2256, 5, 414, 208, 2, 2256, 2257, 7, 64,
	2, 2, 2257, 2259, 3, 2, 2, 2, 2258, 2253, 3, 2, 2, 2, 2259, 2262, 3, 2,
	2, 2, 2260, 2258, 3, 2, 2, 2, 2260, 2261, 3, 2, 2, 2, 2261, 389, 3, 2,
	2, 2, 2262, 2260, 3, 2, 2, 2, 2263, 2264, 5, 58, 30, 2, 2264, 2265, 7,
	63, 2, 2, 2265, 2266, 5, 414, 208, 2, 2266, 2267, 7, 64, 2, 2, 2267, 2274,
	3, 2, 2, 2, 2268, 2269, 5, 370, 186, 2, 2269, 2270, 7, 63, 2, 2, 2270,
	2271, 5, 414, 208, 2, 2271, 2272, 7, 64, 2, 2, 2272, 2274, 3, 2, 2, 2,
	2273, 2263, 3, 2, 2, 2, 2273, 2268, 3, 2, 2, 2, 2274, 2282, 3, 2, 2, 2,
	2275, 2276, 5, 368, 185, 2, 2276, 2277, 7, 63, 2, 2, 2277, 2278, 5, 414,
	208, 2, 2278, 2279, 7, 64, 2, 2, 2279, 2281, 3, 2, 2, 2, 2280, 2275, 3,
	2, 2, 2, 2281, 2284, 3, 2, 2, 2, 2282, 2280, 3, 2, 2, 2, 2282, 2283, 3,
	2, 2, 2, 2283, 391, 3, 2, 2, 2, 2284, 2282, 3, 2, 2, 2, 2285, 2286, 5,
	60, 31, 2, 2286, 2288, 7, 59, 2, 2, 2287, 2289, 5, 398, 200, 2, 2288, 2287,
	3, 2, 2, 2, 2288, 2289, 3, 2, 2, 2, 2289, 2290, 3, 2, 2, 2, 2290, 2291,
	7, 60, 2, 2, 2291, 2354, 3, 2, 2, 2, 2292, 2293, 5, 54, 28, 2, 2293, 2295,
	7, 67, 2, 2, 2294, 2296, 5, 42, 22, 2, 2295, 2294, 3, 2, 2, 2, 2295, 2296,
	3, 2, 2, 2, 2296, 2297, 3, 2, 2, 2, 2297, 2298, 7, 104, 2, 2, 2298, 2300,
	7, 59, 2, 2, 2299, 2301, 5, 398, 200, 2, 2300, 2299, 3, 2, 2, 2, 2300,
	2301, 3, 2, 2, 2, 2301, 2302, 3, 2, 2, 2, 2302, 2303, 7, 60, 2, 2, 2303,
	2354, 3, 2, 2, 2, 2304, 2305, 5, 58, 30, 2, 2305, 2307, 7, 67, 2, 2, 2306,
	2308, 5, 42, 22, 2, 2307, 2306, 3, 2, 2, 2, 2307, 2308, 3, 2, 2, 2, 2308,
	2309, 3, 2, 2, 2, 2309, 2310, 7, 104, 2, 2, 2310, 2312, 7, 59, 2, 2, 2311,
	2313, 5, 398, 200, 2, 2312, 2311, 3, 2, 2, 2, 2312, 2313, 3, 2, 2, 2, 2313,
	2314, 3, 2, 2, 2, 2314, 2315, 7, 60, 2, 2, 2315, 2354, 3, 2, 2, 2, 2316,
	2317, 5, 352, 177, 2, 2317, 2319, 7, 67, 2, 2, 2318, 2320, 5, 42, 22, 2,
	2319, 2318, 3, 2, 2, 2, 2319, 2320, 3, 2, 2, 2, 2320, 2321, 3, 2, 2, 2,
	2321, 2322, 7, 104, 2, 2, 2322, 2324, 7, 59, 2, 2, 2323, 2325, 5, 398,
	200, 2, 2324, 2323, 3, 2, 2, 2, 2324, 2325, 3, 2, 2, 2, 2325, 2326, 3,
	2, 2, 2, 2326, 2327, 7, 60, 2, 2, 2327, 2354, 3, 2, 2, 2, 2328, 2329, 7,
	42, 2, 2, 2329, 2331, 7, 67, 2, 2, 2330, 2332, 5, 42, 22, 2, 2331, 2330,
	3, 2, 2, 2, 2331, 2332, 3, 2, 2, 2, 2332, 2333, 3, 2, 2, 2, 2333, 2334,
	7, 104, 2, 2, 2334, 2336, 7, 59, 2, 2, 2335, 2337, 5, 398, 200, 2, 2336,
	2335, 3, 2, 2, 2, 2336, 2337, 3, 2, 2, 2, 2337, 2338, 3, 2, 2, 2, 2338,
	2354, 7, 60, 2, 2, 2339, 2340, 5, 54, 28, 2, 2340, 2341, 7, 67, 2, 2, 2341,
	2342, 7, 42, 2, 2, 2342, 2344, 7, 67, 2, 2, 2343, 2345, 5, 42, 22, 2, 2344,
	2343, 3, 2, 2, 2, 2344, 2345, 3, 2, 2, 2, 2345, 2346, 3, 2, 2, 2, 2346,
	2347, 7, 104, 2, 2, 2347, 2349, 7, 59, 2, 2, 2348, 2350, 5, 398, 200, 2,
	2349, 2348, 3, 2, 2, 2, 2349, 2350, 3, 2, 2, 2, 2350, 2351, 3, 2, 2, 2,
	2351, 2352, 7, 60, 2, 2, 2352, 2354, 3, 2, 2, 2, 2353, 2285, 3, 2, 2, 2,
	2353, 2292, 3, 2, 2, 2, 2353, 2304, 3, 2, 2, 2, 2353, 2316, 3, 2, 2, 2,
	2353, 2328, 3, 2, 2, 2, 2353, 2339, 3, 2, 2, 2, 2354, 393, 3, 2, 2, 2,
	2355, 2357, 7, 67, 2, 2, 2356, 2358, 5, 42, 22, 2, 2357, 2356, 3, 2, 2,
	2, 2357, 2358, 3, 2, 2, 2, 2358, 2359, 3, 2, 2, 2, 2359, 2360, 7, 104,
	2, 2, 2360, 2362, 7, 59, 2, 2, 2361, 2363, 5, 398, 200, 2, 2362, 2361,
	3, 2, 2, 2, 2362, 2363, 3, 2, 2, 2, 2363, 2364, 3, 2, 2, 2, 2364, 2365,
	7, 60, 2, 2, 2365, 395, 3, 2, 2, 2, 2366, 2367, 5, 60, 31, 2, 2367, 2369,
	7, 59, 2, 2, 2368, 2370, 5, 398, 200, 2, 2369, 2368, 3, 2, 2, 2, 2369,
	2370, 3, 2, 2, 2, 2370, 2371, 3, 2, 2, 2, 2371, 2372, 7, 60, 2, 2, 2372,
	2423, 3, 2, 2, 2, 2373, 2374, 5, 54, 28, 2, 2374, 2376, 7, 67, 2, 2, 2375,
	2377, 5, 42, 22, 2, 2376, 2375, 3, 2, 2, 2, 2376, 2377, 3, 2, 2, 2, 2377,
	2378, 3, 2, 2, 2, 2378, 2379, 7, 104, 2, 2, 2379, 2381, 7, 59, 2, 2, 2380,
	2382, 5, 398, 200, 2, 2381, 2380, 3, 2, 2, 2, 2381, 2382, 3, 2, 2, 2, 2382,
	2383, 3, 2, 2, 2, 2383, 2384, 7, 60, 2, 2, 2384, 2423, 3, 2, 2, 2, 2385,
	2386, 5, 58, 30, 2, 2386, 2388, 7, 67, 2, 2, 2387, 2389, 5, 42, 22, 2,
	2388, 2387, 3, 2, 2, 2, 2388, 2389, 3, 2, 2, 2, 2389, 2390, 3, 2, 2, 2,
	2390, 2391, 7, 104, 2, 2, 2391, 2393, 7, 59, 2, 2, 2392, 2394, 5, 398,
	200, 2, 2393, 2392, 3, 2, 2, 2, 2393, 2394, 3, 2, 2, 2, 2394, 2395, 3,
	2, 2, 2, 2395, 2396, 7, 60, 2, 2, 2396, 2423, 3, 2, 2, 2, 2397, 2398, 7,
	42, 2, 2, 2398, 2400, 7, 67, 2, 2, 2399, 2401, 5, 42, 22, 2, 2400, 2399,
	3, 2, 2, 2, 2400, 2401, 3, 2, 2, 2, 2401, 2402, 3, 2, 2, 2, 2402, 2403,
	7, 104, 2, 2, 2403, 2405, 7, 59, 2, 2, 2404, 2406, 5, 398, 200, 2, 2405,
	2404, 3, 2, 2, 2, 2405, 2406, 3, 2, 2, 2, 2406, 2407, 3, 2, 2, 2, 2407,
	2423, 7, 60, 2, 2, 2408, 2409, 5, 54, 28, 2, 2409, 2410, 7, 67, 2, 2, 2410,
	2411, 7, 42, 2, 2, 2411, 2413, 7, 67, 2, 2, 2412, 2414, 5, 42, 22, 2, 2413,
	2412, 3, 2, 2, 2, 2413, 2414, 3, 2, 2, 2, 2414, 2415, 3, 2, 2, 2, 2415,
	2416, 7, 104, 2, 2, 2416, 2418, 7, 59, 2, 2, 2417, 2419, 5, 398, 200, 2,
	2418, 2417, 3, 2, 2, 2, 2418, 2419, 3, 2, 2, 2, 2419, 2420, 3, 2, 2, 2,
	2420, 2421, 7, 60, 2, 2, 2421, 2423, 3, 2, 2, 2, 2422, 2366, 3, 2, 2, 2,
	2422, 2373, 3, 2, 2, 2, 2422, 2385, 3, 2, 2, 2, 2422, 2397, 3, 2, 2, 2,
	2422, 2408, 3, 2, 2, 2, 2423, 397, 3, 2, 2, 2, 2424, 2429, 5, 414, 208,
	2, 2425, 2426, 7, 66, 2, 2, 2426, 2428, 5, 414, 208, 2, 2427, 2425, 3,
	2, 2, 2, 2428, 2431, 3, 2, 2, 2, 2429, 2427, 3, 2, 2, 2, 2429, 2430, 3,
	2, 2, 2, 2430, 399, 3, 2, 2, 2, 2431, 2429, 3, 2, 2, 2, 2432, 2433, 5,
	58, 30, 2, 2433, 2435, 7, 92, 2, 2, 2434, 2436, 5, 42, 22, 2, 2435, 2434,
	3, 2, 2, 2, 2435, 2436, 3, 2, 2, 2, 2436, 2437, 3, 2, 2, 2, 2437, 2438,
	7, 104, 2, 2, 2438, 2480, 3, 2, 2, 2, 2439, 2440, 5, 12, 7, 2, 2440, 2442,
	7, 92, 2, 2, 2441, 2443, 5, 42, 22, 2, 2442, 2441, 3, 2, 2, 2, 2442, 2443,
	3, 2, 2, 2, 2443, 2444, 3, 2, 2, 2, 2444, 2445, 7, 104, 2, 2, 2445, 2480,
	3, 2, 2, 2, 2446, 2447, 5, 352, 177, 2, 2447, 2449, 7, 92, 2, 2, 2448,
	2450, 5, 42, 22, 2, 2449, 2448, 3, 2, 2, 2, 2449, 2450, 3, 2, 2, 2, 2450,
	2451, 3, 2, 2, 2, 2451, 2452, 7, 104, 2, 2, 2452, 2480, 3, 2, 2, 2, 2453,
	2454, 7, 42, 2, 2, 2454, 2456, 7, 92, 2, 2, 2455, 2457, 5, 42, 22, 2, 2456,
	2455, 3, 2, 2, 2, 2456, 2457, 3, 2, 2, 2, 2457, 2458, 3, 2, 2, 2, 2458,
	2480, 7, 104, 2, 2, 2459, 2460, 5, 54, 28, 2, 2460, 2461, 7, 67, 2, 2,
	2461, 2462, 7, 42, 2, 2, 2462, 2464, 7, 92, 2, 2, 2463, 2465, 5, 42, 22,
	2, 2464, 2463, 3, 2, 2, 2, 2464, 2465, 3, 2, 2, 2, 2465, 2466, 3, 2, 2,
	2, 2466, 2467, 7, 104, 2, 2, 2467, 2480, 3, 2, 2, 2, 2468, 2469, 5, 16,
	9, 2, 2469, 2471, 7, 92, 2, 2, 2470, 2472, 5, 42, 22, 2, 2471, 2470, 3,
	2, 2, 2, 2471, 2472, 3, 2, 2, 2, 2472, 2473, 3, 2, 2, 2, 2473, 2474, 7,
	33, 2, 2, 2474, 2480, 3, 2, 2, 2, 2475, 2476, 5, 30, 16, 2, 2476, 2477,
	7, 92, 2, 2, 2477, 2478, 7, 33, 2, 2, 2478, 2480, 3, 2, 2, 2, 2479, 2432,
	3, 2, 2, 2, 2479, 2439, 3, 2, 2, 2, 2479, 2446, 3, 2, 2, 2, 2479, 2453,
	3, 2, 2, 2, 2479, 2459, 3, 2, 2, 2, 2479, 2468, 3, 2, 2, 2, 2479, 2475,
	3, 2, 2, 2, 2480, 401, 3, 2, 2, 2, 2481, 2483, 7, 92, 2, 2, 2482, 2484,
	5, 42, 22, 2, 2483, 2482, 3, 2, 2, 2, 2483, 2484, 3, 2, 2, 2, 2484, 2485,
	3, 2, 2, 2, 2485, 2486, 7, 104, 2, 2, 2486, 403, 3, 2, 2, 2, 2487, 2488,
	5, 58, 30, 2, 2488, 2490, 7, 92, 2, 2, 2489, 2491, 5, 42, 22, 2, 2490,
	2489, 3, 2, 2, 2, 2490, 2491, 3, 2, 2, 2, 2491, 2492, 3, 2, 2, 2, 2492,
	2493, 7, 104, 2, 2, 2493, 2528, 3, 2, 2, 2, 2494, 2495, 5, 12, 7, 2, 2495,
	2497, 7, 92, 2, 2, 2496, 2498, 5, 42, 22, 2, 2497, 2496, 3, 2, 2, 2, 2497,
	2498, 3, 2, 2, 2, 2498, 2499, 3, 2, 2, 2, 2499, 2500, 7, 104, 2, 2, 2500,
	2528, 3, 2, 2, 2, 2501, 2502, 7, 42, 2, 2, 2502, 2504, 7, 92, 2, 2, 2503,
	2505, 5, 42, 22, 2, 2504, 2503, 3, 2, 2, 2, 2504, 2505, 3, 2, 2, 2, 2505,
	2506, 3, 2, 2, 2, 2506, 2528, 7, 104, 2, 2, 2507, 2508, 5, 54, 28, 2, 2508,
	2509, 7, 67, 2, 2, 2509, 2510, 7, 42, 2, 2, 2510, 2512, 7, 92, 2, 2, 2511,
	2513, 5, 42, 22, 2, 2512, 2511, 3, 2, 2, 2, 2512, 2513, 3, 2, 2, 2, 2513,
	2514, 3, 2, 2, 2, 2514, 2515, 7, 104, 2, 2, 2515, 2528, 3, 2, 2, 2, 2516,
	2517, 5, 16, 9, 2, 2517, 2519, 7, 92, 2, 2, 2518, 2520, 5, 42, 22, 2, 2519,
	2518, 3, 2, 2, 2, 2519, 2520, 3, 2, 2, 2, 2520, 2521, 3, 2, 2, 2, 2521,
	2522, 7, 33, 2, 2, 2522, 2528, 3, 2, 2, 2, 2523, 2524, 5, 30, 16, 2, 2524,
	2525, 7, 92, 2, 2, 2525, 2526, 7, 33, 2, 2, 2526, 2528, 3, 2, 2, 2, 2527,
	2487, 3, 2, 2, 2, 2527, 2494, 3, 2, 2, 2, 2527, 2501, 3, 2, 2, 2, 2527,
	2507, 3, 2, 2, 2, 2527, 2516, 3, 2, 2, 2, 2527, 2523, 3, 2, 2, 2, 2528,
	405, 3, 2, 2, 2, 2529, 2530, 7, 33, 2, 2, 2530, 2531, 5, 4, 3, 2, 2531,
	2533, 5, 408, 205, 2, 2532, 2534, 5, 32, 17, 2, 2533, 2532, 3, 2, 2, 2,
	2533, 2534, 3, 2, 2, 2, 2534, 2552, 3, 2, 2, 2, 2535, 2536, 7, 33, 2, 2,
	2536, 2537, 5, 14, 8, 2, 2537, 2539, 5, 408, 205, 2, 2538, 2540, 5, 32,
	17, 2, 2539, 2538, 3, 2, 2, 2, 2539, 2540, 3, 2, 2, 2, 2540, 2552, 3, 2,
	2, 2, 2541, 2542, 7, 33, 2, 2, 2542, 2543, 5, 4, 3, 2, 2543, 2544, 5, 32,
	17, 2, 2544, 2545, 5, 248, 125, 2, 2545, 2552, 3, 2, 2, 2, 2546, 2547,
	7, 33, 2, 2, 2547, 2548, 5, 14, 8, 2, 2548, 2549, 5, 32, 17, 2, 2549, 2550,
	5, 248, 125, 2, 2550, 2552, 3, 2, 2, 2, 2551, 2529, 3, 2, 2, 2, 2551, 2535,
	3, 2, 2, 2, 2551, 2541, 3, 2, 2, 2, 2551, 2546, 3, 2, 2, 2, 2552, 407,
	3, 2, 2, 2, 2553, 2557, 5, 410, 206, 2, 2554, 2556, 5, 410, 206, 2, 2555,
	2554, 3, 2, 2, 2, 2556, 2559, 3, 2, 2, 2, 2557, 2555, 3, 2, 2, 2, 2557,
	2558, 3, 2, 2, 2, 2558, 409, 3, 2, 2, 2, 2559, 2557, 3, 2, 2, 2, 2560,
	2562, 5, 230, 116, 2, 2561, 2560, 3, 2, 2, 2, 2562, 2565, 3, 2, 2, 2, 2563,
	2561, 3, 2, 2, 2, 2563, 2564, 3, 2, 2, 2, 2564, 2566, 3, 2, 2, 2, 2565,
	2563, 3, 2, 2, 2, 2566, 2567, 7, 63, 2, 2, 2567, 2568, 5, 414, 208, 2,
	2568, 2569, 7, 64, 2, 2, 2569, 411, 3, 2, 2, 2, 2570, 2571, 5, 414, 208,
	2, 2571, 413, 3, 2, 2, 2, 2572, 2575, 5, 416, 209, 2, 2573, 2575, 5, 424,
	213, 2, 2574, 2572, 3, 2, 2, 2, 2574, 2573, 3, 2, 2, 2, 2575, 415, 3, 2,
	2, 2, 2576, 2577, 5, 418, 210, 2, 2577, 2578, 7, 91, 2, 2, 2578, 2579,
	5, 422, 212, 2, 2579, 417, 3, 2, 2, 2, 2580, 2591, 7, 104, 2, 2, 2581,
	2583, 7, 59, 2, 2, 2582, 2584, 5, 150, 76, 2, 2583, 2582, 3, 2, 2, 2, 2583,
	2584, 3, 2, 2, 2, 2584, 2585, 3, 2, 2, 2, 2585, 2591, 7, 60, 2, 2, 2586,
	2587, 7, 59, 2, 2, 2587, 2588, 5, 420, 211, 2, 2588, 2589, 7, 60, 2, 2,
	2589, 2591, 3, 2, 2, 2, 2590, 2580, 3, 2, 2, 2, 2590, 2581, 3, 2, 2, 2,
	2590, 2586, 3, 2, 2, 2, 2591, 419, 3, 2, 2, 2, 2592, 2597, 7, 104, 2, 2,
	2593, 2594, 7, 66, 2, 2, 2594, 2596, 7, 104, 2, 2, 2595, 2593, 3, 2, 2,
	2, 2596, 2599, 3, 2, 2, 2, 2597, 2595, 3, 2, 2, 2, 2597, 2598, 3, 2, 2,
	2, 2598, 421, 3, 2, 2, 2, 2599, 2597, 3, 2, 2, 2, 2600, 2603, 5, 414, 208,
	2, 2601, 2603, 5, 252, 127, 2, 2602, 2600, 3, 2, 2, 2, 2602, 2601, 3, 2,
	2, 2, 2603, 423, 3, 2, 2, 2, 2604, 2607, 5, 432, 217, 2, 2605, 2607, 5,
	426, 214, 2, 2606, 2604, 3, 2, 2, 2, 2606, 2605, 3, 2, 2, 2, 2607, 425,
	3, 2, 2, 2, 2608, 2609, 5, 428, 215, 2, 2609, 2610, 5, 430, 216, 2, 2610,
	2611, 5, 414, 208, 2, 2611, 427, 3, 2, 2, 2, 2612, 2616, 5, 58, 30, 2,
	2613, 2616, 5, 380, 191, 2, 2614, 2616, 5, 386, 194, 2, 2615, 2612, 3,
	2, 2, 2, 2615, 2613, 3, 2, 2, 2, 2615, 2614, 3, 2, 2, 2, 2616, 429, 3,
	2, 2, 2, 2617, 2618, 9, 5, 2, 2, 2618, 431, 3, 2, 2, 2, 2619, 2627, 5,
	434, 218, 2, 2620, 2621, 5, 434, 218, 2, 2621, 2622, 7, 73, 2, 2, 2622,
	2623, 5, 414, 208, 2, 2623, 2624, 7, 74, 2, 2, 2624, 2625, 5, 432, 217,
	2, 2625, 2627, 3, 2, 2, 2, 2626, 2619, 3, 2, 2, 2, 2626, 2620, 3, 2, 2,
	2, 2627, 433, 3, 2, 2, 2, 2628, 2629, 8, 218, 1, 2, 2629, 2630, 5, 436,
	219, 2, 2630, 2636, 3, 2, 2, 2, 2631, 2632, 12, 3, 2, 2, 2632, 2633, 7,
	80, 2, 2, 2633, 2635, 5, 436, 219, 2, 2634, 2631, 3, 2, 2, 2, 2635, 2638,
	3, 2, 2, 2, 2636, 2634, 3, 2, 2, 2, 2636, 2637, 3, 2, 2, 2, 2637, 435,
	3, 2, 2, 2, 2638, 2636, 3, 2, 2, 2, 2639, 2640, 8, 219, 1, 2, 2640, 2641,
	5, 438, 220, 2, 2641, 2647, 3, 2, 2, 2, 2642, 2643, 12, 3, 2, 2, 2643,
	2644, 7, 79, 2, 2, 2644, 2646, 5, 438, 220, 2, 2645, 2642, 3, 2, 2, 2,
	2646, 2649, 3, 2, 2, 2, 2647, 2645, 3, 2, 2, 2, 2647, 2648, 3, 2, 2, 2,
	2648, 437, 3, 2, 2, 2, 2649, 2647, 3, 2, 2, 2, 2650, 2651, 8, 220, 1, 2,
	2651, 2652, 5, 440, 221, 2, 2652, 2658, 3, 2, 2, 2, 2653, 2654, 12, 3,
	2, 2, 2654, 2655, 7, 88, 2, 2, 2655, 2657, 5, 440, 221, 2, 2656, 2653,
	3, 2, 2, 2, 2657, 2660, 3, 2, 2, 2, 2658, 2656, 3, 2, 2, 2, 2658, 2659,
	3, 2, 2, 2, 2659, 439, 3, 2, 2, 2, 2660, 2658, 3, 2, 2, 2, 2661, 2662,
	8, 221, 1, 2, 2662, 2663, 5, 442, 222, 2, 2663, 2669, 3, 2, 2, 2, 2664,
	2665, 12, 3, 2, 2, 2665, 2666, 7, 89, 2, 2, 2666, 2668, 5, 442, 222, 2,
	2667, 2664, 3, 2, 2, 2, 2668, 2671, 3, 2, 2, 2, 2669, 2667, 3, 2, 2, 2,
	2669, 2670, 3, 2, 2, 2, 2670, 441, 3, 2, 2, 2, 2671, 2669, 3, 2, 2, 2,
	2672, 2673, 8, 222, 1, 2, 2673, 2674, 5, 444, 223, 2, 2674, 2680, 3, 2,
	2, 2, 2675, 2676, 12, 3, 2, 2, 2676, 2677, 7, 87, 2, 2, 2677, 2679, 5,
	444, 223, 2, 2678, 2675, 3, 2, 2, 2, 2679, 2682, 3, 2, 2, 2, 2680, 2678,
	3, 2, 2, 2, 2680, 2681, 3, 2, 2, 2, 2681, 443, 3, 2, 2, 2, 2682, 2680,
	3, 2, 2, 2, 2683, 2684, 8, 223, 1, 2, 2684, 2685, 5, 446, 224, 2, 2685,
	2694, 3, 2, 2, 2, 2686, 2687, 12, 4, 2, 2, 2687, 2688, 7, 75, 2, 2, 2688,
	2693, 5, 446, 224, 2, 2689, 2690, 12, 3, 2, 2, 2690, 2691, 7, 78, 2, 2,
	2691, 2693, 5, 446, 224, 2, 2692, 2686, 3, 2, 2, 2, 2692, 2689, 3, 2, 2,
	2, 2693, 2696, 3, 2, 2, 2, 2694, 2692, 3, 2, 2, 2, 2694, 2695, 3, 2, 2,
	2, 2695, 445, 3, 2, 2, 2, 2696, 2694, 3, 2, 2, 2, 2697, 2698, 8, 224, 1,
	2, 2698, 2699, 5, 448, 225, 2, 2699, 2717, 3, 2, 2, 2, 2700, 2701, 12,
	7, 2, 2, 2701, 2702, 7, 70, 2, 2, 2702, 2716, 5, 448, 225, 2, 2703, 2704,
	12, 6, 2, 2, 2704, 2705, 7, 69, 2, 2, 2705, 2716, 5, 448, 225, 2, 2706,
	2707, 12, 5, 2, 2, 2707, 2708, 7, 76, 2, 2, 2708, 2716, 5, 448, 225, 2,
	2709, 2710, 12, 4, 2, 2, 2710, 2711, 7, 77, 2, 2, 2711, 2716, 5, 448, 225,
	2, 2712, 2713, 12, 3, 2, 2, 2713, 2714, 7, 28, 2, 2, 2714, 2716, 5, 12,
	7, 2, 2715, 2700, 3, 2, 2, 2, 2715, 2703, 3, 2, 2, 2, 2715, 2706, 3, 2,
	2, 2, 2715, 2709, 3, 2, 2, 2, 2715, 2712, 3, 2, 2, 2, 2716, 2719, 3, 2,
	2, 2, 2717, 2715, 3, 2, 2, 2, 2717, 2718, 3, 2, 2, 2, 2718, 447, 3, 2,
	2, 2, 2719, 2717, 3, 2, 2, 2, 2720, 2721, 8, 225, 1, 2, 2721, 2722, 5,
	450, 226, 2, 2722, 2738, 3, 2, 2, 2, 2723, 2724, 12, 5, 2, 2, 2724, 2725,
	7, 70, 2, 2, 2725, 2726, 7, 70, 2, 2, 2726, 2737, 5, 450, 226, 2, 2727,
	2728, 12, 4, 2, 2, 2728, 2729, 7, 69, 2, 2, 2729, 2730, 7, 69, 2, 2, 2730,
	2737, 5, 450, 226, 2, 2731, 2732, 12, 3, 2, 2, 2732, 2733, 7, 69, 2, 2,
	2733, 2734, 7, 69, 2, 2, 2734, 2735, 7, 69, 2, 2, 2735, 2737, 5, 450, 226,
	2, 2736, 2723, 3, 2, 2, 2, 2736, 2727, 3, 2, 2, 2, 2736, 2731, 3, 2, 2,
	2, 2737, 2740, 3, 2, 2, 2, 2738, 2736, 3, 2, 2, 2, 2738, 2739, 3, 2, 2,
	2, 2739, 449, 3, 2, 2, 2, 2740, 2738, 3, 2, 2, 2, 2741, 2742, 8, 226, 1,
	2, 2742, 2743, 5, 452, 227, 2, 2743, 2752, 3, 2, 2, 2, 2744, 2745, 12,
	4, 2, 2, 2745, 2746, 7, 83, 2, 2, 2746, 2751, 5, 452, 227, 2, 2747, 2748,
	12, 3, 2, 2, 2748, 2749, 7, 84, 2, 2, 2749, 2751, 5, 452, 227, 2, 2750,
	2744, 3, 2, 2, 2, 2750, 2747, 3, 2, 2, 2, 2751, 2754, 3, 2, 2, 2, 2752,
	2750, 3, 2, 2, 2, 2752, 2753, 3, 2, 2, 2, 2753, 451, 3, 2, 2, 2, 2754,
	2752, 3, 2, 2, 2, 2755, 2756, 8, 227, 1, 2, 2756, 2757, 5, 454, 228, 2,
	2757, 2769, 3, 2, 2, 2, 2758, 2759, 12, 5, 2, 2, 2759, 2760, 7, 85, 2,
	2, 2760, 2768, 5, 454, 228, 2, 2761, 2762, 12, 4, 2, 2, 2762, 2763, 7,
	86, 2, 2, 2763, 2768, 5, 454, 228, 2, 2764, 2765, 12, 3, 2, 2, 2765, 2766,
	7, 90, 2, 2, 2766, 2768, 5, 454, 228, 2, 2767, 2758, 3, 2, 2, 2, 2767,
	2761, 3, 2, 2, 2, 2767, 2764, 3, 2, 2, 2, 2768, 2771, 3, 2, 2, 2, 2769,
	2767, 3, 2, 2, 2, 2769, 2770, 3, 2, 2, 2, 2770, 453, 3, 2, 2, 2, 2771,
	2769, 3, 2, 2, 2, 2772, 2780, 5, 456, 229, 2, 2773, 2780, 5, 458, 230,
	2, 2774, 2775, 7, 83, 2, 2, 2775, 2780, 5, 454, 228, 2, 2776, 2777, 7,
	84, 2, 2, 2777, 2780, 5, 454, 228, 2, 2778, 2780, 5, 460, 231, 2, 2779,
	2772, 3, 2, 2, 2, 2779, 2773, 3, 2, 2, 2, 2779, 2774, 3, 2, 2, 2, 2779,
	2776, 3, 2, 2, 2, 2779, 2778, 3, 2, 2, 2, 2780, 455, 3, 2, 2, 2, 2781,
	2782, 7, 81, 2, 2, 2782, 2783, 5, 454, 228, 2, 2783, 457, 3, 2, 2, 2, 2784,
	2785, 7, 82, 2, 2, 2785, 2786, 5, 454, 228, 2, 2786, 459, 3, 2, 2, 2, 2787,
	2794, 5, 462, 232, 2, 2788, 2789, 7, 72, 2, 2, 2789, 2794, 5, 454, 228,
	2, 2790, 2791, 7, 71, 2, 2, 2791, 2794, 5, 454, 228, 2, 2792, 2794, 5,
	472, 237, 2, 2793, 2787, 3, 2, 2, 2, 2793, 2788, 3, 2, 2, 2, 2793, 2790,
	3, 2, 2, 2, 2793, 2792, 3, 2, 2, 2, 2794, 461, 3, 2, 2, 2, 2795, 2798,
	5, 352, 177, 2, 2796, 2798, 5, 58, 30, 2, 2797, 2795, 3, 2, 2, 2, 2797,
	2796, 3, 2, 2, 2, 2798, 2803, 3, 2, 2, 2, 2799, 2802, 5, 466, 234, 2, 2800,
	2802, 5, 470, 236, 2, 2801, 2799, 3, 2, 2, 2, 2801, 2800, 3, 2, 2, 2, 2802,
	2805, 3, 2, 2, 2, 2803, 2801, 3, 2, 2, 2, 2803, 2804, 3, 2, 2, 2, 2804,
	463, 3, 2, 2, 2, 2805, 2803, 3, 2, 2, 2, 2806, 2807, 5, 462, 232, 2, 2807,
	2808, 7, 81, 2, 2, 2808, 465, 3, 2, 2, 2, 2809, 2810, 7, 81, 2, 2, 2810,
	467, 3, 2, 2, 2, 2811, 2812, 5, 462, 232, 2, 2812, 2813, 7, 82, 2, 2, 2813,
	469, 3, 2, 2, 2, 2814, 2815, 7, 82, 2, 2, 2815, 471, 3, 2, 2, 2, 2816,
	2817, 7, 59, 2, 2, 2817, 2818, 5, 4, 3, 2, 2818, 2819, 7, 60, 2, 2, 2819,
	2820, 5, 454, 228, 2, 2820, 2844, 3, 2, 2, 2, 2821, 2822, 7, 59, 2, 2,
	2822, 2826, 5, 12, 7, 2, 2823, 2825, 5, 40, 21, 2, 2824, 2823, 3, 2, 2,
	2, 2825, 2828, 3, 2, 2, 2, 2826, 2824, 3, 2, 2, 2, 2826, 2827, 3, 2, 2,
	2, 2827, 2829, 3, 2, 2, 2, 2828, 2826, 3, 2, 2, 2, 2829, 2830, 7, 60, 2,
	2, 2830, 2831, 5, 460, 231, 2, 2831, 2844, 3, 2, 2, 2, 2832, 2833, 7, 59,
	2, 2, 2833, 2837, 5, 12, 7, 2, 2834, 2836, 5, 40, 21, 2, 2835, 2834, 3,
	2, 2, 2, 2836, 2839, 3, 2, 2, 2, 2837, 2835, 3, 2, 2, 2, 2837, 2838, 3,
	2, 2, 2, 2838, 2840, 3, 2, 2, 2, 2839, 2837, 3, 2, 2, 2, 2840, 2841, 7,
	60, 2, 2, 2841, 2842, 5, 416, 209, 2, 2842, 2844, 3, 2, 2, 2, 2843, 2816,
	3, 2, 2, 2, 2843, 2821, 3, 2, 2, 2, 2843, 2832, 3, 2, 2, 2, 2844, 473,
	3, 2, 2, 2, 324, 479, 486, 490, 494, 503, 507, 511, 513, 519, 524, 531,
	536, 538, 544, 549, 554, 559, 570, 584, 589, 597, 604, 610, 615, 626, 629,
	643, 648, 653, 658, 664, 674, 682, 692, 700, 712, 716, 721, 727, 735, 748,
	777, 781, 786, 792, 795, 798, 810, 821, 835, 842, 851, 858, 863, 878, 885,
	891, 895, 899, 903, 907, 912, 916, 920, 922, 927, 934, 939, 941, 947, 952,
	956, 975, 980, 996, 1001, 1007, 1013, 1015, 1019, 1024, 1028, 1036, 1043,
	1051, 1054, 1059, 1067, 1072, 1079, 1086, 1091, 1097, 1109, 1114, 1118,
	1128, 1133, 1141, 1144, 1149, 1157, 1160, 1165, 1170, 1175, 1180, 1187,
	1192, 1200, 1205, 1210, 1215, 1221, 1227, 1230, 1233, 1242, 1248, 1254,
	1257, 1260, 1268, 1273, 1278, 1284, 1287, 1298, 1307, 1317, 1322, 1333,
	1338, 1350, 1355, 1367, 1377, 1382, 1390, 1393, 1400, 1408, 1414, 1423,
	1433, 1437, 1440, 1449, 1463, 1466, 1475, 1480, 1487, 1492, 1500, 1512,
	1519, 1533, 1555, 1589, 1601, 1607, 1619, 1632, 1658, 1662, 1667, 1671,
	1675, 1683, 1687, 1691, 1698, 1707, 1715, 1730, 1742, 1748, 1754, 1775,
	1780, 1786, 1798, 1809, 1819, 1822, 1827, 1836, 1842, 1852, 1857, 1866,
	1889, 1899, 1921, 1928, 1936, 1944, 1955, 1978, 1988, 1999, 2021, 2025,
	2030, 2038, 2044, 2048, 2052, 2056, 2062, 2067, 2072, 2076, 2080, 2086,
	2091, 2096, 2100, 2104, 2106, 2111, 2116, 2121, 2125, 2129, 2133, 2138,
	2146, 2152, 2156, 2160, 2164, 2170, 2175, 2180, 2184, 2188, 2190, 2195,
	2210, 2224, 2236, 2245, 2260, 2273, 2282, 2288, 2295, 2300, 2307, 2312,
	2319, 2324, 2331, 2336, 2344, 2349, 2353, 2357, 2362, 2369, 2376, 2381,
	2388, 2393, 2400, 2405, 2413, 2418, 2422, 2429, 2435, 2442, 2449, 2456,
	2464, 2471, 2479, 2483, 2490, 2497, 2504, 2512, 2519, 2527, 2533, 2539,
	2551, 2557, 2563, 2574, 2583, 2590, 2597, 2602, 2606, 2615, 2626, 2636,
	2647, 2658, 2669, 2680, 2692, 2694, 2715, 2717, 2736, 2738, 2750, 2752,
	2767, 2769, 2779, 2793, 2797, 2801, 2803, 2826, 2837, 2843,
}
var literalNames = []string{
	"", "'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'", "", "", "",
	"", "", "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", "';'", "','",
	"'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", "'=='", "'<='",
	"'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", "'-'", "'*'", "'/'",
	"'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", "'-='", "'*='", "'/='",
	"'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", "'>>>='", "", "'@'",
	"'...'",
}
var symbolicNames = []string{
	"", "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", "IntegerLiteral", "FloatingPointLiteral",
	"BooleanLiteral", "CharacterLiteral", "StringLiteral", "NullLiteral", "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", "ARROW", "COLONCOLON", "ADD_ASSIGN",
	"SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN",
	"MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier",
	"AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT",
}

var ruleNames = []string{
	"literal", "primitiveType", "numericType", "integralType", "floatingPointType",
	"referenceType", "classOrInterfaceType", "classType", "classType_lf_classOrInterfaceType",
	"classType_lfno_classOrInterfaceType", "interfaceType", "interfaceType_lf_classOrInterfaceType",
	"interfaceType_lfno_classOrInterfaceType", "typeVariable", "arrayType",
	"dims", "typeParameter", "typeParameterModifier", "typeBound", "additionalBound",
	"typeArguments", "typeArgumentList", "typeArgument", "wildcard", "wildcardBounds",
	"packageName", "typeName", "packageOrTypeName", "expressionName", "methodName",
	"ambiguousName", "compilationUnit", "packageDeclaration", "packageModifier",
	"importDeclaration", "singleTypeImportDeclaration", "typeImportOnDemandDeclaration",
	"singleStaticImportDeclaration", "staticImportOnDemandDeclaration", "typeDeclaration",
	"classDeclaration", "normalClassDeclaration", "classModifier", "typeParameters",
	"typeParameterList", "superclass", "superinterfaces", "interfaceTypeList",
	"classBody", "classBodyDeclaration", "classMemberDeclaration", "fieldDeclaration",
	"fieldModifier", "variableDeclaratorList", "variableDeclarator", "variableDeclaratorId",
	"variableInitializer", "unannType", "unannPrimitiveType", "unannReferenceType",
	"unannClassOrInterfaceType", "unannClassType", "unannClassType_lf_unannClassOrInterfaceType",
	"unannClassType_lfno_unannClassOrInterfaceType", "unannInterfaceType",
	"unannInterfaceType_lf_unannClassOrInterfaceType", "unannInterfaceType_lfno_unannClassOrInterfaceType",
	"unannTypeVariable", "unannArrayType", "methodDeclaration", "methodModifier",
	"methodHeader", "result", "methodDeclarator", "formalParameterList", "formalParameters",
	"formalParameter", "variableModifier", "lastFormalParameter", "receiverParameter",
	"throws_", "exceptionTypeList", "exceptionType", "methodBody", "instanceInitializer",
	"staticInitializer", "constructorDeclaration", "constructorModifier", "constructorDeclarator",
	"simpleTypeName", "constructorBody", "explicitConstructorInvocation", "enumDeclaration",
	"enumBody", "enumConstantList", "enumConstant", "enumConstantModifier",
	"enumBodyDeclarations", "interfaceDeclaration", "normalInterfaceDeclaration",
	"interfaceModifier", "extendsInterfaces", "interfaceBody", "interfaceMemberDeclaration",
	"constantDeclaration", "constantModifier", "interfaceMethodDeclaration",
	"interfaceMethodModifier", "annotationTypeDeclaration", "annotationTypeBody",
	"annotationTypeMemberDeclaration", "annotationTypeElementDeclaration",
	"annotationTypeElementModifier", "defaultValue", "annotation", "normalAnnotation",
	"elementValuePairList", "elementValuePair", "elementValue", "elementValueArrayInitializer",
	"elementValueList", "markerAnnotation", "singleElementAnnotation", "arrayInitializer",
	"variableInitializerList", "block", "blockStatements", "blockStatement",
	"localVariableDeclarationStatement", "localVariableDeclaration", "statement",
	"statementNoShortIf", "statementWithoutTrailingSubstatement", "emptyStatement_",
	"labeledStatement", "labeledStatementNoShortIf", "expressionStatement",
	"statementExpression", "ifThenStatement", "ifThenElseStatement", "ifThenElseStatementNoShortIf",
	"assertStatement", "switchStatement", "switchBlock", "switchBlockStatementGroup",
	"switchLabels", "switchLabel", "enumConstantName", "whileStatement", "whileStatementNoShortIf",
	"doStatement", "forStatement", "forStatementNoShortIf", "basicForStatement",
	"basicForStatementNoShortIf", "forInit", "forUpdate", "statementExpressionList",
	"enhancedForStatement", "enhancedForStatementNoShortIf", "breakStatement",
	"continueStatement", "returnStatement", "throwStatement", "synchronizedStatement",
	"tryStatement", "catches", "catchClause", "catchFormalParameter", "catchType",
	"finally_", "tryWithResourcesStatement", "resourceSpecification", "resourceList",
	"resource", "primary", "primaryNoNewArray", "primaryNoNewArray_lf_arrayAccess",
	"primaryNoNewArray_lfno_arrayAccess", "primaryNoNewArray_lf_primary", "primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary",
	"primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary", "primaryNoNewArray_lfno_primary",
	"primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary", "primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary",
	"classInstanceCreationExpression", "classInstanceCreationExpression_lf_primary",
	"classInstanceCreationExpression_lfno_primary", "typeArgumentsOrDiamond",
	"fieldAccess", "fieldAccess_lf_primary", "fieldAccess_lfno_primary", "arrayAccess",
	"arrayAccess_lf_primary", "arrayAccess_lfno_primary", "methodInvocation",
	"methodInvocation_lf_primary", "methodInvocation_lfno_primary", "argumentList",
	"methodReference", "methodReference_lf_primary", "methodReference_lfno_primary",
	"arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression",
	"expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList",
	"lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator",
	"conditionalExpression", "conditionalOrExpression", "conditionalAndExpression",
	"inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression",
	"relationalExpression", "shiftExpression", "additiveExpression", "multiplicativeExpression",
	"unaryExpression", "preIncrementExpression", "preDecrementExpression",
	"unaryExpressionNotPlusMinus", "postfixExpression", "postIncrementExpression",
	"postIncrementExpression_lf_postfixExpression", "postDecrementExpression",
	"postDecrementExpression_lf_postfixExpression", "castExpression",
}

type Java8Parser struct {
	*antlr.BaseParser
}

// NewJava8Parser produces a new parser instance for the optional input antlr.TokenStream.
//
// The *Java8Parser instance produced may be reused by calling the SetInputStream method.
// The initial parser configuration is expensive to construct, and the object is not thread-safe;
// however, if used within a Golang sync.Pool, the construction cost amortizes well and the
// objects can be used in a thread-safe manner.
func NewJava8Parser(input antlr.TokenStream) *Java8Parser {
	this := new(Java8Parser)
	deserializer := antlr.NewATNDeserializer(nil)
	deserializedATN := deserializer.DeserializeFromUInt16(parserATN)
	decisionToDFA := make([]*antlr.DFA, len(deserializedATN.DecisionToState))
	for index, ds := range deserializedATN.DecisionToState {
		decisionToDFA[index] = antlr.NewDFA(ds, index)
	}
	this.BaseParser = antlr.NewBaseParser(input)

	this.Interpreter = antlr.NewParserATNSimulator(this, deserializedATN, decisionToDFA, antlr.NewPredictionContextCache())
	this.RuleNames = ruleNames
	this.LiteralNames = literalNames
	this.SymbolicNames = symbolicNames
	this.GrammarFileName = "Java8Parser.g4"

	return this
}

// Java8Parser tokens.
const (
	Java8ParserEOF                  = antlr.TokenEOF
	Java8ParserABSTRACT             = 1
	Java8ParserASSERT               = 2
	Java8ParserBOOLEAN              = 3
	Java8ParserBREAK                = 4
	Java8ParserBYTE                 = 5
	Java8ParserCASE                 = 6
	Java8ParserCATCH                = 7
	Java8ParserCHAR                 = 8
	Java8ParserCLASS                = 9
	Java8ParserCONST                = 10
	Java8ParserCONTINUE             = 11
	Java8ParserDEFAULT              = 12
	Java8ParserDO                   = 13
	Java8ParserDOUBLE               = 14
	Java8ParserELSE                 = 15
	Java8ParserENUM                 = 16
	Java8ParserEXTENDS              = 17
	Java8ParserFINAL                = 18
	Java8ParserFINALLY              = 19
	Java8ParserFLOAT                = 20
	Java8ParserFOR                  = 21
	Java8ParserIF                   = 22
	Java8ParserGOTO                 = 23
	Java8ParserIMPLEMENTS           = 24
	Java8ParserIMPORT               = 25
	Java8ParserINSTANCEOF           = 26
	Java8ParserINT                  = 27
	Java8ParserINTERFACE            = 28
	Java8ParserLONG                 = 29
	Java8ParserNATIVE               = 30
	Java8ParserNEW                  = 31
	Java8ParserPACKAGE              = 32
	Java8ParserPRIVATE              = 33
	Java8ParserPROTECTED            = 34
	Java8ParserPUBLIC               = 35
	Java8ParserRETURN               = 36
	Java8ParserSHORT                = 37
	Java8ParserSTATIC               = 38
	Java8ParserSTRICTFP             = 39
	Java8ParserSUPER                = 40
	Java8ParserSWITCH               = 41
	Java8ParserSYNCHRONIZED         = 42
	Java8ParserTHIS                 = 43
	Java8ParserTHROW                = 44
	Java8ParserTHROWS               = 45
	Java8ParserTRANSIENT            = 46
	Java8ParserTRY                  = 47
	Java8ParserVOID                 = 48
	Java8ParserVOLATILE             = 49
	Java8ParserWHILE                = 50
	Java8ParserIntegerLiteral       = 51
	Java8ParserFloatingPointLiteral = 52
	Java8ParserBooleanLiteral       = 53
	Java8ParserCharacterLiteral     = 54
	Java8ParserStringLiteral        = 55
	Java8ParserNullLiteral          = 56
	Java8ParserLPAREN               = 57
	Java8ParserRPAREN               = 58
	Java8ParserLBRACE               = 59
	Java8ParserRBRACE               = 60
	Java8ParserLBRACK               = 61
	Java8ParserRBRACK               = 62
	Java8ParserSEMI                 = 63
	Java8ParserCOMMA                = 64
	Java8ParserDOT                  = 65
	Java8ParserASSIGN               = 66
	Java8ParserGT                   = 67
	Java8ParserLT                   = 68
	Java8ParserBANG                 = 69
	Java8ParserTILDE                = 70
	Java8ParserQUESTION             = 71
	Java8ParserCOLON                = 72
	Java8ParserEQUAL                = 73
	Java8ParserLE                   = 74
	Java8ParserGE                   = 75
	Java8ParserNOTEQUAL             = 76
	Java8ParserAND                  = 77
	Java8ParserOR                   = 78
	Java8ParserINC                  = 79
	Java8ParserDEC                  = 80
	Java8ParserADD                  = 81
	Java8ParserSUB                  = 82
	Java8ParserMUL                  = 83
	Java8ParserDIV                  = 84
	Java8ParserBITAND               = 85
	Java8ParserBITOR                = 86
	Java8ParserCARET                = 87
	Java8ParserMOD                  = 88
	Java8ParserARROW                = 89
	Java8ParserCOLONCOLON           = 90
	Java8ParserADD_ASSIGN           = 91
	Java8ParserSUB_ASSIGN           = 92
	Java8ParserMUL_ASSIGN           = 93
	Java8ParserDIV_ASSIGN           = 94
	Java8ParserAND_ASSIGN           = 95
	Java8ParserOR_ASSIGN            = 96
	Java8ParserXOR_ASSIGN           = 97
	Java8ParserMOD_ASSIGN           = 98
	Java8ParserLSHIFT_ASSIGN        = 99
	Java8ParserRSHIFT_ASSIGN        = 100
	Java8ParserURSHIFT_ASSIGN       = 101
	Java8ParserIdentifier           = 102
	Java8ParserAT                   = 103
	Java8ParserELLIPSIS             = 104
	Java8ParserWS                   = 105
	Java8ParserCOMMENT              = 106
	Java8ParserLINE_COMMENT         = 107
)

// Java8Parser rules.
const (
	Java8ParserRULE_literal                                                      = 0
	Java8ParserRULE_primitiveType                                                = 1
	Java8ParserRULE_numericType                                                  = 2
	Java8ParserRULE_integralType                                                 = 3
	Java8ParserRULE_floatingPointType                                            = 4
	Java8ParserRULE_referenceType                                                = 5
	Java8ParserRULE_classOrInterfaceType                                         = 6
	Java8ParserRULE_classType                                                    = 7
	Java8ParserRULE_classType_lf_classOrInterfaceType                            = 8
	Java8ParserRULE_classType_lfno_classOrInterfaceType                          = 9
	Java8ParserRULE_interfaceType                                                = 10
	Java8ParserRULE_interfaceType_lf_classOrInterfaceType                        = 11
	Java8ParserRULE_interfaceType_lfno_classOrInterfaceType                      = 12
	Java8ParserRULE_typeVariable                                                 = 13
	Java8ParserRULE_arrayType                                                    = 14
	Java8ParserRULE_dims                                                         = 15
	Java8ParserRULE_typeParameter                                                = 16
	Java8ParserRULE_typeParameterModifier                                        = 17
	Java8ParserRULE_typeBound                                                    = 18
	Java8ParserRULE_additionalBound                                              = 19
	Java8ParserRULE_typeArguments                                                = 20
	Java8ParserRULE_typeArgumentList                                             = 21
	Java8ParserRULE_typeArgument                                                 = 22
	Java8ParserRULE_wildcard                                                     = 23
	Java8ParserRULE_wildcardBounds                                               = 24
	Java8ParserRULE_packageName                                                  = 25
	Java8ParserRULE_typeName                                                     = 26
	Java8ParserRULE_packageOrTypeName                                            = 27
	Java8ParserRULE_expressionName                                               = 28
	Java8ParserRULE_methodName                                                   = 29
	Java8ParserRULE_ambiguousName                                                = 30
	Java8ParserRULE_compilationUnit                                              = 31
	Java8ParserRULE_packageDeclaration                                           = 32
	Java8ParserRULE_packageModifier                                              = 33
	Java8ParserRULE_importDeclaration                                            = 34
	Java8ParserRULE_singleTypeImportDeclaration                                  = 35
	Java8ParserRULE_typeImportOnDemandDeclaration                                = 36
	Java8ParserRULE_singleStaticImportDeclaration                                = 37
	Java8ParserRULE_staticImportOnDemandDeclaration                              = 38
	Java8ParserRULE_typeDeclaration                                              = 39
	Java8ParserRULE_classDeclaration                                             = 40
	Java8ParserRULE_normalClassDeclaration                                       = 41
	Java8ParserRULE_classModifier                                                = 42
	Java8ParserRULE_typeParameters                                               = 43
	Java8ParserRULE_typeParameterList                                            = 44
	Java8ParserRULE_superclass                                                   = 45
	Java8ParserRULE_superinterfaces                                              = 46
	Java8ParserRULE_interfaceTypeList                                            = 47
	Java8ParserRULE_classBody                                                    = 48
	Java8ParserRULE_classBodyDeclaration                                         = 49
	Java8ParserRULE_classMemberDeclaration                                       = 50
	Java8ParserRULE_fieldDeclaration                                             = 51
	Java8ParserRULE_fieldModifier                                                = 52
	Java8ParserRULE_variableDeclaratorList                                       = 53
	Java8ParserRULE_variableDeclarator                                           = 54
	Java8ParserRULE_variableDeclaratorId                                         = 55
	Java8ParserRULE_variableInitializer                                          = 56
	Java8ParserRULE_unannType                                                    = 57
	Java8ParserRULE_unannPrimitiveType                                           = 58
	Java8ParserRULE_unannReferenceType                                           = 59
	Java8ParserRULE_unannClassOrInterfaceType                                    = 60
	Java8ParserRULE_unannClassType                                               = 61
	Java8ParserRULE_unannClassType_lf_unannClassOrInterfaceType                  = 62
	Java8ParserRULE_unannClassType_lfno_unannClassOrInterfaceType                = 63
	Java8ParserRULE_unannInterfaceType                                           = 64
	Java8ParserRULE_unannInterfaceType_lf_unannClassOrInterfaceType              = 65
	Java8ParserRULE_unannInterfaceType_lfno_unannClassOrInterfaceType            = 66
	Java8ParserRULE_unannTypeVariable                                            = 67
	Java8ParserRULE_unannArrayType                                               = 68
	Java8ParserRULE_methodDeclaration                                            = 69
	Java8ParserRULE_methodModifier                                               = 70
	Java8ParserRULE_methodHeader                                                 = 71
	Java8ParserRULE_result                                                       = 72
	Java8ParserRULE_methodDeclarator                                             = 73
	Java8ParserRULE_formalParameterList                                          = 74
	Java8ParserRULE_formalParameters                                             = 75
	Java8ParserRULE_formalParameter                                              = 76
	Java8ParserRULE_variableModifier                                             = 77
	Java8ParserRULE_lastFormalParameter                                          = 78
	Java8ParserRULE_receiverParameter                                            = 79
	Java8ParserRULE_throws_                                                      = 80
	Java8ParserRULE_exceptionTypeList                                            = 81
	Java8ParserRULE_exceptionType                                                = 82
	Java8ParserRULE_methodBody                                                   = 83
	Java8ParserRULE_instanceInitializer                                          = 84
	Java8ParserRULE_staticInitializer                                            = 85
	Java8ParserRULE_constructorDeclaration                                       = 86
	Java8ParserRULE_constructorModifier                                          = 87
	Java8ParserRULE_constructorDeclarator                                        = 88
	Java8ParserRULE_simpleTypeName                                               = 89
	Java8ParserRULE_constructorBody                                              = 90
	Java8ParserRULE_explicitConstructorInvocation                                = 91
	Java8ParserRULE_enumDeclaration                                              = 92
	Java8ParserRULE_enumBody                                                     = 93
	Java8ParserRULE_enumConstantList                                             = 94
	Java8ParserRULE_enumConstant                                                 = 95
	Java8ParserRULE_enumConstantModifier                                         = 96
	Java8ParserRULE_enumBodyDeclarations                                         = 97
	Java8ParserRULE_interfaceDeclaration                                         = 98
	Java8ParserRULE_normalInterfaceDeclaration                                   = 99
	Java8ParserRULE_interfaceModifier                                            = 100
	Java8ParserRULE_extendsInterfaces                                            = 101
	Java8ParserRULE_interfaceBody                                                = 102
	Java8ParserRULE_interfaceMemberDeclaration                                   = 103
	Java8ParserRULE_constantDeclaration                                          = 104
	Java8ParserRULE_constantModifier                                             = 105
	Java8ParserRULE_interfaceMethodDeclaration                                   = 106
	Java8ParserRULE_interfaceMethodModifier                                      = 107
	Java8ParserRULE_annotationTypeDeclaration                                    = 108
	Java8ParserRULE_annotationTypeBody                                           = 109
	Java8ParserRULE_annotationTypeMemberDeclaration                              = 110
	Java8ParserRULE_annotationTypeElementDeclaration                             = 111
	Java8ParserRULE_annotationTypeElementModifier                                = 112
	Java8ParserRULE_defaultValue                                                 = 113
	Java8ParserRULE_annotation                                                   = 114
	Java8ParserRULE_normalAnnotation                                             = 115
	Java8ParserRULE_elementValuePairList                                         = 116
	Java8ParserRULE_elementValuePair                                             = 117
	Java8ParserRULE_elementValue                                                 = 118
	Java8ParserRULE_elementValueArrayInitializer                                 = 119
	Java8ParserRULE_elementValueList                                             = 120
	Java8ParserRULE_markerAnnotation                                             = 121
	Java8ParserRULE_singleElementAnnotation                                      = 122
	Java8ParserRULE_arrayInitializer                                             = 123
	Java8ParserRULE_variableInitializerList                                      = 124
	Java8ParserRULE_block                                                        = 125
	Java8ParserRULE_blockStatements                                              = 126
	Java8ParserRULE_blockStatement                                               = 127
	Java8ParserRULE_localVariableDeclarationStatement                            = 128
	Java8ParserRULE_localVariableDeclaration                                     = 129
	Java8ParserRULE_statement                                                    = 130
	Java8ParserRULE_statementNoShortIf                                           = 131
	Java8ParserRULE_statementWithoutTrailingSubstatement                         = 132
	Java8ParserRULE_emptyStatement_                                              = 133
	Java8ParserRULE_labeledStatement                                             = 134
	Java8ParserRULE_labeledStatementNoShortIf                                    = 135
	Java8ParserRULE_expressionStatement                                          = 136
	Java8ParserRULE_statementExpression                                          = 137
	Java8ParserRULE_ifThenStatement                                              = 138
	Java8ParserRULE_ifThenElseStatement                                          = 139
	Java8ParserRULE_ifThenElseStatementNoShortIf                                 = 140
	Java8ParserRULE_assertStatement                                              = 141
	Java8ParserRULE_switchStatement                                              = 142
	Java8ParserRULE_switchBlock                                                  = 143
	Java8ParserRULE_switchBlockStatementGroup                                    = 144
	Java8ParserRULE_switchLabels                                                 = 145
	Java8ParserRULE_switchLabel                                                  = 146
	Java8ParserRULE_enumConstantName                                             = 147
	Java8ParserRULE_whileStatement                                               = 148
	Java8ParserRULE_whileStatementNoShortIf                                      = 149
	Java8ParserRULE_doStatement                                                  = 150
	Java8ParserRULE_forStatement                                                 = 151
	Java8ParserRULE_forStatementNoShortIf                                        = 152
	Java8ParserRULE_basicForStatement                                            = 153
	Java8ParserRULE_basicForStatementNoShortIf                                   = 154
	Java8ParserRULE_forInit                                                      = 155
	Java8ParserRULE_forUpdate                                                    = 156
	Java8ParserRULE_statementExpressionList                                      = 157
	Java8ParserRULE_enhancedForStatement                                         = 158
	Java8ParserRULE_enhancedForStatementNoShortIf                                = 159
	Java8ParserRULE_breakStatement                                               = 160
	Java8ParserRULE_continueStatement                                            = 161
	Java8ParserRULE_returnStatement                                              = 162
	Java8ParserRULE_throwStatement                                               = 163
	Java8ParserRULE_synchronizedStatement                                        = 164
	Java8ParserRULE_tryStatement                                                 = 165
	Java8ParserRULE_catches                                                      = 166
	Java8ParserRULE_catchClause                                                  = 167
	Java8ParserRULE_catchFormalParameter                                         = 168
	Java8ParserRULE_catchType                                                    = 169
	Java8ParserRULE_finally_                                                     = 170
	Java8ParserRULE_tryWithResourcesStatement                                    = 171
	Java8ParserRULE_resourceSpecification                                        = 172
	Java8ParserRULE_resourceList                                                 = 173
	Java8ParserRULE_resource                                                     = 174
	Java8ParserRULE_primary                                                      = 175
	Java8ParserRULE_primaryNoNewArray                                            = 176
	Java8ParserRULE_primaryNoNewArray_lf_arrayAccess                             = 177
	Java8ParserRULE_primaryNoNewArray_lfno_arrayAccess                           = 178
	Java8ParserRULE_primaryNoNewArray_lf_primary                                 = 179
	Java8ParserRULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary       = 180
	Java8ParserRULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary     = 181
	Java8ParserRULE_primaryNoNewArray_lfno_primary                               = 182
	Java8ParserRULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary   = 183
	Java8ParserRULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary = 184
	Java8ParserRULE_classInstanceCreationExpression                              = 185
	Java8ParserRULE_classInstanceCreationExpression_lf_primary                   = 186
	Java8ParserRULE_classInstanceCreationExpression_lfno_primary                 = 187
	Java8ParserRULE_typeArgumentsOrDiamond                                       = 188
	Java8ParserRULE_fieldAccess                                                  = 189
	Java8ParserRULE_fieldAccess_lf_primary                                       = 190
	Java8ParserRULE_fieldAccess_lfno_primary                                     = 191
	Java8ParserRULE_arrayAccess                                                  = 192
	Java8ParserRULE_arrayAccess_lf_primary                                       = 193
	Java8ParserRULE_arrayAccess_lfno_primary                                     = 194
	Java8ParserRULE_methodInvocation                                             = 195
	Java8ParserRULE_methodInvocation_lf_primary                                  = 196
	Java8ParserRULE_methodInvocation_lfno_primary                                = 197
	Java8ParserRULE_argumentList                                                 = 198
	Java8ParserRULE_methodReference                                              = 199
	Java8ParserRULE_methodReference_lf_primary                                   = 200
	Java8ParserRULE_methodReference_lfno_primary                                 = 201
	Java8ParserRULE_arrayCreationExpression                                      = 202
	Java8ParserRULE_dimExprs                                                     = 203
	Java8ParserRULE_dimExpr                                                      = 204
	Java8ParserRULE_constantExpression                                           = 205
	Java8ParserRULE_expression                                                   = 206
	Java8ParserRULE_lambdaExpression                                             = 207
	Java8ParserRULE_lambdaParameters                                             = 208
	Java8ParserRULE_inferredFormalParameterList                                  = 209
	Java8ParserRULE_lambdaBody                                                   = 210
	Java8ParserRULE_assignmentExpression                                         = 211
	Java8ParserRULE_assignment                                                   = 212
	Java8ParserRULE_leftHandSide                                                 = 213
	Java8ParserRULE_assignmentOperator                                           = 214
	Java8ParserRULE_conditionalExpression                                        = 215
	Java8ParserRULE_conditionalOrExpression                                      = 216
	Java8ParserRULE_conditionalAndExpression                                     = 217
	Java8ParserRULE_inclusiveOrExpression                                        = 218
	Java8ParserRULE_exclusiveOrExpression                                        = 219
	Java8ParserRULE_andExpression                                                = 220
	Java8ParserRULE_equalityExpression                                           = 221
	Java8ParserRULE_relationalExpression                                         = 222
	Java8ParserRULE_shiftExpression                                              = 223
	Java8ParserRULE_additiveExpression                                           = 224
	Java8ParserRULE_multiplicativeExpression                                     = 225
	Java8ParserRULE_unaryExpression                                              = 226
	Java8ParserRULE_preIncrementExpression                                       = 227
	Java8ParserRULE_preDecrementExpression                                       = 228
	Java8ParserRULE_unaryExpressionNotPlusMinus                                  = 229
	Java8ParserRULE_postfixExpression                                            = 230
	Java8ParserRULE_postIncrementExpression                                      = 231
	Java8ParserRULE_postIncrementExpression_lf_postfixExpression                 = 232
	Java8ParserRULE_postDecrementExpression                                      = 233
	Java8ParserRULE_postDecrementExpression_lf_postfixExpression                 = 234
	Java8ParserRULE_castExpression                                               = 235
)

// ILiteralContext is an interface to support dynamic dispatch.
type ILiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLiteralContext differentiates from other interfaces.
	IsLiteralContext()
}

type LiteralContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLiteralContext() *LiteralContext {
	var p = new(LiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_literal
	return p
}

func (*LiteralContext) IsLiteralContext() {}

func NewLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralContext {
	var p = new(LiteralContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_literal

	return p
}

func (s *LiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *LiteralContext) IntegerLiteral() antlr.TerminalNode {
	return s.GetToken(Java8ParserIntegerLiteral, 0)
}

func (s *LiteralContext) FloatingPointLiteral() antlr.TerminalNode {
	return s.GetToken(Java8ParserFloatingPointLiteral, 0)
}

func (s *LiteralContext) BooleanLiteral() antlr.TerminalNode {
	return s.GetToken(Java8ParserBooleanLiteral, 0)
}

func (s *LiteralContext) CharacterLiteral() antlr.TerminalNode {
	return s.GetToken(Java8ParserCharacterLiteral, 0)
}

func (s *LiteralContext) StringLiteral() antlr.TerminalNode {
	return s.GetToken(Java8ParserStringLiteral, 0)
}

func (s *LiteralContext) NullLiteral() antlr.TerminalNode {
	return s.GetToken(Java8ParserNullLiteral, 0)
}

func (s *LiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterLiteral(s)
	}
}

func (s *LiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitLiteral(s)
	}
}

func (p *Java8Parser) Literal() (localctx ILiteralContext) {
	this := p
	_ = this

	localctx = NewLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 0, Java8ParserRULE_literal)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(472)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-51)&-(0x1f+1)) == 0 && ((1<<uint((_la-51)))&((1<<(Java8ParserIntegerLiteral-51))|(1<<(Java8ParserFloatingPointLiteral-51))|(1<<(Java8ParserBooleanLiteral-51))|(1<<(Java8ParserCharacterLiteral-51))|(1<<(Java8ParserStringLiteral-51))|(1<<(Java8ParserNullLiteral-51)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IPrimitiveTypeContext is an interface to support dynamic dispatch.
type IPrimitiveTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimitiveTypeContext differentiates from other interfaces.
	IsPrimitiveTypeContext()
}

type PrimitiveTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimitiveTypeContext() *PrimitiveTypeContext {
	var p = new(PrimitiveTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_primitiveType
	return p
}

func (*PrimitiveTypeContext) IsPrimitiveTypeContext() {}

func NewPrimitiveTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimitiveTypeContext {
	var p = new(PrimitiveTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_primitiveType

	return p
}

func (s *PrimitiveTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *PrimitiveTypeContext) NumericType() INumericTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INumericTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INumericTypeContext)
}

func (s *PrimitiveTypeContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *PrimitiveTypeContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *PrimitiveTypeContext) BOOLEAN() antlr.TerminalNode {
	return s.GetToken(Java8ParserBOOLEAN, 0)
}

func (s *PrimitiveTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimitiveTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimitiveTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPrimitiveType(s)
	}
}

func (s *PrimitiveTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPrimitiveType(s)
	}
}

func (p *Java8Parser) PrimitiveType() (localctx IPrimitiveTypeContext) {
	this := p
	_ = this

	localctx = NewPrimitiveTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 2, Java8ParserRULE_primitiveType)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(488)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 2, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(477)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserAT {
			{
				p.SetState(474)
				p.Annotation()
			}

			p.SetState(479)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(480)
			p.NumericType()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(484)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserAT {
			{
				p.SetState(481)
				p.Annotation()
			}

			p.SetState(486)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(487)
			p.Match(Java8ParserBOOLEAN)
		}

	}

	return localctx
}

// INumericTypeContext is an interface to support dynamic dispatch.
type INumericTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNumericTypeContext differentiates from other interfaces.
	IsNumericTypeContext()
}

type NumericTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNumericTypeContext() *NumericTypeContext {
	var p = new(NumericTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_numericType
	return p
}

func (*NumericTypeContext) IsNumericTypeContext() {}

func NewNumericTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumericTypeContext {
	var p = new(NumericTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_numericType

	return p
}

func (s *NumericTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *NumericTypeContext) IntegralType() IIntegralTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIntegralTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIntegralTypeContext)
}

func (s *NumericTypeContext) FloatingPointType() IFloatingPointTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFloatingPointTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFloatingPointTypeContext)
}

func (s *NumericTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NumericTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *NumericTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterNumericType(s)
	}
}

func (s *NumericTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitNumericType(s)
	}
}

func (p *Java8Parser) NumericType() (localctx INumericTypeContext) {
	this := p
	_ = this

	localctx = NewNumericTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, Java8ParserRULE_numericType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(492)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserBYTE, Java8ParserCHAR, Java8ParserINT, Java8ParserLONG, Java8ParserSHORT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(490)
			p.IntegralType()
		}

	case Java8ParserDOUBLE, Java8ParserFLOAT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(491)
			p.FloatingPointType()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IIntegralTypeContext is an interface to support dynamic dispatch.
type IIntegralTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIntegralTypeContext differentiates from other interfaces.
	IsIntegralTypeContext()
}

type IntegralTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIntegralTypeContext() *IntegralTypeContext {
	var p = new(IntegralTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_integralType
	return p
}

func (*IntegralTypeContext) IsIntegralTypeContext() {}

func NewIntegralTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntegralTypeContext {
	var p = new(IntegralTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_integralType

	return p
}

func (s *IntegralTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *IntegralTypeContext) BYTE() antlr.TerminalNode {
	return s.GetToken(Java8ParserBYTE, 0)
}

func (s *IntegralTypeContext) SHORT() antlr.TerminalNode {
	return s.GetToken(Java8ParserSHORT, 0)
}

func (s *IntegralTypeContext) INT() antlr.TerminalNode {
	return s.GetToken(Java8ParserINT, 0)
}

func (s *IntegralTypeContext) LONG() antlr.TerminalNode {
	return s.GetToken(Java8ParserLONG, 0)
}

func (s *IntegralTypeContext) CHAR() antlr.TerminalNode {
	return s.GetToken(Java8ParserCHAR, 0)
}

func (s *IntegralTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IntegralTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IntegralTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterIntegralType(s)
	}
}

func (s *IntegralTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitIntegralType(s)
	}
}

func (p *Java8Parser) IntegralType() (localctx IIntegralTypeContext) {
	this := p
	_ = this

	localctx = NewIntegralTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 6, Java8ParserRULE_integralType)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(494)
		_la = p.GetTokenStream().LA(1)

		if !((((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserINT)|(1<<Java8ParserLONG))) != 0) || _la == Java8ParserSHORT) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IFloatingPointTypeContext is an interface to support dynamic dispatch.
type IFloatingPointTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFloatingPointTypeContext differentiates from other interfaces.
	IsFloatingPointTypeContext()
}

type FloatingPointTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFloatingPointTypeContext() *FloatingPointTypeContext {
	var p = new(FloatingPointTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_floatingPointType
	return p
}

func (*FloatingPointTypeContext) IsFloatingPointTypeContext() {}

func NewFloatingPointTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FloatingPointTypeContext {
	var p = new(FloatingPointTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_floatingPointType

	return p
}

func (s *FloatingPointTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *FloatingPointTypeContext) FLOAT() antlr.TerminalNode {
	return s.GetToken(Java8ParserFLOAT, 0)
}

func (s *FloatingPointTypeContext) DOUBLE() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOUBLE, 0)
}

func (s *FloatingPointTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FloatingPointTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FloatingPointTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterFloatingPointType(s)
	}
}

func (s *FloatingPointTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitFloatingPointType(s)
	}
}

func (p *Java8Parser) FloatingPointType() (localctx IFloatingPointTypeContext) {
	this := p
	_ = this

	localctx = NewFloatingPointTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 8, Java8ParserRULE_floatingPointType)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(496)
		_la = p.GetTokenStream().LA(1)

		if !(_la == Java8ParserDOUBLE || _la == Java8ParserFLOAT) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IReferenceTypeContext is an interface to support dynamic dispatch.
type IReferenceTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsReferenceTypeContext differentiates from other interfaces.
	IsReferenceTypeContext()
}

type ReferenceTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReferenceTypeContext() *ReferenceTypeContext {
	var p = new(ReferenceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_referenceType
	return p
}

func (*ReferenceTypeContext) IsReferenceTypeContext() {}

func NewReferenceTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReferenceTypeContext {
	var p = new(ReferenceTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_referenceType

	return p
}

func (s *ReferenceTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *ReferenceTypeContext) ClassOrInterfaceType() IClassOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassOrInterfaceTypeContext)
}

func (s *ReferenceTypeContext) TypeVariable() ITypeVariableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeVariableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeVariableContext)
}

func (s *ReferenceTypeContext) ArrayType() IArrayTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayTypeContext)
}

func (s *ReferenceTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ReferenceTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ReferenceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterReferenceType(s)
	}
}

func (s *ReferenceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitReferenceType(s)
	}
}

func (p *Java8Parser) ReferenceType() (localctx IReferenceTypeContext) {
	this := p
	_ = this

	localctx = NewReferenceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 10, Java8ParserRULE_referenceType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(501)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 4, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(498)
			p.ClassOrInterfaceType()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(499)
			p.TypeVariable()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(500)
			p.ArrayType()
		}

	}

	return localctx
}

// IClassOrInterfaceTypeContext is an interface to support dynamic dispatch.
type IClassOrInterfaceTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassOrInterfaceTypeContext differentiates from other interfaces.
	IsClassOrInterfaceTypeContext()
}

type ClassOrInterfaceTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassOrInterfaceTypeContext() *ClassOrInterfaceTypeContext {
	var p = new(ClassOrInterfaceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_classOrInterfaceType
	return p
}

func (*ClassOrInterfaceTypeContext) IsClassOrInterfaceTypeContext() {}

func NewClassOrInterfaceTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassOrInterfaceTypeContext {
	var p = new(ClassOrInterfaceTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_classOrInterfaceType

	return p
}

func (s *ClassOrInterfaceTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassOrInterfaceTypeContext) ClassType_lfno_classOrInterfaceType() IClassType_lfno_classOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassType_lfno_classOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassType_lfno_classOrInterfaceTypeContext)
}

func (s *ClassOrInterfaceTypeContext) InterfaceType_lfno_classOrInterfaceType() IInterfaceType_lfno_classOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceType_lfno_classOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceType_lfno_classOrInterfaceTypeContext)
}

func (s *ClassOrInterfaceTypeContext) AllClassType_lf_classOrInterfaceType() []IClassType_lf_classOrInterfaceTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IClassType_lf_classOrInterfaceTypeContext)(nil)).Elem())
	var tst = make([]IClassType_lf_classOrInterfaceTypeContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IClassType_lf_classOrInterfaceTypeContext)
		}
	}

	return tst
}

func (s *ClassOrInterfaceTypeContext) ClassType_lf_classOrInterfaceType(i int) IClassType_lf_classOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassType_lf_classOrInterfaceTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IClassType_lf_classOrInterfaceTypeContext)
}

func (s *ClassOrInterfaceTypeContext) AllInterfaceType_lf_classOrInterfaceType() []IInterfaceType_lf_classOrInterfaceTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInterfaceType_lf_classOrInterfaceTypeContext)(nil)).Elem())
	var tst = make([]IInterfaceType_lf_classOrInterfaceTypeContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IInterfaceType_lf_classOrInterfaceTypeContext)
		}
	}

	return tst
}

func (s *ClassOrInterfaceTypeContext) InterfaceType_lf_classOrInterfaceType(i int) IInterfaceType_lf_classOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceType_lf_classOrInterfaceTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInterfaceType_lf_classOrInterfaceTypeContext)
}

func (s *ClassOrInterfaceTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassOrInterfaceTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassOrInterfaceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterClassOrInterfaceType(s)
	}
}

func (s *ClassOrInterfaceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitClassOrInterfaceType(s)
	}
}

func (p *Java8Parser) ClassOrInterfaceType() (localctx IClassOrInterfaceTypeContext) {
	this := p
	_ = this

	localctx = NewClassOrInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 12, Java8ParserRULE_classOrInterfaceType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(505)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 5, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(503)
			p.ClassType_lfno_classOrInterfaceType()
		}

	case 2:
		{
			p.SetState(504)
			p.InterfaceType_lfno_classOrInterfaceType()
		}

	}
	p.SetState(511)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(509)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 6, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(507)
					p.ClassType_lf_classOrInterfaceType()
				}

			case 2:
				{
					p.SetState(508)
					p.InterfaceType_lf_classOrInterfaceType()
				}

			}

		}
		p.SetState(513)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext())
	}

	return localctx
}

// IClassTypeContext is an interface to support dynamic dispatch.
type IClassTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassTypeContext differentiates from other interfaces.
	IsClassTypeContext()
}

type ClassTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassTypeContext() *ClassTypeContext {
	var p = new(ClassTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_classType
	return p
}

func (*ClassTypeContext) IsClassTypeContext() {}

func NewClassTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassTypeContext {
	var p = new(ClassTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_classType

	return p
}

func (s *ClassTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassTypeContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *ClassTypeContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *ClassTypeContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *ClassTypeContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *ClassTypeContext) ClassOrInterfaceType() IClassOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassOrInterfaceTypeContext)
}

func (s *ClassTypeContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *ClassTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterClassType(s)
	}
}

func (s *ClassTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitClassType(s)
	}
}

func (p *Java8Parser) ClassType() (localctx IClassTypeContext) {
	this := p
	_ = this

	localctx = NewClassTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 14, Java8ParserRULE_classType)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(536)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 12, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(517)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserAT {
			{
				p.SetState(514)
				p.Annotation()
			}

			p.SetState(519)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(520)
			p.Match(Java8ParserIdentifier)
		}
		p.SetState(522)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(521)
				p.TypeArguments()
			}

		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(524)
			p.ClassOrInterfaceType()
		}
		{
			p.SetState(525)
			p.Match(Java8ParserDOT)
		}
		p.SetState(529)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserAT {
			{
				p.SetState(526)
				p.Annotation()
			}

			p.SetState(531)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(532)
			p.Match(Java8ParserIdentifier)
		}
		p.SetState(534)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(533)
				p.TypeArguments()
			}

		}

	}

	return localctx
}

// IClassType_lf_classOrInterfaceTypeContext is an interface to support dynamic dispatch.
type IClassType_lf_classOrInterfaceTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassType_lf_classOrInterfaceTypeContext differentiates from other interfaces.
	IsClassType_lf_classOrInterfaceTypeContext()
}

type ClassType_lf_classOrInterfaceTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassType_lf_classOrInterfaceTypeContext() *ClassType_lf_classOrInterfaceTypeContext {
	var p = new(ClassType_lf_classOrInterfaceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_classType_lf_classOrInterfaceType
	return p
}

func (*ClassType_lf_classOrInterfaceTypeContext) IsClassType_lf_classOrInterfaceTypeContext() {}

func NewClassType_lf_classOrInterfaceTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassType_lf_classOrInterfaceTypeContext {
	var p = new(ClassType_lf_classOrInterfaceTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_classType_lf_classOrInterfaceType

	return p
}

func (s *ClassType_lf_classOrInterfaceTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassType_lf_classOrInterfaceTypeContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *ClassType_lf_classOrInterfaceTypeContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *ClassType_lf_classOrInterfaceTypeContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *ClassType_lf_classOrInterfaceTypeContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *ClassType_lf_classOrInterfaceTypeContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *ClassType_lf_classOrInterfaceTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassType_lf_classOrInterfaceTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassType_lf_classOrInterfaceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterClassType_lf_classOrInterfaceType(s)
	}
}

func (s *ClassType_lf_classOrInterfaceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitClassType_lf_classOrInterfaceType(s)
	}
}

func (p *Java8Parser) ClassType_lf_classOrInterfaceType() (localctx IClassType_lf_classOrInterfaceTypeContext) {
	this := p
	_ = this

	localctx = NewClassType_lf_classOrInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, Java8ParserRULE_classType_lf_classOrInterfaceType)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(538)
		p.Match(Java8ParserDOT)
	}
	p.SetState(542)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserAT {
		{
			p.SetState(539)
			p.Annotation()
		}

		p.SetState(544)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(545)
		p.Match(Java8ParserIdentifier)
	}
	p.SetState(547)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 14, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(546)
			p.TypeArguments()
		}

	}

	return localctx
}

// IClassType_lfno_classOrInterfaceTypeContext is an interface to support dynamic dispatch.
type IClassType_lfno_classOrInterfaceTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassType_lfno_classOrInterfaceTypeContext differentiates from other interfaces.
	IsClassType_lfno_classOrInterfaceTypeContext()
}

type ClassType_lfno_classOrInterfaceTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassType_lfno_classOrInterfaceTypeContext() *ClassType_lfno_classOrInterfaceTypeContext {
	var p = new(ClassType_lfno_classOrInterfaceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_classType_lfno_classOrInterfaceType
	return p
}

func (*ClassType_lfno_classOrInterfaceTypeContext) IsClassType_lfno_classOrInterfaceTypeContext() {}

func NewClassType_lfno_classOrInterfaceTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassType_lfno_classOrInterfaceTypeContext {
	var p = new(ClassType_lfno_classOrInterfaceTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_classType_lfno_classOrInterfaceType

	return p
}

func (s *ClassType_lfno_classOrInterfaceTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassType_lfno_classOrInterfaceTypeContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *ClassType_lfno_classOrInterfaceTypeContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *ClassType_lfno_classOrInterfaceTypeContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *ClassType_lfno_classOrInterfaceTypeContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *ClassType_lfno_classOrInterfaceTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassType_lfno_classOrInterfaceTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassType_lfno_classOrInterfaceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterClassType_lfno_classOrInterfaceType(s)
	}
}

func (s *ClassType_lfno_classOrInterfaceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitClassType_lfno_classOrInterfaceType(s)
	}
}

func (p *Java8Parser) ClassType_lfno_classOrInterfaceType() (localctx IClassType_lfno_classOrInterfaceTypeContext) {
	this := p
	_ = this

	localctx = NewClassType_lfno_classOrInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, Java8ParserRULE_classType_lfno_classOrInterfaceType)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(552)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserAT {
		{
			p.SetState(549)
			p.Annotation()
		}

		p.SetState(554)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(555)
		p.Match(Java8ParserIdentifier)
	}
	p.SetState(557)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 16, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(556)
			p.TypeArguments()
		}

	}

	return localctx
}

// IInterfaceTypeContext is an interface to support dynamic dispatch.
type IInterfaceTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInterfaceTypeContext differentiates from other interfaces.
	IsInterfaceTypeContext()
}

type InterfaceTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInterfaceTypeContext() *InterfaceTypeContext {
	var p = new(InterfaceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_interfaceType
	return p
}

func (*InterfaceTypeContext) IsInterfaceTypeContext() {}

func NewInterfaceTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InterfaceTypeContext {
	var p = new(InterfaceTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_interfaceType

	return p
}

func (s *InterfaceTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *InterfaceTypeContext) ClassType() IClassTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassTypeContext)
}

func (s *InterfaceTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InterfaceTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InterfaceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterInterfaceType(s)
	}
}

func (s *InterfaceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitInterfaceType(s)
	}
}

func (p *Java8Parser) InterfaceType() (localctx IInterfaceTypeContext) {
	this := p
	_ = this

	localctx = NewInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 20, Java8ParserRULE_interfaceType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(559)
		p.ClassType()
	}

	return localctx
}

// IInterfaceType_lf_classOrInterfaceTypeContext is an interface to support dynamic dispatch.
type IInterfaceType_lf_classOrInterfaceTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInterfaceType_lf_classOrInterfaceTypeContext differentiates from other interfaces.
	IsInterfaceType_lf_classOrInterfaceTypeContext()
}

type InterfaceType_lf_classOrInterfaceTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInterfaceType_lf_classOrInterfaceTypeContext() *InterfaceType_lf_classOrInterfaceTypeContext {
	var p = new(InterfaceType_lf_classOrInterfaceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_interfaceType_lf_classOrInterfaceType
	return p
}

func (*InterfaceType_lf_classOrInterfaceTypeContext) IsInterfaceType_lf_classOrInterfaceTypeContext() {
}

func NewInterfaceType_lf_classOrInterfaceTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InterfaceType_lf_classOrInterfaceTypeContext {
	var p = new(InterfaceType_lf_classOrInterfaceTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_interfaceType_lf_classOrInterfaceType

	return p
}

func (s *InterfaceType_lf_classOrInterfaceTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *InterfaceType_lf_classOrInterfaceTypeContext) ClassType_lf_classOrInterfaceType() IClassType_lf_classOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassType_lf_classOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassType_lf_classOrInterfaceTypeContext)
}

func (s *InterfaceType_lf_classOrInterfaceTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InterfaceType_lf_classOrInterfaceTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InterfaceType_lf_classOrInterfaceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterInterfaceType_lf_classOrInterfaceType(s)
	}
}

func (s *InterfaceType_lf_classOrInterfaceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitInterfaceType_lf_classOrInterfaceType(s)
	}
}

func (p *Java8Parser) InterfaceType_lf_classOrInterfaceType() (localctx IInterfaceType_lf_classOrInterfaceTypeContext) {
	this := p
	_ = this

	localctx = NewInterfaceType_lf_classOrInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 22, Java8ParserRULE_interfaceType_lf_classOrInterfaceType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(561)
		p.ClassType_lf_classOrInterfaceType()
	}

	return localctx
}

// IInterfaceType_lfno_classOrInterfaceTypeContext is an interface to support dynamic dispatch.
type IInterfaceType_lfno_classOrInterfaceTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInterfaceType_lfno_classOrInterfaceTypeContext differentiates from other interfaces.
	IsInterfaceType_lfno_classOrInterfaceTypeContext()
}

type InterfaceType_lfno_classOrInterfaceTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInterfaceType_lfno_classOrInterfaceTypeContext() *InterfaceType_lfno_classOrInterfaceTypeContext {
	var p = new(InterfaceType_lfno_classOrInterfaceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_interfaceType_lfno_classOrInterfaceType
	return p
}

func (*InterfaceType_lfno_classOrInterfaceTypeContext) IsInterfaceType_lfno_classOrInterfaceTypeContext() {
}

func NewInterfaceType_lfno_classOrInterfaceTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InterfaceType_lfno_classOrInterfaceTypeContext {
	var p = new(InterfaceType_lfno_classOrInterfaceTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_interfaceType_lfno_classOrInterfaceType

	return p
}

func (s *InterfaceType_lfno_classOrInterfaceTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *InterfaceType_lfno_classOrInterfaceTypeContext) ClassType_lfno_classOrInterfaceType() IClassType_lfno_classOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassType_lfno_classOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassType_lfno_classOrInterfaceTypeContext)
}

func (s *InterfaceType_lfno_classOrInterfaceTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InterfaceType_lfno_classOrInterfaceTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InterfaceType_lfno_classOrInterfaceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterInterfaceType_lfno_classOrInterfaceType(s)
	}
}

func (s *InterfaceType_lfno_classOrInterfaceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitInterfaceType_lfno_classOrInterfaceType(s)
	}
}

func (p *Java8Parser) InterfaceType_lfno_classOrInterfaceType() (localctx IInterfaceType_lfno_classOrInterfaceTypeContext) {
	this := p
	_ = this

	localctx = NewInterfaceType_lfno_classOrInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, Java8ParserRULE_interfaceType_lfno_classOrInterfaceType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(563)
		p.ClassType_lfno_classOrInterfaceType()
	}

	return localctx
}

// ITypeVariableContext is an interface to support dynamic dispatch.
type ITypeVariableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeVariableContext differentiates from other interfaces.
	IsTypeVariableContext()
}

type TypeVariableContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeVariableContext() *TypeVariableContext {
	var p = new(TypeVariableContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_typeVariable
	return p
}

func (*TypeVariableContext) IsTypeVariableContext() {}

func NewTypeVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeVariableContext {
	var p = new(TypeVariableContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_typeVariable

	return p
}

func (s *TypeVariableContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeVariableContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *TypeVariableContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *TypeVariableContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *TypeVariableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeVariableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeVariableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTypeVariable(s)
	}
}

func (s *TypeVariableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTypeVariable(s)
	}
}

func (p *Java8Parser) TypeVariable() (localctx ITypeVariableContext) {
	this := p
	_ = this

	localctx = NewTypeVariableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 26, Java8ParserRULE_typeVariable)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(568)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserAT {
		{
			p.SetState(565)
			p.Annotation()
		}

		p.SetState(570)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(571)
		p.Match(Java8ParserIdentifier)
	}

	return localctx
}

// IArrayTypeContext is an interface to support dynamic dispatch.
type IArrayTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArrayTypeContext differentiates from other interfaces.
	IsArrayTypeContext()
}

type ArrayTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArrayTypeContext() *ArrayTypeContext {
	var p = new(ArrayTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_arrayType
	return p
}

func (*ArrayTypeContext) IsArrayTypeContext() {}

func NewArrayTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayTypeContext {
	var p = new(ArrayTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_arrayType

	return p
}

func (s *ArrayTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *ArrayTypeContext) PrimitiveType() IPrimitiveTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimitiveTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimitiveTypeContext)
}

func (s *ArrayTypeContext) Dims() IDimsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDimsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDimsContext)
}

func (s *ArrayTypeContext) ClassOrInterfaceType() IClassOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassOrInterfaceTypeContext)
}

func (s *ArrayTypeContext) TypeVariable() ITypeVariableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeVariableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeVariableContext)
}

func (s *ArrayTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArrayTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArrayTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterArrayType(s)
	}
}

func (s *ArrayTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitArrayType(s)
	}
}

func (p *Java8Parser) ArrayType() (localctx IArrayTypeContext) {
	this := p
	_ = this

	localctx = NewArrayTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, Java8ParserRULE_arrayType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(582)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 18, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(573)
			p.PrimitiveType()
		}
		{
			p.SetState(574)
			p.Dims()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(576)
			p.ClassOrInterfaceType()
		}
		{
			p.SetState(577)
			p.Dims()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(579)
			p.TypeVariable()
		}
		{
			p.SetState(580)
			p.Dims()
		}

	}

	return localctx
}

// IDimsContext is an interface to support dynamic dispatch.
type IDimsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDimsContext differentiates from other interfaces.
	IsDimsContext()
}

type DimsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDimsContext() *DimsContext {
	var p = new(DimsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_dims
	return p
}

func (*DimsContext) IsDimsContext() {}

func NewDimsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DimsContext {
	var p = new(DimsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_dims

	return p
}

func (s *DimsContext) GetParser() antlr.Parser { return s.parser }

func (s *DimsContext) AllLBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserLBRACK)
}

func (s *DimsContext) LBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACK, i)
}

func (s *DimsContext) AllRBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserRBRACK)
}

func (s *DimsContext) RBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACK, i)
}

func (s *DimsContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *DimsContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *DimsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DimsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DimsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterDims(s)
	}
}

func (s *DimsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitDims(s)
	}
}

func (p *Java8Parser) Dims() (localctx IDimsContext) {
	this := p
	_ = this

	localctx = NewDimsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, Java8ParserRULE_dims)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(587)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserAT {
		{
			p.SetState(584)
			p.Annotation()
		}

		p.SetState(589)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(590)
		p.Match(Java8ParserLBRACK)
	}
	{
		p.SetState(591)
		p.Match(Java8ParserRBRACK)
	}
	p.SetState(602)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 21, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(595)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == Java8ParserAT {
				{
					p.SetState(592)
					p.Annotation()
				}

				p.SetState(597)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(598)
				p.Match(Java8ParserLBRACK)
			}
			{
				p.SetState(599)
				p.Match(Java8ParserRBRACK)
			}

		}
		p.SetState(604)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 21, p.GetParserRuleContext())
	}

	return localctx
}

// ITypeParameterContext is an interface to support dynamic dispatch.
type ITypeParameterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeParameterContext differentiates from other interfaces.
	IsTypeParameterContext()
}

type TypeParameterContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeParameterContext() *TypeParameterContext {
	var p = new(TypeParameterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_typeParameter
	return p
}

func (*TypeParameterContext) IsTypeParameterContext() {}

func NewTypeParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeParameterContext {
	var p = new(TypeParameterContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_typeParameter

	return p
}

func (s *TypeParameterContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeParameterContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *TypeParameterContext) AllTypeParameterModifier() []ITypeParameterModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeParameterModifierContext)(nil)).Elem())
	var tst = make([]ITypeParameterModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ITypeParameterModifierContext)
		}
	}

	return tst
}

func (s *TypeParameterContext) TypeParameterModifier(i int) ITypeParameterModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParameterModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeParameterModifierContext)
}

func (s *TypeParameterContext) TypeBound() ITypeBoundContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeBoundContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeBoundContext)
}

func (s *TypeParameterContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeParameterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTypeParameter(s)
	}
}

func (s *TypeParameterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTypeParameter(s)
	}
}

func (p *Java8Parser) TypeParameter() (localctx ITypeParameterContext) {
	this := p
	_ = this

	localctx = NewTypeParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, Java8ParserRULE_typeParameter)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(608)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserAT {
		{
			p.SetState(605)
			p.TypeParameterModifier()
		}

		p.SetState(610)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(611)
		p.Match(Java8ParserIdentifier)
	}
	p.SetState(613)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserEXTENDS {
		{
			p.SetState(612)
			p.TypeBound()
		}

	}

	return localctx
}

// ITypeParameterModifierContext is an interface to support dynamic dispatch.
type ITypeParameterModifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeParameterModifierContext differentiates from other interfaces.
	IsTypeParameterModifierContext()
}

type TypeParameterModifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeParameterModifierContext() *TypeParameterModifierContext {
	var p = new(TypeParameterModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_typeParameterModifier
	return p
}

func (*TypeParameterModifierContext) IsTypeParameterModifierContext() {}

func NewTypeParameterModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeParameterModifierContext {
	var p = new(TypeParameterModifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_typeParameterModifier

	return p
}

func (s *TypeParameterModifierContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeParameterModifierContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *TypeParameterModifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeParameterModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeParameterModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTypeParameterModifier(s)
	}
}

func (s *TypeParameterModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTypeParameterModifier(s)
	}
}

func (p *Java8Parser) TypeParameterModifier() (localctx ITypeParameterModifierContext) {
	this := p
	_ = this

	localctx = NewTypeParameterModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 34, Java8ParserRULE_typeParameterModifier)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(615)
		p.Annotation()
	}

	return localctx
}

// ITypeBoundContext is an interface to support dynamic dispatch.
type ITypeBoundContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeBoundContext differentiates from other interfaces.
	IsTypeBoundContext()
}

type TypeBoundContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeBoundContext() *TypeBoundContext {
	var p = new(TypeBoundContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_typeBound
	return p
}

func (*TypeBoundContext) IsTypeBoundContext() {}

func NewTypeBoundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeBoundContext {
	var p = new(TypeBoundContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_typeBound

	return p
}

func (s *TypeBoundContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeBoundContext) EXTENDS() antlr.TerminalNode {
	return s.GetToken(Java8ParserEXTENDS, 0)
}

func (s *TypeBoundContext) TypeVariable() ITypeVariableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeVariableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeVariableContext)
}

func (s *TypeBoundContext) ClassOrInterfaceType() IClassOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassOrInterfaceTypeContext)
}

func (s *TypeBoundContext) AllAdditionalBound() []IAdditionalBoundContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAdditionalBoundContext)(nil)).Elem())
	var tst = make([]IAdditionalBoundContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAdditionalBoundContext)
		}
	}

	return tst
}

func (s *TypeBoundContext) AdditionalBound(i int) IAdditionalBoundContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAdditionalBoundContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAdditionalBoundContext)
}

func (s *TypeBoundContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeBoundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeBoundContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTypeBound(s)
	}
}

func (s *TypeBoundContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTypeBound(s)
	}
}

func (p *Java8Parser) TypeBound() (localctx ITypeBoundContext) {
	this := p
	_ = this

	localctx = NewTypeBoundContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, Java8ParserRULE_typeBound)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(627)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 25, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(617)
			p.Match(Java8ParserEXTENDS)
		}
		{
			p.SetState(618)
			p.TypeVariable()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(619)
			p.Match(Java8ParserEXTENDS)
		}
		{
			p.SetState(620)
			p.ClassOrInterfaceType()
		}
		p.SetState(624)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserBITAND {
			{
				p.SetState(621)
				p.AdditionalBound()
			}

			p.SetState(626)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}

	return localctx
}

// IAdditionalBoundContext is an interface to support dynamic dispatch.
type IAdditionalBoundContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAdditionalBoundContext differentiates from other interfaces.
	IsAdditionalBoundContext()
}

type AdditionalBoundContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAdditionalBoundContext() *AdditionalBoundContext {
	var p = new(AdditionalBoundContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_additionalBound
	return p
}

func (*AdditionalBoundContext) IsAdditionalBoundContext() {}

func NewAdditionalBoundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AdditionalBoundContext {
	var p = new(AdditionalBoundContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_additionalBound

	return p
}

func (s *AdditionalBoundContext) GetParser() antlr.Parser { return s.parser }

func (s *AdditionalBoundContext) BITAND() antlr.TerminalNode {
	return s.GetToken(Java8ParserBITAND, 0)
}

func (s *AdditionalBoundContext) InterfaceType() IInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceTypeContext)
}

func (s *AdditionalBoundContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AdditionalBoundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AdditionalBoundContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterAdditionalBound(s)
	}
}

func (s *AdditionalBoundContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitAdditionalBound(s)
	}
}

func (p *Java8Parser) AdditionalBound() (localctx IAdditionalBoundContext) {
	this := p
	_ = this

	localctx = NewAdditionalBoundContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, Java8ParserRULE_additionalBound)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(629)
		p.Match(Java8ParserBITAND)
	}
	{
		p.SetState(630)
		p.InterfaceType()
	}

	return localctx
}

// ITypeArgumentsContext is an interface to support dynamic dispatch.
type ITypeArgumentsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeArgumentsContext differentiates from other interfaces.
	IsTypeArgumentsContext()
}

type TypeArgumentsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeArgumentsContext() *TypeArgumentsContext {
	var p = new(TypeArgumentsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_typeArguments
	return p
}

func (*TypeArgumentsContext) IsTypeArgumentsContext() {}

func NewTypeArgumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeArgumentsContext {
	var p = new(TypeArgumentsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_typeArguments

	return p
}

func (s *TypeArgumentsContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeArgumentsContext) LT() antlr.TerminalNode {
	return s.GetToken(Java8ParserLT, 0)
}

func (s *TypeArgumentsContext) TypeArgumentList() ITypeArgumentListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentListContext)
}

func (s *TypeArgumentsContext) GT() antlr.TerminalNode {
	return s.GetToken(Java8ParserGT, 0)
}

func (s *TypeArgumentsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeArgumentsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeArgumentsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTypeArguments(s)
	}
}

func (s *TypeArgumentsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTypeArguments(s)
	}
}

func (p *Java8Parser) TypeArguments() (localctx ITypeArgumentsContext) {
	this := p
	_ = this

	localctx = NewTypeArgumentsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, Java8ParserRULE_typeArguments)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(632)
		p.Match(Java8ParserLT)
	}
	{
		p.SetState(633)
		p.TypeArgumentList()
	}
	{
		p.SetState(634)
		p.Match(Java8ParserGT)
	}

	return localctx
}

// ITypeArgumentListContext is an interface to support dynamic dispatch.
type ITypeArgumentListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeArgumentListContext differentiates from other interfaces.
	IsTypeArgumentListContext()
}

type TypeArgumentListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeArgumentListContext() *TypeArgumentListContext {
	var p = new(TypeArgumentListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_typeArgumentList
	return p
}

func (*TypeArgumentListContext) IsTypeArgumentListContext() {}

func NewTypeArgumentListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeArgumentListContext {
	var p = new(TypeArgumentListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_typeArgumentList

	return p
}

func (s *TypeArgumentListContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeArgumentListContext) AllTypeArgument() []ITypeArgumentContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeArgumentContext)(nil)).Elem())
	var tst = make([]ITypeArgumentContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ITypeArgumentContext)
		}
	}

	return tst
}

func (s *TypeArgumentListContext) TypeArgument(i int) ITypeArgumentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentContext)
}

func (s *TypeArgumentListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserCOMMA)
}

func (s *TypeArgumentListContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, i)
}

func (s *TypeArgumentListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeArgumentListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeArgumentListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTypeArgumentList(s)
	}
}

func (s *TypeArgumentListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTypeArgumentList(s)
	}
}

func (p *Java8Parser) TypeArgumentList() (localctx ITypeArgumentListContext) {
	this := p
	_ = this

	localctx = NewTypeArgumentListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, Java8ParserRULE_typeArgumentList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(636)
		p.TypeArgument()
	}
	p.SetState(641)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserCOMMA {
		{
			p.SetState(637)
			p.Match(Java8ParserCOMMA)
		}
		{
			p.SetState(638)
			p.TypeArgument()
		}

		p.SetState(643)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// ITypeArgumentContext is an interface to support dynamic dispatch.
type ITypeArgumentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeArgumentContext differentiates from other interfaces.
	IsTypeArgumentContext()
}

type TypeArgumentContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeArgumentContext() *TypeArgumentContext {
	var p = new(TypeArgumentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_typeArgument
	return p
}

func (*TypeArgumentContext) IsTypeArgumentContext() {}

func NewTypeArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeArgumentContext {
	var p = new(TypeArgumentContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_typeArgument

	return p
}

func (s *TypeArgumentContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeArgumentContext) ReferenceType() IReferenceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReferenceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReferenceTypeContext)
}

func (s *TypeArgumentContext) Wildcard() IWildcardContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWildcardContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWildcardContext)
}

func (s *TypeArgumentContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeArgumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeArgumentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTypeArgument(s)
	}
}

func (s *TypeArgumentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTypeArgument(s)
	}
}

func (p *Java8Parser) TypeArgument() (localctx ITypeArgumentContext) {
	this := p
	_ = this

	localctx = NewTypeArgumentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, Java8ParserRULE_typeArgument)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(646)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 27, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(644)
			p.ReferenceType()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(645)
			p.Wildcard()
		}

	}

	return localctx
}

// IWildcardContext is an interface to support dynamic dispatch.
type IWildcardContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWildcardContext differentiates from other interfaces.
	IsWildcardContext()
}

type WildcardContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWildcardContext() *WildcardContext {
	var p = new(WildcardContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_wildcard
	return p
}

func (*WildcardContext) IsWildcardContext() {}

func NewWildcardContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WildcardContext {
	var p = new(WildcardContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_wildcard

	return p
}

func (s *WildcardContext) GetParser() antlr.Parser { return s.parser }

func (s *WildcardContext) QUESTION() antlr.TerminalNode {
	return s.GetToken(Java8ParserQUESTION, 0)
}

func (s *WildcardContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *WildcardContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *WildcardContext) WildcardBounds() IWildcardBoundsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWildcardBoundsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWildcardBoundsContext)
}

func (s *WildcardContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *WildcardContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *WildcardContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterWildcard(s)
	}
}

func (s *WildcardContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitWildcard(s)
	}
}

func (p *Java8Parser) Wildcard() (localctx IWildcardContext) {
	this := p
	_ = this

	localctx = NewWildcardContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, Java8ParserRULE_wildcard)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(651)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserAT {
		{
			p.SetState(648)
			p.Annotation()
		}

		p.SetState(653)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(654)
		p.Match(Java8ParserQUESTION)
	}
	p.SetState(656)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserEXTENDS || _la == Java8ParserSUPER {
		{
			p.SetState(655)
			p.WildcardBounds()
		}

	}

	return localctx
}

// IWildcardBoundsContext is an interface to support dynamic dispatch.
type IWildcardBoundsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWildcardBoundsContext differentiates from other interfaces.
	IsWildcardBoundsContext()
}

type WildcardBoundsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWildcardBoundsContext() *WildcardBoundsContext {
	var p = new(WildcardBoundsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_wildcardBounds
	return p
}

func (*WildcardBoundsContext) IsWildcardBoundsContext() {}

func NewWildcardBoundsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WildcardBoundsContext {
	var p = new(WildcardBoundsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_wildcardBounds

	return p
}

func (s *WildcardBoundsContext) GetParser() antlr.Parser { return s.parser }

func (s *WildcardBoundsContext) EXTENDS() antlr.TerminalNode {
	return s.GetToken(Java8ParserEXTENDS, 0)
}

func (s *WildcardBoundsContext) ReferenceType() IReferenceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReferenceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReferenceTypeContext)
}

func (s *WildcardBoundsContext) SUPER() antlr.TerminalNode {
	return s.GetToken(Java8ParserSUPER, 0)
}

func (s *WildcardBoundsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *WildcardBoundsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *WildcardBoundsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterWildcardBounds(s)
	}
}

func (s *WildcardBoundsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitWildcardBounds(s)
	}
}

func (p *Java8Parser) WildcardBounds() (localctx IWildcardBoundsContext) {
	this := p
	_ = this

	localctx = NewWildcardBoundsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, Java8ParserRULE_wildcardBounds)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(662)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserEXTENDS:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(658)
			p.Match(Java8ParserEXTENDS)
		}
		{
			p.SetState(659)
			p.ReferenceType()
		}

	case Java8ParserSUPER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(660)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(661)
			p.ReferenceType()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IPackageNameContext is an interface to support dynamic dispatch.
type IPackageNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPackageNameContext differentiates from other interfaces.
	IsPackageNameContext()
}

type PackageNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPackageNameContext() *PackageNameContext {
	var p = new(PackageNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_packageName
	return p
}

func (*PackageNameContext) IsPackageNameContext() {}

func NewPackageNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PackageNameContext {
	var p = new(PackageNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_packageName

	return p
}

func (s *PackageNameContext) GetParser() antlr.Parser { return s.parser }

func (s *PackageNameContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *PackageNameContext) PackageName() IPackageNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPackageNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPackageNameContext)
}

func (s *PackageNameContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *PackageNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PackageNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PackageNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPackageName(s)
	}
}

func (s *PackageNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPackageName(s)
	}
}

func (p *Java8Parser) PackageName() (localctx IPackageNameContext) {
	return p.packageName(0)
}

func (p *Java8Parser) packageName(_p int) (localctx IPackageNameContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewPackageNameContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IPackageNameContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 50
	p.EnterRecursionRule(localctx, 50, Java8ParserRULE_packageName, _p)

	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(665)
		p.Match(Java8ParserIdentifier)
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(672)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 31, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			localctx = NewPackageNameContext(p, _parentctx, _parentState)
			p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_packageName)
			p.SetState(667)

			if !(p.Precpred(p.GetParserRuleContext(), 1)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
			}
			{
				p.SetState(668)
				p.Match(Java8ParserDOT)
			}
			{
				p.SetState(669)
				p.Match(Java8ParserIdentifier)
			}

		}
		p.SetState(674)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 31, p.GetParserRuleContext())
	}

	return localctx
}

// ITypeNameContext is an interface to support dynamic dispatch.
type ITypeNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeNameContext differentiates from other interfaces.
	IsTypeNameContext()
}

type TypeNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeNameContext() *TypeNameContext {
	var p = new(TypeNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_typeName
	return p
}

func (*TypeNameContext) IsTypeNameContext() {}

func NewTypeNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeNameContext {
	var p = new(TypeNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_typeName

	return p
}

func (s *TypeNameContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeNameContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *TypeNameContext) PackageOrTypeName() IPackageOrTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPackageOrTypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPackageOrTypeNameContext)
}

func (s *TypeNameContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *TypeNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTypeName(s)
	}
}

func (s *TypeNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTypeName(s)
	}
}

func (p *Java8Parser) TypeName() (localctx ITypeNameContext) {
	this := p
	_ = this

	localctx = NewTypeNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, Java8ParserRULE_typeName)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(680)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 32, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(675)
			p.Match(Java8ParserIdentifier)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(676)
			p.packageOrTypeName(0)
		}
		{
			p.SetState(677)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(678)
			p.Match(Java8ParserIdentifier)
		}

	}

	return localctx
}

// IPackageOrTypeNameContext is an interface to support dynamic dispatch.
type IPackageOrTypeNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPackageOrTypeNameContext differentiates from other interfaces.
	IsPackageOrTypeNameContext()
}

type PackageOrTypeNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPackageOrTypeNameContext() *PackageOrTypeNameContext {
	var p = new(PackageOrTypeNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_packageOrTypeName
	return p
}

func (*PackageOrTypeNameContext) IsPackageOrTypeNameContext() {}

func NewPackageOrTypeNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PackageOrTypeNameContext {
	var p = new(PackageOrTypeNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_packageOrTypeName

	return p
}

func (s *PackageOrTypeNameContext) GetParser() antlr.Parser { return s.parser }

func (s *PackageOrTypeNameContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *PackageOrTypeNameContext) PackageOrTypeName() IPackageOrTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPackageOrTypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPackageOrTypeNameContext)
}

func (s *PackageOrTypeNameContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *PackageOrTypeNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PackageOrTypeNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PackageOrTypeNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPackageOrTypeName(s)
	}
}

func (s *PackageOrTypeNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPackageOrTypeName(s)
	}
}

func (p *Java8Parser) PackageOrTypeName() (localctx IPackageOrTypeNameContext) {
	return p.packageOrTypeName(0)
}

func (p *Java8Parser) packageOrTypeName(_p int) (localctx IPackageOrTypeNameContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewPackageOrTypeNameContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IPackageOrTypeNameContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 54
	p.EnterRecursionRule(localctx, 54, Java8ParserRULE_packageOrTypeName, _p)

	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(683)
		p.Match(Java8ParserIdentifier)
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(690)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 33, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			localctx = NewPackageOrTypeNameContext(p, _parentctx, _parentState)
			p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_packageOrTypeName)
			p.SetState(685)

			if !(p.Precpred(p.GetParserRuleContext(), 1)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
			}
			{
				p.SetState(686)
				p.Match(Java8ParserDOT)
			}
			{
				p.SetState(687)
				p.Match(Java8ParserIdentifier)
			}

		}
		p.SetState(692)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 33, p.GetParserRuleContext())
	}

	return localctx
}

// IExpressionNameContext is an interface to support dynamic dispatch.
type IExpressionNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExpressionNameContext differentiates from other interfaces.
	IsExpressionNameContext()
}

type ExpressionNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExpressionNameContext() *ExpressionNameContext {
	var p = new(ExpressionNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_expressionName
	return p
}

func (*ExpressionNameContext) IsExpressionNameContext() {}

func NewExpressionNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionNameContext {
	var p = new(ExpressionNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_expressionName

	return p
}

func (s *ExpressionNameContext) GetParser() antlr.Parser { return s.parser }

func (s *ExpressionNameContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *ExpressionNameContext) AmbiguousName() IAmbiguousNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousNameContext)
}

func (s *ExpressionNameContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *ExpressionNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExpressionNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExpressionNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterExpressionName(s)
	}
}

func (s *ExpressionNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitExpressionName(s)
	}
}

func (p *Java8Parser) ExpressionName() (localctx IExpressionNameContext) {
	this := p
	_ = this

	localctx = NewExpressionNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, Java8ParserRULE_expressionName)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(698)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 34, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(693)
			p.Match(Java8ParserIdentifier)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(694)
			p.ambiguousName(0)
		}
		{
			p.SetState(695)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(696)
			p.Match(Java8ParserIdentifier)
		}

	}

	return localctx
}

// IMethodNameContext is an interface to support dynamic dispatch.
type IMethodNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMethodNameContext differentiates from other interfaces.
	IsMethodNameContext()
}

type MethodNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMethodNameContext() *MethodNameContext {
	var p = new(MethodNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_methodName
	return p
}

func (*MethodNameContext) IsMethodNameContext() {}

func NewMethodNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodNameContext {
	var p = new(MethodNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_methodName

	return p
}

func (s *MethodNameContext) GetParser() antlr.Parser { return s.parser }

func (s *MethodNameContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *MethodNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MethodNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MethodNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterMethodName(s)
	}
}

func (s *MethodNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitMethodName(s)
	}
}

func (p *Java8Parser) MethodName() (localctx IMethodNameContext) {
	this := p
	_ = this

	localctx = NewMethodNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, Java8ParserRULE_methodName)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(700)
		p.Match(Java8ParserIdentifier)
	}

	return localctx
}

// IAmbiguousNameContext is an interface to support dynamic dispatch.
type IAmbiguousNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAmbiguousNameContext differentiates from other interfaces.
	IsAmbiguousNameContext()
}

type AmbiguousNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAmbiguousNameContext() *AmbiguousNameContext {
	var p = new(AmbiguousNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_ambiguousName
	return p
}

func (*AmbiguousNameContext) IsAmbiguousNameContext() {}

func NewAmbiguousNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AmbiguousNameContext {
	var p = new(AmbiguousNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_ambiguousName

	return p
}

func (s *AmbiguousNameContext) GetParser() antlr.Parser { return s.parser }

func (s *AmbiguousNameContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *AmbiguousNameContext) AmbiguousName() IAmbiguousNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAmbiguousNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAmbiguousNameContext)
}

func (s *AmbiguousNameContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *AmbiguousNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AmbiguousNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AmbiguousNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterAmbiguousName(s)
	}
}

func (s *AmbiguousNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitAmbiguousName(s)
	}
}

func (p *Java8Parser) AmbiguousName() (localctx IAmbiguousNameContext) {
	return p.ambiguousName(0)
}

func (p *Java8Parser) ambiguousName(_p int) (localctx IAmbiguousNameContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewAmbiguousNameContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IAmbiguousNameContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 60
	p.EnterRecursionRule(localctx, 60, Java8ParserRULE_ambiguousName, _p)

	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(703)
		p.Match(Java8ParserIdentifier)
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(710)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 35, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			localctx = NewAmbiguousNameContext(p, _parentctx, _parentState)
			p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_ambiguousName)
			p.SetState(705)

			if !(p.Precpred(p.GetParserRuleContext(), 1)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
			}
			{
				p.SetState(706)
				p.Match(Java8ParserDOT)
			}
			{
				p.SetState(707)
				p.Match(Java8ParserIdentifier)
			}

		}
		p.SetState(712)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 35, p.GetParserRuleContext())
	}

	return localctx
}

// ICompilationUnitContext is an interface to support dynamic dispatch.
type ICompilationUnitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCompilationUnitContext differentiates from other interfaces.
	IsCompilationUnitContext()
}

type CompilationUnitContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCompilationUnitContext() *CompilationUnitContext {
	var p = new(CompilationUnitContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_compilationUnit
	return p
}

func (*CompilationUnitContext) IsCompilationUnitContext() {}

func NewCompilationUnitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompilationUnitContext {
	var p = new(CompilationUnitContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_compilationUnit

	return p
}

func (s *CompilationUnitContext) GetParser() antlr.Parser { return s.parser }

func (s *CompilationUnitContext) EOF() antlr.TerminalNode {
	return s.GetToken(Java8ParserEOF, 0)
}

func (s *CompilationUnitContext) PackageDeclaration() IPackageDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPackageDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPackageDeclarationContext)
}

func (s *CompilationUnitContext) AllImportDeclaration() []IImportDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IImportDeclarationContext)(nil)).Elem())
	var tst = make([]IImportDeclarationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IImportDeclarationContext)
		}
	}

	return tst
}

func (s *CompilationUnitContext) ImportDeclaration(i int) IImportDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IImportDeclarationContext)
}

func (s *CompilationUnitContext) AllTypeDeclaration() []ITypeDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeDeclarationContext)(nil)).Elem())
	var tst = make([]ITypeDeclarationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ITypeDeclarationContext)
		}
	}

	return tst
}

func (s *CompilationUnitContext) TypeDeclaration(i int) ITypeDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeDeclarationContext)
}

func (s *CompilationUnitContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CompilationUnitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CompilationUnitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterCompilationUnit(s)
	}
}

func (s *CompilationUnitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitCompilationUnit(s)
	}
}

func (p *Java8Parser) CompilationUnit() (localctx ICompilationUnitContext) {
	this := p
	_ = this

	localctx = NewCompilationUnitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 62, Java8ParserRULE_compilationUnit)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(714)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 36, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(713)
			p.PackageDeclaration()
		}

	}
	p.SetState(719)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserIMPORT {
		{
			p.SetState(716)
			p.ImportDeclaration()
		}

		p.SetState(721)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(725)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserABSTRACT)|(1<<Java8ParserCLASS)|(1<<Java8ParserENUM)|(1<<Java8ParserFINAL)|(1<<Java8ParserINTERFACE))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(Java8ParserPRIVATE-33))|(1<<(Java8ParserPROTECTED-33))|(1<<(Java8ParserPUBLIC-33))|(1<<(Java8ParserSTATIC-33))|(1<<(Java8ParserSTRICTFP-33))|(1<<(Java8ParserSEMI-33)))) != 0) || _la == Java8ParserAT {
		{
			p.SetState(722)
			p.TypeDeclaration()
		}

		p.SetState(727)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(728)
		p.Match(Java8ParserEOF)
	}

	return localctx
}

// IPackageDeclarationContext is an interface to support dynamic dispatch.
type IPackageDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPackageDeclarationContext differentiates from other interfaces.
	IsPackageDeclarationContext()
}

type PackageDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPackageDeclarationContext() *PackageDeclarationContext {
	var p = new(PackageDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_packageDeclaration
	return p
}

func (*PackageDeclarationContext) IsPackageDeclarationContext() {}

func NewPackageDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PackageDeclarationContext {
	var p = new(PackageDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_packageDeclaration

	return p
}

func (s *PackageDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *PackageDeclarationContext) PACKAGE() antlr.TerminalNode {
	return s.GetToken(Java8ParserPACKAGE, 0)
}

func (s *PackageDeclarationContext) PackageName() IPackageNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPackageNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPackageNameContext)
}

func (s *PackageDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *PackageDeclarationContext) AllPackageModifier() []IPackageModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IPackageModifierContext)(nil)).Elem())
	var tst = make([]IPackageModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IPackageModifierContext)
		}
	}

	return tst
}

func (s *PackageDeclarationContext) PackageModifier(i int) IPackageModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPackageModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IPackageModifierContext)
}

func (s *PackageDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PackageDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PackageDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPackageDeclaration(s)
	}
}

func (s *PackageDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPackageDeclaration(s)
	}
}

func (p *Java8Parser) PackageDeclaration() (localctx IPackageDeclarationContext) {
	this := p
	_ = this

	localctx = NewPackageDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 64, Java8ParserRULE_packageDeclaration)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(733)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserAT {
		{
			p.SetState(730)
			p.PackageModifier()
		}

		p.SetState(735)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(736)
		p.Match(Java8ParserPACKAGE)
	}
	{
		p.SetState(737)
		p.packageName(0)
	}
	{
		p.SetState(738)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// IPackageModifierContext is an interface to support dynamic dispatch.
type IPackageModifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPackageModifierContext differentiates from other interfaces.
	IsPackageModifierContext()
}

type PackageModifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPackageModifierContext() *PackageModifierContext {
	var p = new(PackageModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_packageModifier
	return p
}

func (*PackageModifierContext) IsPackageModifierContext() {}

func NewPackageModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PackageModifierContext {
	var p = new(PackageModifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_packageModifier

	return p
}

func (s *PackageModifierContext) GetParser() antlr.Parser { return s.parser }

func (s *PackageModifierContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *PackageModifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PackageModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PackageModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPackageModifier(s)
	}
}

func (s *PackageModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPackageModifier(s)
	}
}

func (p *Java8Parser) PackageModifier() (localctx IPackageModifierContext) {
	this := p
	_ = this

	localctx = NewPackageModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, Java8ParserRULE_packageModifier)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(740)
		p.Annotation()
	}

	return localctx
}

// IImportDeclarationContext is an interface to support dynamic dispatch.
type IImportDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsImportDeclarationContext differentiates from other interfaces.
	IsImportDeclarationContext()
}

type ImportDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyImportDeclarationContext() *ImportDeclarationContext {
	var p = new(ImportDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_importDeclaration
	return p
}

func (*ImportDeclarationContext) IsImportDeclarationContext() {}

func NewImportDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportDeclarationContext {
	var p = new(ImportDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_importDeclaration

	return p
}

func (s *ImportDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *ImportDeclarationContext) SingleTypeImportDeclaration() ISingleTypeImportDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleTypeImportDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleTypeImportDeclarationContext)
}

func (s *ImportDeclarationContext) TypeImportOnDemandDeclaration() ITypeImportOnDemandDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeImportOnDemandDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeImportOnDemandDeclarationContext)
}

func (s *ImportDeclarationContext) SingleStaticImportDeclaration() ISingleStaticImportDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleStaticImportDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleStaticImportDeclarationContext)
}

func (s *ImportDeclarationContext) StaticImportOnDemandDeclaration() IStaticImportOnDemandDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStaticImportOnDemandDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStaticImportOnDemandDeclarationContext)
}

func (s *ImportDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ImportDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ImportDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterImportDeclaration(s)
	}
}

func (s *ImportDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitImportDeclaration(s)
	}
}

func (p *Java8Parser) ImportDeclaration() (localctx IImportDeclarationContext) {
	this := p
	_ = this

	localctx = NewImportDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, Java8ParserRULE_importDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(746)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 40, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(742)
			p.SingleTypeImportDeclaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(743)
			p.TypeImportOnDemandDeclaration()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(744)
			p.SingleStaticImportDeclaration()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(745)
			p.StaticImportOnDemandDeclaration()
		}

	}

	return localctx
}

// ISingleTypeImportDeclarationContext is an interface to support dynamic dispatch.
type ISingleTypeImportDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSingleTypeImportDeclarationContext differentiates from other interfaces.
	IsSingleTypeImportDeclarationContext()
}

type SingleTypeImportDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySingleTypeImportDeclarationContext() *SingleTypeImportDeclarationContext {
	var p = new(SingleTypeImportDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_singleTypeImportDeclaration
	return p
}

func (*SingleTypeImportDeclarationContext) IsSingleTypeImportDeclarationContext() {}

func NewSingleTypeImportDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleTypeImportDeclarationContext {
	var p = new(SingleTypeImportDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_singleTypeImportDeclaration

	return p
}

func (s *SingleTypeImportDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *SingleTypeImportDeclarationContext) IMPORT() antlr.TerminalNode {
	return s.GetToken(Java8ParserIMPORT, 0)
}

func (s *SingleTypeImportDeclarationContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *SingleTypeImportDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *SingleTypeImportDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SingleTypeImportDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SingleTypeImportDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterSingleTypeImportDeclaration(s)
	}
}

func (s *SingleTypeImportDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitSingleTypeImportDeclaration(s)
	}
}

func (p *Java8Parser) SingleTypeImportDeclaration() (localctx ISingleTypeImportDeclarationContext) {
	this := p
	_ = this

	localctx = NewSingleTypeImportDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, Java8ParserRULE_singleTypeImportDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(748)
		p.Match(Java8ParserIMPORT)
	}
	{
		p.SetState(749)
		p.TypeName()
	}
	{
		p.SetState(750)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// ITypeImportOnDemandDeclarationContext is an interface to support dynamic dispatch.
type ITypeImportOnDemandDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeImportOnDemandDeclarationContext differentiates from other interfaces.
	IsTypeImportOnDemandDeclarationContext()
}

type TypeImportOnDemandDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeImportOnDemandDeclarationContext() *TypeImportOnDemandDeclarationContext {
	var p = new(TypeImportOnDemandDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_typeImportOnDemandDeclaration
	return p
}

func (*TypeImportOnDemandDeclarationContext) IsTypeImportOnDemandDeclarationContext() {}

func NewTypeImportOnDemandDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeImportOnDemandDeclarationContext {
	var p = new(TypeImportOnDemandDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_typeImportOnDemandDeclaration

	return p
}

func (s *TypeImportOnDemandDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeImportOnDemandDeclarationContext) IMPORT() antlr.TerminalNode {
	return s.GetToken(Java8ParserIMPORT, 0)
}

func (s *TypeImportOnDemandDeclarationContext) PackageOrTypeName() IPackageOrTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPackageOrTypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPackageOrTypeNameContext)
}

func (s *TypeImportOnDemandDeclarationContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *TypeImportOnDemandDeclarationContext) MUL() antlr.TerminalNode {
	return s.GetToken(Java8ParserMUL, 0)
}

func (s *TypeImportOnDemandDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *TypeImportOnDemandDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeImportOnDemandDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeImportOnDemandDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTypeImportOnDemandDeclaration(s)
	}
}

func (s *TypeImportOnDemandDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTypeImportOnDemandDeclaration(s)
	}
}

func (p *Java8Parser) TypeImportOnDemandDeclaration() (localctx ITypeImportOnDemandDeclarationContext) {
	this := p
	_ = this

	localctx = NewTypeImportOnDemandDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, Java8ParserRULE_typeImportOnDemandDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(752)
		p.Match(Java8ParserIMPORT)
	}
	{
		p.SetState(753)
		p.packageOrTypeName(0)
	}
	{
		p.SetState(754)
		p.Match(Java8ParserDOT)
	}
	{
		p.SetState(755)
		p.Match(Java8ParserMUL)
	}
	{
		p.SetState(756)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// ISingleStaticImportDeclarationContext is an interface to support dynamic dispatch.
type ISingleStaticImportDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSingleStaticImportDeclarationContext differentiates from other interfaces.
	IsSingleStaticImportDeclarationContext()
}

type SingleStaticImportDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySingleStaticImportDeclarationContext() *SingleStaticImportDeclarationContext {
	var p = new(SingleStaticImportDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_singleStaticImportDeclaration
	return p
}

func (*SingleStaticImportDeclarationContext) IsSingleStaticImportDeclarationContext() {}

func NewSingleStaticImportDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleStaticImportDeclarationContext {
	var p = new(SingleStaticImportDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_singleStaticImportDeclaration

	return p
}

func (s *SingleStaticImportDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *SingleStaticImportDeclarationContext) IMPORT() antlr.TerminalNode {
	return s.GetToken(Java8ParserIMPORT, 0)
}

func (s *SingleStaticImportDeclarationContext) STATIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserSTATIC, 0)
}

func (s *SingleStaticImportDeclarationContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *SingleStaticImportDeclarationContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *SingleStaticImportDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *SingleStaticImportDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *SingleStaticImportDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SingleStaticImportDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SingleStaticImportDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterSingleStaticImportDeclaration(s)
	}
}

func (s *SingleStaticImportDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitSingleStaticImportDeclaration(s)
	}
}

func (p *Java8Parser) SingleStaticImportDeclaration() (localctx ISingleStaticImportDeclarationContext) {
	this := p
	_ = this

	localctx = NewSingleStaticImportDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, Java8ParserRULE_singleStaticImportDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(758)
		p.Match(Java8ParserIMPORT)
	}
	{
		p.SetState(759)
		p.Match(Java8ParserSTATIC)
	}
	{
		p.SetState(760)
		p.TypeName()
	}
	{
		p.SetState(761)
		p.Match(Java8ParserDOT)
	}
	{
		p.SetState(762)
		p.Match(Java8ParserIdentifier)
	}
	{
		p.SetState(763)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// IStaticImportOnDemandDeclarationContext is an interface to support dynamic dispatch.
type IStaticImportOnDemandDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStaticImportOnDemandDeclarationContext differentiates from other interfaces.
	IsStaticImportOnDemandDeclarationContext()
}

type StaticImportOnDemandDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStaticImportOnDemandDeclarationContext() *StaticImportOnDemandDeclarationContext {
	var p = new(StaticImportOnDemandDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_staticImportOnDemandDeclaration
	return p
}

func (*StaticImportOnDemandDeclarationContext) IsStaticImportOnDemandDeclarationContext() {}

func NewStaticImportOnDemandDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StaticImportOnDemandDeclarationContext {
	var p = new(StaticImportOnDemandDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_staticImportOnDemandDeclaration

	return p
}

func (s *StaticImportOnDemandDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *StaticImportOnDemandDeclarationContext) IMPORT() antlr.TerminalNode {
	return s.GetToken(Java8ParserIMPORT, 0)
}

func (s *StaticImportOnDemandDeclarationContext) STATIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserSTATIC, 0)
}

func (s *StaticImportOnDemandDeclarationContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *StaticImportOnDemandDeclarationContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *StaticImportOnDemandDeclarationContext) MUL() antlr.TerminalNode {
	return s.GetToken(Java8ParserMUL, 0)
}

func (s *StaticImportOnDemandDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *StaticImportOnDemandDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StaticImportOnDemandDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StaticImportOnDemandDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterStaticImportOnDemandDeclaration(s)
	}
}

func (s *StaticImportOnDemandDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitStaticImportOnDemandDeclaration(s)
	}
}

func (p *Java8Parser) StaticImportOnDemandDeclaration() (localctx IStaticImportOnDemandDeclarationContext) {
	this := p
	_ = this

	localctx = NewStaticImportOnDemandDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 76, Java8ParserRULE_staticImportOnDemandDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(765)
		p.Match(Java8ParserIMPORT)
	}
	{
		p.SetState(766)
		p.Match(Java8ParserSTATIC)
	}
	{
		p.SetState(767)
		p.TypeName()
	}
	{
		p.SetState(768)
		p.Match(Java8ParserDOT)
	}
	{
		p.SetState(769)
		p.Match(Java8ParserMUL)
	}
	{
		p.SetState(770)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// ITypeDeclarationContext is an interface to support dynamic dispatch.
type ITypeDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeDeclarationContext differentiates from other interfaces.
	IsTypeDeclarationContext()
}

type TypeDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeDeclarationContext() *TypeDeclarationContext {
	var p = new(TypeDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_typeDeclaration
	return p
}

func (*TypeDeclarationContext) IsTypeDeclarationContext() {}

func NewTypeDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeDeclarationContext {
	var p = new(TypeDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_typeDeclaration

	return p
}

func (s *TypeDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeDeclarationContext) ClassDeclaration() IClassDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassDeclarationContext)
}

func (s *TypeDeclarationContext) InterfaceDeclaration() IInterfaceDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceDeclarationContext)
}

func (s *TypeDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *TypeDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTypeDeclaration(s)
	}
}

func (s *TypeDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTypeDeclaration(s)
	}
}

func (p *Java8Parser) TypeDeclaration() (localctx ITypeDeclarationContext) {
	this := p
	_ = this

	localctx = NewTypeDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, Java8ParserRULE_typeDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(775)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 41, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(772)
			p.ClassDeclaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(773)
			p.InterfaceDeclaration()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(774)
			p.Match(Java8ParserSEMI)
		}

	}

	return localctx
}

// IClassDeclarationContext is an interface to support dynamic dispatch.
type IClassDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassDeclarationContext differentiates from other interfaces.
	IsClassDeclarationContext()
}

type ClassDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassDeclarationContext() *ClassDeclarationContext {
	var p = new(ClassDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_classDeclaration
	return p
}

func (*ClassDeclarationContext) IsClassDeclarationContext() {}

func NewClassDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassDeclarationContext {
	var p = new(ClassDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_classDeclaration

	return p
}

func (s *ClassDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassDeclarationContext) NormalClassDeclaration() INormalClassDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INormalClassDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INormalClassDeclarationContext)
}

func (s *ClassDeclarationContext) EnumDeclaration() IEnumDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumDeclarationContext)
}

func (s *ClassDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterClassDeclaration(s)
	}
}

func (s *ClassDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitClassDeclaration(s)
	}
}

func (p *Java8Parser) ClassDeclaration() (localctx IClassDeclarationContext) {
	this := p
	_ = this

	localctx = NewClassDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, Java8ParserRULE_classDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(779)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 42, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(777)
			p.NormalClassDeclaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(778)
			p.EnumDeclaration()
		}

	}

	return localctx
}

// INormalClassDeclarationContext is an interface to support dynamic dispatch.
type INormalClassDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNormalClassDeclarationContext differentiates from other interfaces.
	IsNormalClassDeclarationContext()
}

type NormalClassDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNormalClassDeclarationContext() *NormalClassDeclarationContext {
	var p = new(NormalClassDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_normalClassDeclaration
	return p
}

func (*NormalClassDeclarationContext) IsNormalClassDeclarationContext() {}

func NewNormalClassDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NormalClassDeclarationContext {
	var p = new(NormalClassDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_normalClassDeclaration

	return p
}

func (s *NormalClassDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *NormalClassDeclarationContext) CLASS() antlr.TerminalNode {
	return s.GetToken(Java8ParserCLASS, 0)
}

func (s *NormalClassDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *NormalClassDeclarationContext) ClassBody() IClassBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassBodyContext)
}

func (s *NormalClassDeclarationContext) AllClassModifier() []IClassModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IClassModifierContext)(nil)).Elem())
	var tst = make([]IClassModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IClassModifierContext)
		}
	}

	return tst
}

func (s *NormalClassDeclarationContext) ClassModifier(i int) IClassModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IClassModifierContext)
}

func (s *NormalClassDeclarationContext) TypeParameters() ITypeParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

func (s *NormalClassDeclarationContext) Superclass() ISuperclassContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISuperclassContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISuperclassContext)
}

func (s *NormalClassDeclarationContext) Superinterfaces() ISuperinterfacesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISuperinterfacesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISuperinterfacesContext)
}

func (s *NormalClassDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NormalClassDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *NormalClassDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterNormalClassDeclaration(s)
	}
}

func (s *NormalClassDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitNormalClassDeclaration(s)
	}
}

func (p *Java8Parser) NormalClassDeclaration() (localctx INormalClassDeclarationContext) {
	this := p
	_ = this

	localctx = NewNormalClassDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, Java8ParserRULE_normalClassDeclaration)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(784)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserABSTRACT || _la == Java8ParserFINAL || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(Java8ParserPRIVATE-33))|(1<<(Java8ParserPROTECTED-33))|(1<<(Java8ParserPUBLIC-33))|(1<<(Java8ParserSTATIC-33))|(1<<(Java8ParserSTRICTFP-33)))) != 0) || _la == Java8ParserAT {
		{
			p.SetState(781)
			p.ClassModifier()
		}

		p.SetState(786)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(787)
		p.Match(Java8ParserCLASS)
	}
	{
		p.SetState(788)
		p.Match(Java8ParserIdentifier)
	}
	p.SetState(790)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserLT {
		{
			p.SetState(789)
			p.TypeParameters()
		}

	}
	p.SetState(793)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserEXTENDS {
		{
			p.SetState(792)
			p.Superclass()
		}

	}
	p.SetState(796)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserIMPLEMENTS {
		{
			p.SetState(795)
			p.Superinterfaces()
		}

	}
	{
		p.SetState(798)
		p.ClassBody()
	}

	return localctx
}

// IClassModifierContext is an interface to support dynamic dispatch.
type IClassModifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassModifierContext differentiates from other interfaces.
	IsClassModifierContext()
}

type ClassModifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassModifierContext() *ClassModifierContext {
	var p = new(ClassModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_classModifier
	return p
}

func (*ClassModifierContext) IsClassModifierContext() {}

func NewClassModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassModifierContext {
	var p = new(ClassModifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_classModifier

	return p
}

func (s *ClassModifierContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassModifierContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *ClassModifierContext) PUBLIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserPUBLIC, 0)
}

func (s *ClassModifierContext) PROTECTED() antlr.TerminalNode {
	return s.GetToken(Java8ParserPROTECTED, 0)
}

func (s *ClassModifierContext) PRIVATE() antlr.TerminalNode {
	return s.GetToken(Java8ParserPRIVATE, 0)
}

func (s *ClassModifierContext) ABSTRACT() antlr.TerminalNode {
	return s.GetToken(Java8ParserABSTRACT, 0)
}

func (s *ClassModifierContext) STATIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserSTATIC, 0)
}

func (s *ClassModifierContext) FINAL() antlr.TerminalNode {
	return s.GetToken(Java8ParserFINAL, 0)
}

func (s *ClassModifierContext) STRICTFP() antlr.TerminalNode {
	return s.GetToken(Java8ParserSTRICTFP, 0)
}

func (s *ClassModifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterClassModifier(s)
	}
}

func (s *ClassModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitClassModifier(s)
	}
}

func (p *Java8Parser) ClassModifier() (localctx IClassModifierContext) {
	this := p
	_ = this

	localctx = NewClassModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 84, Java8ParserRULE_classModifier)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(808)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(800)
			p.Annotation()
		}

	case Java8ParserPUBLIC:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(801)
			p.Match(Java8ParserPUBLIC)
		}

	case Java8ParserPROTECTED:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(802)
			p.Match(Java8ParserPROTECTED)
		}

	case Java8ParserPRIVATE:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(803)
			p.Match(Java8ParserPRIVATE)
		}

	case Java8ParserABSTRACT:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(804)
			p.Match(Java8ParserABSTRACT)
		}

	case Java8ParserSTATIC:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(805)
			p.Match(Java8ParserSTATIC)
		}

	case Java8ParserFINAL:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(806)
			p.Match(Java8ParserFINAL)
		}

	case Java8ParserSTRICTFP:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(807)
			p.Match(Java8ParserSTRICTFP)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// ITypeParametersContext is an interface to support dynamic dispatch.
type ITypeParametersContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeParametersContext differentiates from other interfaces.
	IsTypeParametersContext()
}

type TypeParametersContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeParametersContext() *TypeParametersContext {
	var p = new(TypeParametersContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_typeParameters
	return p
}

func (*TypeParametersContext) IsTypeParametersContext() {}

func NewTypeParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeParametersContext {
	var p = new(TypeParametersContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_typeParameters

	return p
}

func (s *TypeParametersContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeParametersContext) LT() antlr.TerminalNode {
	return s.GetToken(Java8ParserLT, 0)
}

func (s *TypeParametersContext) TypeParameterList() ITypeParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeParameterListContext)
}

func (s *TypeParametersContext) GT() antlr.TerminalNode {
	return s.GetToken(Java8ParserGT, 0)
}

func (s *TypeParametersContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeParametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeParametersContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTypeParameters(s)
	}
}

func (s *TypeParametersContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTypeParameters(s)
	}
}

func (p *Java8Parser) TypeParameters() (localctx ITypeParametersContext) {
	this := p
	_ = this

	localctx = NewTypeParametersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, Java8ParserRULE_typeParameters)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(810)
		p.Match(Java8ParserLT)
	}
	{
		p.SetState(811)
		p.TypeParameterList()
	}
	{
		p.SetState(812)
		p.Match(Java8ParserGT)
	}

	return localctx
}

// ITypeParameterListContext is an interface to support dynamic dispatch.
type ITypeParameterListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeParameterListContext differentiates from other interfaces.
	IsTypeParameterListContext()
}

type TypeParameterListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeParameterListContext() *TypeParameterListContext {
	var p = new(TypeParameterListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_typeParameterList
	return p
}

func (*TypeParameterListContext) IsTypeParameterListContext() {}

func NewTypeParameterListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeParameterListContext {
	var p = new(TypeParameterListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_typeParameterList

	return p
}

func (s *TypeParameterListContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeParameterListContext) AllTypeParameter() []ITypeParameterContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeParameterContext)(nil)).Elem())
	var tst = make([]ITypeParameterContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ITypeParameterContext)
		}
	}

	return tst
}

func (s *TypeParameterListContext) TypeParameter(i int) ITypeParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParameterContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeParameterContext)
}

func (s *TypeParameterListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserCOMMA)
}

func (s *TypeParameterListContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, i)
}

func (s *TypeParameterListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeParameterListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeParameterListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTypeParameterList(s)
	}
}

func (s *TypeParameterListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTypeParameterList(s)
	}
}

func (p *Java8Parser) TypeParameterList() (localctx ITypeParameterListContext) {
	this := p
	_ = this

	localctx = NewTypeParameterListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, Java8ParserRULE_typeParameterList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(814)
		p.TypeParameter()
	}
	p.SetState(819)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserCOMMA {
		{
			p.SetState(815)
			p.Match(Java8ParserCOMMA)
		}
		{
			p.SetState(816)
			p.TypeParameter()
		}

		p.SetState(821)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// ISuperclassContext is an interface to support dynamic dispatch.
type ISuperclassContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSuperclassContext differentiates from other interfaces.
	IsSuperclassContext()
}

type SuperclassContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySuperclassContext() *SuperclassContext {
	var p = new(SuperclassContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_superclass
	return p
}

func (*SuperclassContext) IsSuperclassContext() {}

func NewSuperclassContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SuperclassContext {
	var p = new(SuperclassContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_superclass

	return p
}

func (s *SuperclassContext) GetParser() antlr.Parser { return s.parser }

func (s *SuperclassContext) EXTENDS() antlr.TerminalNode {
	return s.GetToken(Java8ParserEXTENDS, 0)
}

func (s *SuperclassContext) ClassType() IClassTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassTypeContext)
}

func (s *SuperclassContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SuperclassContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SuperclassContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterSuperclass(s)
	}
}

func (s *SuperclassContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitSuperclass(s)
	}
}

func (p *Java8Parser) Superclass() (localctx ISuperclassContext) {
	this := p
	_ = this

	localctx = NewSuperclassContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, Java8ParserRULE_superclass)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(822)
		p.Match(Java8ParserEXTENDS)
	}
	{
		p.SetState(823)
		p.ClassType()
	}

	return localctx
}

// ISuperinterfacesContext is an interface to support dynamic dispatch.
type ISuperinterfacesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSuperinterfacesContext differentiates from other interfaces.
	IsSuperinterfacesContext()
}

type SuperinterfacesContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySuperinterfacesContext() *SuperinterfacesContext {
	var p = new(SuperinterfacesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_superinterfaces
	return p
}

func (*SuperinterfacesContext) IsSuperinterfacesContext() {}

func NewSuperinterfacesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SuperinterfacesContext {
	var p = new(SuperinterfacesContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_superinterfaces

	return p
}

func (s *SuperinterfacesContext) GetParser() antlr.Parser { return s.parser }

func (s *SuperinterfacesContext) IMPLEMENTS() antlr.TerminalNode {
	return s.GetToken(Java8ParserIMPLEMENTS, 0)
}

func (s *SuperinterfacesContext) InterfaceTypeList() IInterfaceTypeListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceTypeListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceTypeListContext)
}

func (s *SuperinterfacesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SuperinterfacesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SuperinterfacesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterSuperinterfaces(s)
	}
}

func (s *SuperinterfacesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitSuperinterfaces(s)
	}
}

func (p *Java8Parser) Superinterfaces() (localctx ISuperinterfacesContext) {
	this := p
	_ = this

	localctx = NewSuperinterfacesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, Java8ParserRULE_superinterfaces)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(825)
		p.Match(Java8ParserIMPLEMENTS)
	}
	{
		p.SetState(826)
		p.InterfaceTypeList()
	}

	return localctx
}

// IInterfaceTypeListContext is an interface to support dynamic dispatch.
type IInterfaceTypeListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInterfaceTypeListContext differentiates from other interfaces.
	IsInterfaceTypeListContext()
}

type InterfaceTypeListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInterfaceTypeListContext() *InterfaceTypeListContext {
	var p = new(InterfaceTypeListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_interfaceTypeList
	return p
}

func (*InterfaceTypeListContext) IsInterfaceTypeListContext() {}

func NewInterfaceTypeListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InterfaceTypeListContext {
	var p = new(InterfaceTypeListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_interfaceTypeList

	return p
}

func (s *InterfaceTypeListContext) GetParser() antlr.Parser { return s.parser }

func (s *InterfaceTypeListContext) AllInterfaceType() []IInterfaceTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInterfaceTypeContext)(nil)).Elem())
	var tst = make([]IInterfaceTypeContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IInterfaceTypeContext)
		}
	}

	return tst
}

func (s *InterfaceTypeListContext) InterfaceType(i int) IInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInterfaceTypeContext)
}

func (s *InterfaceTypeListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserCOMMA)
}

func (s *InterfaceTypeListContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, i)
}

func (s *InterfaceTypeListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InterfaceTypeListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InterfaceTypeListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterInterfaceTypeList(s)
	}
}

func (s *InterfaceTypeListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitInterfaceTypeList(s)
	}
}

func (p *Java8Parser) InterfaceTypeList() (localctx IInterfaceTypeListContext) {
	this := p
	_ = this

	localctx = NewInterfaceTypeListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, Java8ParserRULE_interfaceTypeList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(828)
		p.InterfaceType()
	}
	p.SetState(833)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserCOMMA {
		{
			p.SetState(829)
			p.Match(Java8ParserCOMMA)
		}
		{
			p.SetState(830)
			p.InterfaceType()
		}

		p.SetState(835)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IClassBodyContext is an interface to support dynamic dispatch.
type IClassBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassBodyContext differentiates from other interfaces.
	IsClassBodyContext()
}

type ClassBodyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassBodyContext() *ClassBodyContext {
	var p = new(ClassBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_classBody
	return p
}

func (*ClassBodyContext) IsClassBodyContext() {}

func NewClassBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassBodyContext {
	var p = new(ClassBodyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_classBody

	return p
}

func (s *ClassBodyContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassBodyContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACE, 0)
}

func (s *ClassBodyContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACE, 0)
}

func (s *ClassBodyContext) AllClassBodyDeclaration() []IClassBodyDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IClassBodyDeclarationContext)(nil)).Elem())
	var tst = make([]IClassBodyDeclarationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IClassBodyDeclarationContext)
		}
	}

	return tst
}

func (s *ClassBodyContext) ClassBodyDeclaration(i int) IClassBodyDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassBodyDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IClassBodyDeclarationContext)
}

func (s *ClassBodyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassBodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterClassBody(s)
	}
}

func (s *ClassBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitClassBody(s)
	}
}

func (p *Java8Parser) ClassBody() (localctx IClassBodyContext) {
	this := p
	_ = this

	localctx = NewClassBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 96, Java8ParserRULE_classBody)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(836)
		p.Match(Java8ParserLBRACE)
	}
	p.SetState(840)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserABSTRACT)|(1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserCLASS)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserENUM)|(1<<Java8ParserFINAL)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserINTERFACE)|(1<<Java8ParserLONG)|(1<<Java8ParserNATIVE))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(Java8ParserPRIVATE-33))|(1<<(Java8ParserPROTECTED-33))|(1<<(Java8ParserPUBLIC-33))|(1<<(Java8ParserSHORT-33))|(1<<(Java8ParserSTATIC-33))|(1<<(Java8ParserSTRICTFP-33))|(1<<(Java8ParserSYNCHRONIZED-33))|(1<<(Java8ParserTRANSIENT-33))|(1<<(Java8ParserVOID-33))|(1<<(Java8ParserVOLATILE-33))|(1<<(Java8ParserLBRACE-33))|(1<<(Java8ParserSEMI-33)))) != 0) || _la == Java8ParserLT || _la == Java8ParserIdentifier || _la == Java8ParserAT {
		{
			p.SetState(837)
			p.ClassBodyDeclaration()
		}

		p.SetState(842)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(843)
		p.Match(Java8ParserRBRACE)
	}

	return localctx
}

// IClassBodyDeclarationContext is an interface to support dynamic dispatch.
type IClassBodyDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassBodyDeclarationContext differentiates from other interfaces.
	IsClassBodyDeclarationContext()
}

type ClassBodyDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassBodyDeclarationContext() *ClassBodyDeclarationContext {
	var p = new(ClassBodyDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_classBodyDeclaration
	return p
}

func (*ClassBodyDeclarationContext) IsClassBodyDeclarationContext() {}

func NewClassBodyDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassBodyDeclarationContext {
	var p = new(ClassBodyDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_classBodyDeclaration

	return p
}

func (s *ClassBodyDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassBodyDeclarationContext) ClassMemberDeclaration() IClassMemberDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassMemberDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassMemberDeclarationContext)
}

func (s *ClassBodyDeclarationContext) InstanceInitializer() IInstanceInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInstanceInitializerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInstanceInitializerContext)
}

func (s *ClassBodyDeclarationContext) StaticInitializer() IStaticInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStaticInitializerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStaticInitializerContext)
}

func (s *ClassBodyDeclarationContext) ConstructorDeclaration() IConstructorDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstructorDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstructorDeclarationContext)
}

func (s *ClassBodyDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassBodyDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassBodyDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterClassBodyDeclaration(s)
	}
}

func (s *ClassBodyDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitClassBodyDeclaration(s)
	}
}

func (p *Java8Parser) ClassBodyDeclaration() (localctx IClassBodyDeclarationContext) {
	this := p
	_ = this

	localctx = NewClassBodyDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 98, Java8ParserRULE_classBodyDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(849)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 51, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(845)
			p.ClassMemberDeclaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(846)
			p.InstanceInitializer()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(847)
			p.StaticInitializer()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(848)
			p.ConstructorDeclaration()
		}

	}

	return localctx
}

// IClassMemberDeclarationContext is an interface to support dynamic dispatch.
type IClassMemberDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassMemberDeclarationContext differentiates from other interfaces.
	IsClassMemberDeclarationContext()
}

type ClassMemberDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassMemberDeclarationContext() *ClassMemberDeclarationContext {
	var p = new(ClassMemberDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_classMemberDeclaration
	return p
}

func (*ClassMemberDeclarationContext) IsClassMemberDeclarationContext() {}

func NewClassMemberDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassMemberDeclarationContext {
	var p = new(ClassMemberDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_classMemberDeclaration

	return p
}

func (s *ClassMemberDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassMemberDeclarationContext) FieldDeclaration() IFieldDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFieldDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFieldDeclarationContext)
}

func (s *ClassMemberDeclarationContext) MethodDeclaration() IMethodDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodDeclarationContext)
}

func (s *ClassMemberDeclarationContext) ClassDeclaration() IClassDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassDeclarationContext)
}

func (s *ClassMemberDeclarationContext) InterfaceDeclaration() IInterfaceDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceDeclarationContext)
}

func (s *ClassMemberDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *ClassMemberDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassMemberDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassMemberDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterClassMemberDeclaration(s)
	}
}

func (s *ClassMemberDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitClassMemberDeclaration(s)
	}
}

func (p *Java8Parser) ClassMemberDeclaration() (localctx IClassMemberDeclarationContext) {
	this := p
	_ = this

	localctx = NewClassMemberDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, Java8ParserRULE_classMemberDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(856)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 52, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(851)
			p.FieldDeclaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(852)
			p.MethodDeclaration()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(853)
			p.ClassDeclaration()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(854)
			p.InterfaceDeclaration()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(855)
			p.Match(Java8ParserSEMI)
		}

	}

	return localctx
}

// IFieldDeclarationContext is an interface to support dynamic dispatch.
type IFieldDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFieldDeclarationContext differentiates from other interfaces.
	IsFieldDeclarationContext()
}

type FieldDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFieldDeclarationContext() *FieldDeclarationContext {
	var p = new(FieldDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_fieldDeclaration
	return p
}

func (*FieldDeclarationContext) IsFieldDeclarationContext() {}

func NewFieldDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldDeclarationContext {
	var p = new(FieldDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_fieldDeclaration

	return p
}

func (s *FieldDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *FieldDeclarationContext) UnannType() IUnannTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannTypeContext)
}

func (s *FieldDeclarationContext) VariableDeclaratorList() IVariableDeclaratorListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorListContext)
}

func (s *FieldDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *FieldDeclarationContext) AllFieldModifier() []IFieldModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFieldModifierContext)(nil)).Elem())
	var tst = make([]IFieldModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IFieldModifierContext)
		}
	}

	return tst
}

func (s *FieldDeclarationContext) FieldModifier(i int) IFieldModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFieldModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IFieldModifierContext)
}

func (s *FieldDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FieldDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FieldDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterFieldDeclaration(s)
	}
}

func (s *FieldDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitFieldDeclaration(s)
	}
}

func (p *Java8Parser) FieldDeclaration() (localctx IFieldDeclarationContext) {
	this := p
	_ = this

	localctx = NewFieldDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, Java8ParserRULE_fieldDeclaration)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(861)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la-18)&-(0x1f+1)) == 0 && ((1<<uint((_la-18)))&((1<<(Java8ParserFINAL-18))|(1<<(Java8ParserPRIVATE-18))|(1<<(Java8ParserPROTECTED-18))|(1<<(Java8ParserPUBLIC-18))|(1<<(Java8ParserSTATIC-18))|(1<<(Java8ParserTRANSIENT-18))|(1<<(Java8ParserVOLATILE-18)))) != 0) || _la == Java8ParserAT {
		{
			p.SetState(858)
			p.FieldModifier()
		}

		p.SetState(863)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(864)
		p.UnannType()
	}
	{
		p.SetState(865)
		p.VariableDeclaratorList()
	}
	{
		p.SetState(866)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// IFieldModifierContext is an interface to support dynamic dispatch.
type IFieldModifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFieldModifierContext differentiates from other interfaces.
	IsFieldModifierContext()
}

type FieldModifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFieldModifierContext() *FieldModifierContext {
	var p = new(FieldModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_fieldModifier
	return p
}

func (*FieldModifierContext) IsFieldModifierContext() {}

func NewFieldModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldModifierContext {
	var p = new(FieldModifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_fieldModifier

	return p
}

func (s *FieldModifierContext) GetParser() antlr.Parser { return s.parser }

func (s *FieldModifierContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *FieldModifierContext) PUBLIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserPUBLIC, 0)
}

func (s *FieldModifierContext) PROTECTED() antlr.TerminalNode {
	return s.GetToken(Java8ParserPROTECTED, 0)
}

func (s *FieldModifierContext) PRIVATE() antlr.TerminalNode {
	return s.GetToken(Java8ParserPRIVATE, 0)
}

func (s *FieldModifierContext) STATIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserSTATIC, 0)
}

func (s *FieldModifierContext) FINAL() antlr.TerminalNode {
	return s.GetToken(Java8ParserFINAL, 0)
}

func (s *FieldModifierContext) TRANSIENT() antlr.TerminalNode {
	return s.GetToken(Java8ParserTRANSIENT, 0)
}

func (s *FieldModifierContext) VOLATILE() antlr.TerminalNode {
	return s.GetToken(Java8ParserVOLATILE, 0)
}

func (s *FieldModifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FieldModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FieldModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterFieldModifier(s)
	}
}

func (s *FieldModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitFieldModifier(s)
	}
}

func (p *Java8Parser) FieldModifier() (localctx IFieldModifierContext) {
	this := p
	_ = this

	localctx = NewFieldModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 104, Java8ParserRULE_fieldModifier)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(876)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(868)
			p.Annotation()
		}

	case Java8ParserPUBLIC:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(869)
			p.Match(Java8ParserPUBLIC)
		}

	case Java8ParserPROTECTED:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(870)
			p.Match(Java8ParserPROTECTED)
		}

	case Java8ParserPRIVATE:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(871)
			p.Match(Java8ParserPRIVATE)
		}

	case Java8ParserSTATIC:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(872)
			p.Match(Java8ParserSTATIC)
		}

	case Java8ParserFINAL:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(873)
			p.Match(Java8ParserFINAL)
		}

	case Java8ParserTRANSIENT:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(874)
			p.Match(Java8ParserTRANSIENT)
		}

	case Java8ParserVOLATILE:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(875)
			p.Match(Java8ParserVOLATILE)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IVariableDeclaratorListContext is an interface to support dynamic dispatch.
type IVariableDeclaratorListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsVariableDeclaratorListContext differentiates from other interfaces.
	IsVariableDeclaratorListContext()
}

type VariableDeclaratorListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVariableDeclaratorListContext() *VariableDeclaratorListContext {
	var p = new(VariableDeclaratorListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_variableDeclaratorList
	return p
}

func (*VariableDeclaratorListContext) IsVariableDeclaratorListContext() {}

func NewVariableDeclaratorListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclaratorListContext {
	var p = new(VariableDeclaratorListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_variableDeclaratorList

	return p
}

func (s *VariableDeclaratorListContext) GetParser() antlr.Parser { return s.parser }

func (s *VariableDeclaratorListContext) AllVariableDeclarator() []IVariableDeclaratorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVariableDeclaratorContext)(nil)).Elem())
	var tst = make([]IVariableDeclaratorContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IVariableDeclaratorContext)
		}
	}

	return tst
}

func (s *VariableDeclaratorListContext) VariableDeclarator(i int) IVariableDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorContext)
}

func (s *VariableDeclaratorListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserCOMMA)
}

func (s *VariableDeclaratorListContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, i)
}

func (s *VariableDeclaratorListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VariableDeclaratorListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VariableDeclaratorListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterVariableDeclaratorList(s)
	}
}

func (s *VariableDeclaratorListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitVariableDeclaratorList(s)
	}
}

func (p *Java8Parser) VariableDeclaratorList() (localctx IVariableDeclaratorListContext) {
	this := p
	_ = this

	localctx = NewVariableDeclaratorListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, Java8ParserRULE_variableDeclaratorList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(878)
		p.VariableDeclarator()
	}
	p.SetState(883)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserCOMMA {
		{
			p.SetState(879)
			p.Match(Java8ParserCOMMA)
		}
		{
			p.SetState(880)
			p.VariableDeclarator()
		}

		p.SetState(885)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IVariableDeclaratorContext is an interface to support dynamic dispatch.
type IVariableDeclaratorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsVariableDeclaratorContext differentiates from other interfaces.
	IsVariableDeclaratorContext()
}

type VariableDeclaratorContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVariableDeclaratorContext() *VariableDeclaratorContext {
	var p = new(VariableDeclaratorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_variableDeclarator
	return p
}

func (*VariableDeclaratorContext) IsVariableDeclaratorContext() {}

func NewVariableDeclaratorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclaratorContext {
	var p = new(VariableDeclaratorContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_variableDeclarator

	return p
}

func (s *VariableDeclaratorContext) GetParser() antlr.Parser { return s.parser }

func (s *VariableDeclaratorContext) VariableDeclaratorId() IVariableDeclaratorIdContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorIdContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorIdContext)
}

func (s *VariableDeclaratorContext) ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserASSIGN, 0)
}

func (s *VariableDeclaratorContext) VariableInitializer() IVariableInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableInitializerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableInitializerContext)
}

func (s *VariableDeclaratorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VariableDeclaratorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VariableDeclaratorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterVariableDeclarator(s)
	}
}

func (s *VariableDeclaratorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitVariableDeclarator(s)
	}
}

func (p *Java8Parser) VariableDeclarator() (localctx IVariableDeclaratorContext) {
	this := p
	_ = this

	localctx = NewVariableDeclaratorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, Java8ParserRULE_variableDeclarator)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(886)
		p.VariableDeclaratorId()
	}
	p.SetState(889)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserASSIGN {
		{
			p.SetState(887)
			p.Match(Java8ParserASSIGN)
		}
		{
			p.SetState(888)
			p.VariableInitializer()
		}

	}

	return localctx
}

// IVariableDeclaratorIdContext is an interface to support dynamic dispatch.
type IVariableDeclaratorIdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsVariableDeclaratorIdContext differentiates from other interfaces.
	IsVariableDeclaratorIdContext()
}

type VariableDeclaratorIdContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVariableDeclaratorIdContext() *VariableDeclaratorIdContext {
	var p = new(VariableDeclaratorIdContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_variableDeclaratorId
	return p
}

func (*VariableDeclaratorIdContext) IsVariableDeclaratorIdContext() {}

func NewVariableDeclaratorIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclaratorIdContext {
	var p = new(VariableDeclaratorIdContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_variableDeclaratorId

	return p
}

func (s *VariableDeclaratorIdContext) GetParser() antlr.Parser { return s.parser }

func (s *VariableDeclaratorIdContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *VariableDeclaratorIdContext) Dims() IDimsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDimsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDimsContext)
}

func (s *VariableDeclaratorIdContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VariableDeclaratorIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VariableDeclaratorIdContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterVariableDeclaratorId(s)
	}
}

func (s *VariableDeclaratorIdContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitVariableDeclaratorId(s)
	}
}

func (p *Java8Parser) VariableDeclaratorId() (localctx IVariableDeclaratorIdContext) {
	this := p
	_ = this

	localctx = NewVariableDeclaratorIdContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, Java8ParserRULE_variableDeclaratorId)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(891)
		p.Match(Java8ParserIdentifier)
	}
	p.SetState(893)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserLBRACK || _la == Java8ParserAT {
		{
			p.SetState(892)
			p.Dims()
		}

	}

	return localctx
}

// IVariableInitializerContext is an interface to support dynamic dispatch.
type IVariableInitializerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsVariableInitializerContext differentiates from other interfaces.
	IsVariableInitializerContext()
}

type VariableInitializerContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVariableInitializerContext() *VariableInitializerContext {
	var p = new(VariableInitializerContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_variableInitializer
	return p
}

func (*VariableInitializerContext) IsVariableInitializerContext() {}

func NewVariableInitializerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableInitializerContext {
	var p = new(VariableInitializerContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_variableInitializer

	return p
}

func (s *VariableInitializerContext) GetParser() antlr.Parser { return s.parser }

func (s *VariableInitializerContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *VariableInitializerContext) ArrayInitializer() IArrayInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayInitializerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayInitializerContext)
}

func (s *VariableInitializerContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VariableInitializerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VariableInitializerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterVariableInitializer(s)
	}
}

func (s *VariableInitializerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitVariableInitializer(s)
	}
}

func (p *Java8Parser) VariableInitializer() (localctx IVariableInitializerContext) {
	this := p
	_ = this

	localctx = NewVariableInitializerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 112, Java8ParserRULE_variableInitializer)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(897)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserBOOLEAN, Java8ParserBYTE, Java8ParserCHAR, Java8ParserDOUBLE, Java8ParserFLOAT, Java8ParserINT, Java8ParserLONG, Java8ParserNEW, Java8ParserSHORT, Java8ParserSUPER, Java8ParserTHIS, Java8ParserVOID, Java8ParserIntegerLiteral, Java8ParserFloatingPointLiteral, Java8ParserBooleanLiteral, Java8ParserCharacterLiteral, Java8ParserStringLiteral, Java8ParserNullLiteral, Java8ParserLPAREN, Java8ParserBANG, Java8ParserTILDE, Java8ParserINC, Java8ParserDEC, Java8ParserADD, Java8ParserSUB, Java8ParserIdentifier, Java8ParserAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(895)
			p.Expression()
		}

	case Java8ParserLBRACE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(896)
			p.ArrayInitializer()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IUnannTypeContext is an interface to support dynamic dispatch.
type IUnannTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnannTypeContext differentiates from other interfaces.
	IsUnannTypeContext()
}

type UnannTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnannTypeContext() *UnannTypeContext {
	var p = new(UnannTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_unannType
	return p
}

func (*UnannTypeContext) IsUnannTypeContext() {}

func NewUnannTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnannTypeContext {
	var p = new(UnannTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_unannType

	return p
}

func (s *UnannTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *UnannTypeContext) UnannPrimitiveType() IUnannPrimitiveTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannPrimitiveTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannPrimitiveTypeContext)
}

func (s *UnannTypeContext) UnannReferenceType() IUnannReferenceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannReferenceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannReferenceTypeContext)
}

func (s *UnannTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnannTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnannTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterUnannType(s)
	}
}

func (s *UnannTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitUnannType(s)
	}
}

func (p *Java8Parser) UnannType() (localctx IUnannTypeContext) {
	this := p
	_ = this

	localctx = NewUnannTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 114, Java8ParserRULE_unannType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(901)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 59, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(899)
			p.UnannPrimitiveType()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(900)
			p.UnannReferenceType()
		}

	}

	return localctx
}

// IUnannPrimitiveTypeContext is an interface to support dynamic dispatch.
type IUnannPrimitiveTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnannPrimitiveTypeContext differentiates from other interfaces.
	IsUnannPrimitiveTypeContext()
}

type UnannPrimitiveTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnannPrimitiveTypeContext() *UnannPrimitiveTypeContext {
	var p = new(UnannPrimitiveTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_unannPrimitiveType
	return p
}

func (*UnannPrimitiveTypeContext) IsUnannPrimitiveTypeContext() {}

func NewUnannPrimitiveTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnannPrimitiveTypeContext {
	var p = new(UnannPrimitiveTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_unannPrimitiveType

	return p
}

func (s *UnannPrimitiveTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *UnannPrimitiveTypeContext) NumericType() INumericTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INumericTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INumericTypeContext)
}

func (s *UnannPrimitiveTypeContext) BOOLEAN() antlr.TerminalNode {
	return s.GetToken(Java8ParserBOOLEAN, 0)
}

func (s *UnannPrimitiveTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnannPrimitiveTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnannPrimitiveTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterUnannPrimitiveType(s)
	}
}

func (s *UnannPrimitiveTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitUnannPrimitiveType(s)
	}
}

func (p *Java8Parser) UnannPrimitiveType() (localctx IUnannPrimitiveTypeContext) {
	this := p
	_ = this

	localctx = NewUnannPrimitiveTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, Java8ParserRULE_unannPrimitiveType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(905)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserBYTE, Java8ParserCHAR, Java8ParserDOUBLE, Java8ParserFLOAT, Java8ParserINT, Java8ParserLONG, Java8ParserSHORT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(903)
			p.NumericType()
		}

	case Java8ParserBOOLEAN:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(904)
			p.Match(Java8ParserBOOLEAN)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IUnannReferenceTypeContext is an interface to support dynamic dispatch.
type IUnannReferenceTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnannReferenceTypeContext differentiates from other interfaces.
	IsUnannReferenceTypeContext()
}

type UnannReferenceTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnannReferenceTypeContext() *UnannReferenceTypeContext {
	var p = new(UnannReferenceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_unannReferenceType
	return p
}

func (*UnannReferenceTypeContext) IsUnannReferenceTypeContext() {}

func NewUnannReferenceTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnannReferenceTypeContext {
	var p = new(UnannReferenceTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_unannReferenceType

	return p
}

func (s *UnannReferenceTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *UnannReferenceTypeContext) UnannClassOrInterfaceType() IUnannClassOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannClassOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannClassOrInterfaceTypeContext)
}

func (s *UnannReferenceTypeContext) UnannTypeVariable() IUnannTypeVariableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannTypeVariableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannTypeVariableContext)
}

func (s *UnannReferenceTypeContext) UnannArrayType() IUnannArrayTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannArrayTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannArrayTypeContext)
}

func (s *UnannReferenceTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnannReferenceTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnannReferenceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterUnannReferenceType(s)
	}
}

func (s *UnannReferenceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitUnannReferenceType(s)
	}
}

func (p *Java8Parser) UnannReferenceType() (localctx IUnannReferenceTypeContext) {
	this := p
	_ = this

	localctx = NewUnannReferenceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, Java8ParserRULE_unannReferenceType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(910)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 61, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(907)
			p.UnannClassOrInterfaceType()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(908)
			p.UnannTypeVariable()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(909)
			p.UnannArrayType()
		}

	}

	return localctx
}

// IUnannClassOrInterfaceTypeContext is an interface to support dynamic dispatch.
type IUnannClassOrInterfaceTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnannClassOrInterfaceTypeContext differentiates from other interfaces.
	IsUnannClassOrInterfaceTypeContext()
}

type UnannClassOrInterfaceTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnannClassOrInterfaceTypeContext() *UnannClassOrInterfaceTypeContext {
	var p = new(UnannClassOrInterfaceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_unannClassOrInterfaceType
	return p
}

func (*UnannClassOrInterfaceTypeContext) IsUnannClassOrInterfaceTypeContext() {}

func NewUnannClassOrInterfaceTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnannClassOrInterfaceTypeContext {
	var p = new(UnannClassOrInterfaceTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_unannClassOrInterfaceType

	return p
}

func (s *UnannClassOrInterfaceTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *UnannClassOrInterfaceTypeContext) UnannClassType_lfno_unannClassOrInterfaceType() IUnannClassType_lfno_unannClassOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannClassType_lfno_unannClassOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannClassType_lfno_unannClassOrInterfaceTypeContext)
}

func (s *UnannClassOrInterfaceTypeContext) UnannInterfaceType_lfno_unannClassOrInterfaceType() IUnannInterfaceType_lfno_unannClassOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannInterfaceType_lfno_unannClassOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannInterfaceType_lfno_unannClassOrInterfaceTypeContext)
}

func (s *UnannClassOrInterfaceTypeContext) AllUnannClassType_lf_unannClassOrInterfaceType() []IUnannClassType_lf_unannClassOrInterfaceTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IUnannClassType_lf_unannClassOrInterfaceTypeContext)(nil)).Elem())
	var tst = make([]IUnannClassType_lf_unannClassOrInterfaceTypeContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IUnannClassType_lf_unannClassOrInterfaceTypeContext)
		}
	}

	return tst
}

func (s *UnannClassOrInterfaceTypeContext) UnannClassType_lf_unannClassOrInterfaceType(i int) IUnannClassType_lf_unannClassOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannClassType_lf_unannClassOrInterfaceTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IUnannClassType_lf_unannClassOrInterfaceTypeContext)
}

func (s *UnannClassOrInterfaceTypeContext) AllUnannInterfaceType_lf_unannClassOrInterfaceType() []IUnannInterfaceType_lf_unannClassOrInterfaceTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IUnannInterfaceType_lf_unannClassOrInterfaceTypeContext)(nil)).Elem())
	var tst = make([]IUnannInterfaceType_lf_unannClassOrInterfaceTypeContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IUnannInterfaceType_lf_unannClassOrInterfaceTypeContext)
		}
	}

	return tst
}

func (s *UnannClassOrInterfaceTypeContext) UnannInterfaceType_lf_unannClassOrInterfaceType(i int) IUnannInterfaceType_lf_unannClassOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannInterfaceType_lf_unannClassOrInterfaceTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IUnannInterfaceType_lf_unannClassOrInterfaceTypeContext)
}

func (s *UnannClassOrInterfaceTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnannClassOrInterfaceTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnannClassOrInterfaceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterUnannClassOrInterfaceType(s)
	}
}

func (s *UnannClassOrInterfaceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitUnannClassOrInterfaceType(s)
	}
}

func (p *Java8Parser) UnannClassOrInterfaceType() (localctx IUnannClassOrInterfaceTypeContext) {
	this := p
	_ = this

	localctx = NewUnannClassOrInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, Java8ParserRULE_unannClassOrInterfaceType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(914)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 62, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(912)
			p.UnannClassType_lfno_unannClassOrInterfaceType()
		}

	case 2:
		{
			p.SetState(913)
			p.UnannInterfaceType_lfno_unannClassOrInterfaceType()
		}

	}
	p.SetState(920)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 64, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(918)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 63, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(916)
					p.UnannClassType_lf_unannClassOrInterfaceType()
				}

			case 2:
				{
					p.SetState(917)
					p.UnannInterfaceType_lf_unannClassOrInterfaceType()
				}

			}

		}
		p.SetState(922)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 64, p.GetParserRuleContext())
	}

	return localctx
}

// IUnannClassTypeContext is an interface to support dynamic dispatch.
type IUnannClassTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnannClassTypeContext differentiates from other interfaces.
	IsUnannClassTypeContext()
}

type UnannClassTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnannClassTypeContext() *UnannClassTypeContext {
	var p = new(UnannClassTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_unannClassType
	return p
}

func (*UnannClassTypeContext) IsUnannClassTypeContext() {}

func NewUnannClassTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnannClassTypeContext {
	var p = new(UnannClassTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_unannClassType

	return p
}

func (s *UnannClassTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *UnannClassTypeContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *UnannClassTypeContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *UnannClassTypeContext) UnannClassOrInterfaceType() IUnannClassOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannClassOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannClassOrInterfaceTypeContext)
}

func (s *UnannClassTypeContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *UnannClassTypeContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *UnannClassTypeContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *UnannClassTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnannClassTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnannClassTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterUnannClassType(s)
	}
}

func (s *UnannClassTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitUnannClassType(s)
	}
}

func (p *Java8Parser) UnannClassType() (localctx IUnannClassTypeContext) {
	this := p
	_ = this

	localctx = NewUnannClassTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 122, Java8ParserRULE_unannClassType)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(939)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 68, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(923)
			p.Match(Java8ParserIdentifier)
		}
		p.SetState(925)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(924)
				p.TypeArguments()
			}

		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(927)
			p.UnannClassOrInterfaceType()
		}
		{
			p.SetState(928)
			p.Match(Java8ParserDOT)
		}
		p.SetState(932)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserAT {
			{
				p.SetState(929)
				p.Annotation()
			}

			p.SetState(934)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(935)
			p.Match(Java8ParserIdentifier)
		}
		p.SetState(937)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(936)
				p.TypeArguments()
			}

		}

	}

	return localctx
}

// IUnannClassType_lf_unannClassOrInterfaceTypeContext is an interface to support dynamic dispatch.
type IUnannClassType_lf_unannClassOrInterfaceTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnannClassType_lf_unannClassOrInterfaceTypeContext differentiates from other interfaces.
	IsUnannClassType_lf_unannClassOrInterfaceTypeContext()
}

type UnannClassType_lf_unannClassOrInterfaceTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnannClassType_lf_unannClassOrInterfaceTypeContext() *UnannClassType_lf_unannClassOrInterfaceTypeContext {
	var p = new(UnannClassType_lf_unannClassOrInterfaceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_unannClassType_lf_unannClassOrInterfaceType
	return p
}

func (*UnannClassType_lf_unannClassOrInterfaceTypeContext) IsUnannClassType_lf_unannClassOrInterfaceTypeContext() {
}

func NewUnannClassType_lf_unannClassOrInterfaceTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnannClassType_lf_unannClassOrInterfaceTypeContext {
	var p = new(UnannClassType_lf_unannClassOrInterfaceTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_unannClassType_lf_unannClassOrInterfaceType

	return p
}

func (s *UnannClassType_lf_unannClassOrInterfaceTypeContext) GetParser() antlr.Parser {
	return s.parser
}

func (s *UnannClassType_lf_unannClassOrInterfaceTypeContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *UnannClassType_lf_unannClassOrInterfaceTypeContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *UnannClassType_lf_unannClassOrInterfaceTypeContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *UnannClassType_lf_unannClassOrInterfaceTypeContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *UnannClassType_lf_unannClassOrInterfaceTypeContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *UnannClassType_lf_unannClassOrInterfaceTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnannClassType_lf_unannClassOrInterfaceTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnannClassType_lf_unannClassOrInterfaceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterUnannClassType_lf_unannClassOrInterfaceType(s)
	}
}

func (s *UnannClassType_lf_unannClassOrInterfaceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitUnannClassType_lf_unannClassOrInterfaceType(s)
	}
}

func (p *Java8Parser) UnannClassType_lf_unannClassOrInterfaceType() (localctx IUnannClassType_lf_unannClassOrInterfaceTypeContext) {
	this := p
	_ = this

	localctx = NewUnannClassType_lf_unannClassOrInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 124, Java8ParserRULE_unannClassType_lf_unannClassOrInterfaceType)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(941)
		p.Match(Java8ParserDOT)
	}
	p.SetState(945)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserAT {
		{
			p.SetState(942)
			p.Annotation()
		}

		p.SetState(947)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(948)
		p.Match(Java8ParserIdentifier)
	}
	p.SetState(950)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserLT {
		{
			p.SetState(949)
			p.TypeArguments()
		}

	}

	return localctx
}

// IUnannClassType_lfno_unannClassOrInterfaceTypeContext is an interface to support dynamic dispatch.
type IUnannClassType_lfno_unannClassOrInterfaceTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnannClassType_lfno_unannClassOrInterfaceTypeContext differentiates from other interfaces.
	IsUnannClassType_lfno_unannClassOrInterfaceTypeContext()
}

type UnannClassType_lfno_unannClassOrInterfaceTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnannClassType_lfno_unannClassOrInterfaceTypeContext() *UnannClassType_lfno_unannClassOrInterfaceTypeContext {
	var p = new(UnannClassType_lfno_unannClassOrInterfaceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_unannClassType_lfno_unannClassOrInterfaceType
	return p
}

func (*UnannClassType_lfno_unannClassOrInterfaceTypeContext) IsUnannClassType_lfno_unannClassOrInterfaceTypeContext() {
}

func NewUnannClassType_lfno_unannClassOrInterfaceTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnannClassType_lfno_unannClassOrInterfaceTypeContext {
	var p = new(UnannClassType_lfno_unannClassOrInterfaceTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_unannClassType_lfno_unannClassOrInterfaceType

	return p
}

func (s *UnannClassType_lfno_unannClassOrInterfaceTypeContext) GetParser() antlr.Parser {
	return s.parser
}

func (s *UnannClassType_lfno_unannClassOrInterfaceTypeContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *UnannClassType_lfno_unannClassOrInterfaceTypeContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *UnannClassType_lfno_unannClassOrInterfaceTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnannClassType_lfno_unannClassOrInterfaceTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnannClassType_lfno_unannClassOrInterfaceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterUnannClassType_lfno_unannClassOrInterfaceType(s)
	}
}

func (s *UnannClassType_lfno_unannClassOrInterfaceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitUnannClassType_lfno_unannClassOrInterfaceType(s)
	}
}

func (p *Java8Parser) UnannClassType_lfno_unannClassOrInterfaceType() (localctx IUnannClassType_lfno_unannClassOrInterfaceTypeContext) {
	this := p
	_ = this

	localctx = NewUnannClassType_lfno_unannClassOrInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 126, Java8ParserRULE_unannClassType_lfno_unannClassOrInterfaceType)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(952)
		p.Match(Java8ParserIdentifier)
	}
	p.SetState(954)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserLT {
		{
			p.SetState(953)
			p.TypeArguments()
		}

	}

	return localctx
}

// IUnannInterfaceTypeContext is an interface to support dynamic dispatch.
type IUnannInterfaceTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnannInterfaceTypeContext differentiates from other interfaces.
	IsUnannInterfaceTypeContext()
}

type UnannInterfaceTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnannInterfaceTypeContext() *UnannInterfaceTypeContext {
	var p = new(UnannInterfaceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_unannInterfaceType
	return p
}

func (*UnannInterfaceTypeContext) IsUnannInterfaceTypeContext() {}

func NewUnannInterfaceTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnannInterfaceTypeContext {
	var p = new(UnannInterfaceTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_unannInterfaceType

	return p
}

func (s *UnannInterfaceTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *UnannInterfaceTypeContext) UnannClassType() IUnannClassTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannClassTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannClassTypeContext)
}

func (s *UnannInterfaceTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnannInterfaceTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnannInterfaceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterUnannInterfaceType(s)
	}
}

func (s *UnannInterfaceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitUnannInterfaceType(s)
	}
}

func (p *Java8Parser) UnannInterfaceType() (localctx IUnannInterfaceTypeContext) {
	this := p
	_ = this

	localctx = NewUnannInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 128, Java8ParserRULE_unannInterfaceType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(956)
		p.UnannClassType()
	}

	return localctx
}

// IUnannInterfaceType_lf_unannClassOrInterfaceTypeContext is an interface to support dynamic dispatch.
type IUnannInterfaceType_lf_unannClassOrInterfaceTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnannInterfaceType_lf_unannClassOrInterfaceTypeContext differentiates from other interfaces.
	IsUnannInterfaceType_lf_unannClassOrInterfaceTypeContext()
}

type UnannInterfaceType_lf_unannClassOrInterfaceTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnannInterfaceType_lf_unannClassOrInterfaceTypeContext() *UnannInterfaceType_lf_unannClassOrInterfaceTypeContext {
	var p = new(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_unannInterfaceType_lf_unannClassOrInterfaceType
	return p
}

func (*UnannInterfaceType_lf_unannClassOrInterfaceTypeContext) IsUnannInterfaceType_lf_unannClassOrInterfaceTypeContext() {
}

func NewUnannInterfaceType_lf_unannClassOrInterfaceTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnannInterfaceType_lf_unannClassOrInterfaceTypeContext {
	var p = new(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_unannInterfaceType_lf_unannClassOrInterfaceType

	return p
}

func (s *UnannInterfaceType_lf_unannClassOrInterfaceTypeContext) GetParser() antlr.Parser {
	return s.parser
}

func (s *UnannInterfaceType_lf_unannClassOrInterfaceTypeContext) UnannClassType_lf_unannClassOrInterfaceType() IUnannClassType_lf_unannClassOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannClassType_lf_unannClassOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannClassType_lf_unannClassOrInterfaceTypeContext)
}

func (s *UnannInterfaceType_lf_unannClassOrInterfaceTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnannInterfaceType_lf_unannClassOrInterfaceTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnannInterfaceType_lf_unannClassOrInterfaceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterUnannInterfaceType_lf_unannClassOrInterfaceType(s)
	}
}

func (s *UnannInterfaceType_lf_unannClassOrInterfaceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitUnannInterfaceType_lf_unannClassOrInterfaceType(s)
	}
}

func (p *Java8Parser) UnannInterfaceType_lf_unannClassOrInterfaceType() (localctx IUnannInterfaceType_lf_unannClassOrInterfaceTypeContext) {
	this := p
	_ = this

	localctx = NewUnannInterfaceType_lf_unannClassOrInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 130, Java8ParserRULE_unannInterfaceType_lf_unannClassOrInterfaceType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(958)
		p.UnannClassType_lf_unannClassOrInterfaceType()
	}

	return localctx
}

// IUnannInterfaceType_lfno_unannClassOrInterfaceTypeContext is an interface to support dynamic dispatch.
type IUnannInterfaceType_lfno_unannClassOrInterfaceTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnannInterfaceType_lfno_unannClassOrInterfaceTypeContext differentiates from other interfaces.
	IsUnannInterfaceType_lfno_unannClassOrInterfaceTypeContext()
}

type UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnannInterfaceType_lfno_unannClassOrInterfaceTypeContext() *UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext {
	var p = new(UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_unannInterfaceType_lfno_unannClassOrInterfaceType
	return p
}

func (*UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext) IsUnannInterfaceType_lfno_unannClassOrInterfaceTypeContext() {
}

func NewUnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext {
	var p = new(UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_unannInterfaceType_lfno_unannClassOrInterfaceType

	return p
}

func (s *UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext) GetParser() antlr.Parser {
	return s.parser
}

func (s *UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext) UnannClassType_lfno_unannClassOrInterfaceType() IUnannClassType_lfno_unannClassOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannClassType_lfno_unannClassOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannClassType_lfno_unannClassOrInterfaceTypeContext)
}

func (s *UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterUnannInterfaceType_lfno_unannClassOrInterfaceType(s)
	}
}

func (s *UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitUnannInterfaceType_lfno_unannClassOrInterfaceType(s)
	}
}

func (p *Java8Parser) UnannInterfaceType_lfno_unannClassOrInterfaceType() (localctx IUnannInterfaceType_lfno_unannClassOrInterfaceTypeContext) {
	this := p
	_ = this

	localctx = NewUnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 132, Java8ParserRULE_unannInterfaceType_lfno_unannClassOrInterfaceType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(960)
		p.UnannClassType_lfno_unannClassOrInterfaceType()
	}

	return localctx
}

// IUnannTypeVariableContext is an interface to support dynamic dispatch.
type IUnannTypeVariableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnannTypeVariableContext differentiates from other interfaces.
	IsUnannTypeVariableContext()
}

type UnannTypeVariableContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnannTypeVariableContext() *UnannTypeVariableContext {
	var p = new(UnannTypeVariableContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_unannTypeVariable
	return p
}

func (*UnannTypeVariableContext) IsUnannTypeVariableContext() {}

func NewUnannTypeVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnannTypeVariableContext {
	var p = new(UnannTypeVariableContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_unannTypeVariable

	return p
}

func (s *UnannTypeVariableContext) GetParser() antlr.Parser { return s.parser }

func (s *UnannTypeVariableContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *UnannTypeVariableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnannTypeVariableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnannTypeVariableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterUnannTypeVariable(s)
	}
}

func (s *UnannTypeVariableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitUnannTypeVariable(s)
	}
}

func (p *Java8Parser) UnannTypeVariable() (localctx IUnannTypeVariableContext) {
	this := p
	_ = this

	localctx = NewUnannTypeVariableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 134, Java8ParserRULE_unannTypeVariable)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(962)
		p.Match(Java8ParserIdentifier)
	}

	return localctx
}

// IUnannArrayTypeContext is an interface to support dynamic dispatch.
type IUnannArrayTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnannArrayTypeContext differentiates from other interfaces.
	IsUnannArrayTypeContext()
}

type UnannArrayTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnannArrayTypeContext() *UnannArrayTypeContext {
	var p = new(UnannArrayTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_unannArrayType
	return p
}

func (*UnannArrayTypeContext) IsUnannArrayTypeContext() {}

func NewUnannArrayTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnannArrayTypeContext {
	var p = new(UnannArrayTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_unannArrayType

	return p
}

func (s *UnannArrayTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *UnannArrayTypeContext) UnannPrimitiveType() IUnannPrimitiveTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannPrimitiveTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannPrimitiveTypeContext)
}

func (s *UnannArrayTypeContext) Dims() IDimsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDimsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDimsContext)
}

func (s *UnannArrayTypeContext) UnannClassOrInterfaceType() IUnannClassOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannClassOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannClassOrInterfaceTypeContext)
}

func (s *UnannArrayTypeContext) UnannTypeVariable() IUnannTypeVariableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannTypeVariableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannTypeVariableContext)
}

func (s *UnannArrayTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnannArrayTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnannArrayTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterUnannArrayType(s)
	}
}

func (s *UnannArrayTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitUnannArrayType(s)
	}
}

func (p *Java8Parser) UnannArrayType() (localctx IUnannArrayTypeContext) {
	this := p
	_ = this

	localctx = NewUnannArrayTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 136, Java8ParserRULE_unannArrayType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(973)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 72, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(964)
			p.UnannPrimitiveType()
		}
		{
			p.SetState(965)
			p.Dims()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(967)
			p.UnannClassOrInterfaceType()
		}
		{
			p.SetState(968)
			p.Dims()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(970)
			p.UnannTypeVariable()
		}
		{
			p.SetState(971)
			p.Dims()
		}

	}

	return localctx
}

// IMethodDeclarationContext is an interface to support dynamic dispatch.
type IMethodDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMethodDeclarationContext differentiates from other interfaces.
	IsMethodDeclarationContext()
}

type MethodDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMethodDeclarationContext() *MethodDeclarationContext {
	var p = new(MethodDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_methodDeclaration
	return p
}

func (*MethodDeclarationContext) IsMethodDeclarationContext() {}

func NewMethodDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodDeclarationContext {
	var p = new(MethodDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_methodDeclaration

	return p
}

func (s *MethodDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *MethodDeclarationContext) MethodHeader() IMethodHeaderContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodHeaderContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodHeaderContext)
}

func (s *MethodDeclarationContext) MethodBody() IMethodBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodBodyContext)
}

func (s *MethodDeclarationContext) AllMethodModifier() []IMethodModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IMethodModifierContext)(nil)).Elem())
	var tst = make([]IMethodModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IMethodModifierContext)
		}
	}

	return tst
}

func (s *MethodDeclarationContext) MethodModifier(i int) IMethodModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IMethodModifierContext)
}

func (s *MethodDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MethodDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MethodDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterMethodDeclaration(s)
	}
}

func (s *MethodDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitMethodDeclaration(s)
	}
}

func (p *Java8Parser) MethodDeclaration() (localctx IMethodDeclarationContext) {
	this := p
	_ = this

	localctx = NewMethodDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 138, Java8ParserRULE_methodDeclaration)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(978)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserABSTRACT)|(1<<Java8ParserFINAL)|(1<<Java8ParserNATIVE))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(Java8ParserPRIVATE-33))|(1<<(Java8ParserPROTECTED-33))|(1<<(Java8ParserPUBLIC-33))|(1<<(Java8ParserSTATIC-33))|(1<<(Java8ParserSTRICTFP-33))|(1<<(Java8ParserSYNCHRONIZED-33)))) != 0) || _la == Java8ParserAT {
		{
			p.SetState(975)
			p.MethodModifier()
		}

		p.SetState(980)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(981)
		p.MethodHeader()
	}
	{
		p.SetState(982)
		p.MethodBody()
	}

	return localctx
}

// IMethodModifierContext is an interface to support dynamic dispatch.
type IMethodModifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMethodModifierContext differentiates from other interfaces.
	IsMethodModifierContext()
}

type MethodModifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMethodModifierContext() *MethodModifierContext {
	var p = new(MethodModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_methodModifier
	return p
}

func (*MethodModifierContext) IsMethodModifierContext() {}

func NewMethodModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodModifierContext {
	var p = new(MethodModifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_methodModifier

	return p
}

func (s *MethodModifierContext) GetParser() antlr.Parser { return s.parser }

func (s *MethodModifierContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *MethodModifierContext) PUBLIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserPUBLIC, 0)
}

func (s *MethodModifierContext) PROTECTED() antlr.TerminalNode {
	return s.GetToken(Java8ParserPROTECTED, 0)
}

func (s *MethodModifierContext) PRIVATE() antlr.TerminalNode {
	return s.GetToken(Java8ParserPRIVATE, 0)
}

func (s *MethodModifierContext) ABSTRACT() antlr.TerminalNode {
	return s.GetToken(Java8ParserABSTRACT, 0)
}

func (s *MethodModifierContext) STATIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserSTATIC, 0)
}

func (s *MethodModifierContext) FINAL() antlr.TerminalNode {
	return s.GetToken(Java8ParserFINAL, 0)
}

func (s *MethodModifierContext) SYNCHRONIZED() antlr.TerminalNode {
	return s.GetToken(Java8ParserSYNCHRONIZED, 0)
}

func (s *MethodModifierContext) NATIVE() antlr.TerminalNode {
	return s.GetToken(Java8ParserNATIVE, 0)
}

func (s *MethodModifierContext) STRICTFP() antlr.TerminalNode {
	return s.GetToken(Java8ParserSTRICTFP, 0)
}

func (s *MethodModifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MethodModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MethodModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterMethodModifier(s)
	}
}

func (s *MethodModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitMethodModifier(s)
	}
}

func (p *Java8Parser) MethodModifier() (localctx IMethodModifierContext) {
	this := p
	_ = this

	localctx = NewMethodModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 140, Java8ParserRULE_methodModifier)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(994)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(984)
			p.Annotation()
		}

	case Java8ParserPUBLIC:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(985)
			p.Match(Java8ParserPUBLIC)
		}

	case Java8ParserPROTECTED:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(986)
			p.Match(Java8ParserPROTECTED)
		}

	case Java8ParserPRIVATE:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(987)
			p.Match(Java8ParserPRIVATE)
		}

	case Java8ParserABSTRACT:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(988)
			p.Match(Java8ParserABSTRACT)
		}

	case Java8ParserSTATIC:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(989)
			p.Match(Java8ParserSTATIC)
		}

	case Java8ParserFINAL:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(990)
			p.Match(Java8ParserFINAL)
		}

	case Java8ParserSYNCHRONIZED:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(991)
			p.Match(Java8ParserSYNCHRONIZED)
		}

	case Java8ParserNATIVE:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(992)
			p.Match(Java8ParserNATIVE)
		}

	case Java8ParserSTRICTFP:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(993)
			p.Match(Java8ParserSTRICTFP)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IMethodHeaderContext is an interface to support dynamic dispatch.
type IMethodHeaderContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMethodHeaderContext differentiates from other interfaces.
	IsMethodHeaderContext()
}

type MethodHeaderContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMethodHeaderContext() *MethodHeaderContext {
	var p = new(MethodHeaderContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_methodHeader
	return p
}

func (*MethodHeaderContext) IsMethodHeaderContext() {}

func NewMethodHeaderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodHeaderContext {
	var p = new(MethodHeaderContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_methodHeader

	return p
}

func (s *MethodHeaderContext) GetParser() antlr.Parser { return s.parser }

func (s *MethodHeaderContext) Result() IResultContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResultContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IResultContext)
}

func (s *MethodHeaderContext) MethodDeclarator() IMethodDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodDeclaratorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodDeclaratorContext)
}

func (s *MethodHeaderContext) Throws_() IThrows_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IThrows_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IThrows_Context)
}

func (s *MethodHeaderContext) TypeParameters() ITypeParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

func (s *MethodHeaderContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *MethodHeaderContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *MethodHeaderContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MethodHeaderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MethodHeaderContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterMethodHeader(s)
	}
}

func (s *MethodHeaderContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitMethodHeader(s)
	}
}

func (p *Java8Parser) MethodHeader() (localctx IMethodHeaderContext) {
	this := p
	_ = this

	localctx = NewMethodHeaderContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 142, Java8ParserRULE_methodHeader)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1013)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserBOOLEAN, Java8ParserBYTE, Java8ParserCHAR, Java8ParserDOUBLE, Java8ParserFLOAT, Java8ParserINT, Java8ParserLONG, Java8ParserSHORT, Java8ParserVOID, Java8ParserIdentifier:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(996)
			p.Result()
		}
		{
			p.SetState(997)
			p.MethodDeclarator()
		}
		p.SetState(999)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserTHROWS {
			{
				p.SetState(998)
				p.Throws_()
			}

		}

	case Java8ParserLT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1001)
			p.TypeParameters()
		}
		p.SetState(1005)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserAT {
			{
				p.SetState(1002)
				p.Annotation()
			}

			p.SetState(1007)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1008)
			p.Result()
		}
		{
			p.SetState(1009)
			p.MethodDeclarator()
		}
		p.SetState(1011)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserTHROWS {
			{
				p.SetState(1010)
				p.Throws_()
			}

		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IResultContext is an interface to support dynamic dispatch.
type IResultContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsResultContext differentiates from other interfaces.
	IsResultContext()
}

type ResultContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyResultContext() *ResultContext {
	var p = new(ResultContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_result
	return p
}

func (*ResultContext) IsResultContext() {}

func NewResultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResultContext {
	var p = new(ResultContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_result

	return p
}

func (s *ResultContext) GetParser() antlr.Parser { return s.parser }

func (s *ResultContext) UnannType() IUnannTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannTypeContext)
}

func (s *ResultContext) VOID() antlr.TerminalNode {
	return s.GetToken(Java8ParserVOID, 0)
}

func (s *ResultContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ResultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ResultContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterResult(s)
	}
}

func (s *ResultContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitResult(s)
	}
}

func (p *Java8Parser) Result() (localctx IResultContext) {
	this := p
	_ = this

	localctx = NewResultContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 144, Java8ParserRULE_result)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1017)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserBOOLEAN, Java8ParserBYTE, Java8ParserCHAR, Java8ParserDOUBLE, Java8ParserFLOAT, Java8ParserINT, Java8ParserLONG, Java8ParserSHORT, Java8ParserIdentifier:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1015)
			p.UnannType()
		}

	case Java8ParserVOID:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1016)
			p.Match(Java8ParserVOID)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IMethodDeclaratorContext is an interface to support dynamic dispatch.
type IMethodDeclaratorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMethodDeclaratorContext differentiates from other interfaces.
	IsMethodDeclaratorContext()
}

type MethodDeclaratorContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMethodDeclaratorContext() *MethodDeclaratorContext {
	var p = new(MethodDeclaratorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_methodDeclarator
	return p
}

func (*MethodDeclaratorContext) IsMethodDeclaratorContext() {}

func NewMethodDeclaratorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodDeclaratorContext {
	var p = new(MethodDeclaratorContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_methodDeclarator

	return p
}

func (s *MethodDeclaratorContext) GetParser() antlr.Parser { return s.parser }

func (s *MethodDeclaratorContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *MethodDeclaratorContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *MethodDeclaratorContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *MethodDeclaratorContext) FormalParameterList() IFormalParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterListContext)
}

func (s *MethodDeclaratorContext) Dims() IDimsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDimsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDimsContext)
}

func (s *MethodDeclaratorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MethodDeclaratorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MethodDeclaratorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterMethodDeclarator(s)
	}
}

func (s *MethodDeclaratorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitMethodDeclarator(s)
	}
}

func (p *Java8Parser) MethodDeclarator() (localctx IMethodDeclaratorContext) {
	this := p
	_ = this

	localctx = NewMethodDeclaratorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 146, Java8ParserRULE_methodDeclarator)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1019)
		p.Match(Java8ParserIdentifier)
	}
	{
		p.SetState(1020)
		p.Match(Java8ParserLPAREN)
	}
	p.SetState(1022)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFINAL)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG))) != 0) || _la == Java8ParserSHORT || _la == Java8ParserIdentifier || _la == Java8ParserAT {
		{
			p.SetState(1021)
			p.FormalParameterList()
		}

	}
	{
		p.SetState(1024)
		p.Match(Java8ParserRPAREN)
	}
	p.SetState(1026)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserLBRACK || _la == Java8ParserAT {
		{
			p.SetState(1025)
			p.Dims()
		}

	}

	return localctx
}

// IFormalParameterListContext is an interface to support dynamic dispatch.
type IFormalParameterListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFormalParameterListContext differentiates from other interfaces.
	IsFormalParameterListContext()
}

type FormalParameterListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFormalParameterListContext() *FormalParameterListContext {
	var p = new(FormalParameterListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_formalParameterList
	return p
}

func (*FormalParameterListContext) IsFormalParameterListContext() {}

func NewFormalParameterListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FormalParameterListContext {
	var p = new(FormalParameterListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_formalParameterList

	return p
}

func (s *FormalParameterListContext) GetParser() antlr.Parser { return s.parser }

func (s *FormalParameterListContext) ReceiverParameter() IReceiverParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReceiverParameterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReceiverParameterContext)
}

func (s *FormalParameterListContext) FormalParameters() IFormalParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParametersContext)
}

func (s *FormalParameterListContext) COMMA() antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, 0)
}

func (s *FormalParameterListContext) LastFormalParameter() ILastFormalParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILastFormalParameterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILastFormalParameterContext)
}

func (s *FormalParameterListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FormalParameterListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FormalParameterListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterFormalParameterList(s)
	}
}

func (s *FormalParameterListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitFormalParameterList(s)
	}
}

func (p *Java8Parser) FormalParameterList() (localctx IFormalParameterListContext) {
	this := p
	_ = this

	localctx = NewFormalParameterListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 148, Java8ParserRULE_formalParameterList)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1034)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 82, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1028)
			p.ReceiverParameter()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1029)
			p.FormalParameters()
		}
		{
			p.SetState(1030)
			p.Match(Java8ParserCOMMA)
		}
		{
			p.SetState(1031)
			p.LastFormalParameter()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1033)
			p.LastFormalParameter()
		}

	}

	return localctx
}

// IFormalParametersContext is an interface to support dynamic dispatch.
type IFormalParametersContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFormalParametersContext differentiates from other interfaces.
	IsFormalParametersContext()
}

type FormalParametersContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFormalParametersContext() *FormalParametersContext {
	var p = new(FormalParametersContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_formalParameters
	return p
}

func (*FormalParametersContext) IsFormalParametersContext() {}

func NewFormalParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FormalParametersContext {
	var p = new(FormalParametersContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_formalParameters

	return p
}

func (s *FormalParametersContext) GetParser() antlr.Parser { return s.parser }

func (s *FormalParametersContext) AllFormalParameter() []IFormalParameterContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFormalParameterContext)(nil)).Elem())
	var tst = make([]IFormalParameterContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IFormalParameterContext)
		}
	}

	return tst
}

func (s *FormalParametersContext) FormalParameter(i int) IFormalParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterContext)
}

func (s *FormalParametersContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserCOMMA)
}

func (s *FormalParametersContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, i)
}

func (s *FormalParametersContext) ReceiverParameter() IReceiverParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReceiverParameterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReceiverParameterContext)
}

func (s *FormalParametersContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FormalParametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FormalParametersContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterFormalParameters(s)
	}
}

func (s *FormalParametersContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitFormalParameters(s)
	}
}

func (p *Java8Parser) FormalParameters() (localctx IFormalParametersContext) {
	this := p
	_ = this

	localctx = NewFormalParametersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 150, Java8ParserRULE_formalParameters)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.SetState(1052)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 85, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1036)
			p.FormalParameter()
		}
		p.SetState(1041)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 83, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(1037)
					p.Match(Java8ParserCOMMA)
				}
				{
					p.SetState(1038)
					p.FormalParameter()
				}

			}
			p.SetState(1043)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 83, p.GetParserRuleContext())
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1044)
			p.ReceiverParameter()
		}
		p.SetState(1049)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 84, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(1045)
					p.Match(Java8ParserCOMMA)
				}
				{
					p.SetState(1046)
					p.FormalParameter()
				}

			}
			p.SetState(1051)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 84, p.GetParserRuleContext())
		}

	}

	return localctx
}

// IFormalParameterContext is an interface to support dynamic dispatch.
type IFormalParameterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFormalParameterContext differentiates from other interfaces.
	IsFormalParameterContext()
}

type FormalParameterContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFormalParameterContext() *FormalParameterContext {
	var p = new(FormalParameterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_formalParameter
	return p
}

func (*FormalParameterContext) IsFormalParameterContext() {}

func NewFormalParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FormalParameterContext {
	var p = new(FormalParameterContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_formalParameter

	return p
}

func (s *FormalParameterContext) GetParser() antlr.Parser { return s.parser }

func (s *FormalParameterContext) UnannType() IUnannTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannTypeContext)
}

func (s *FormalParameterContext) VariableDeclaratorId() IVariableDeclaratorIdContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorIdContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorIdContext)
}

func (s *FormalParameterContext) AllVariableModifier() []IVariableModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem())
	var tst = make([]IVariableModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IVariableModifierContext)
		}
	}

	return tst
}

func (s *FormalParameterContext) VariableModifier(i int) IVariableModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableModifierContext)
}

func (s *FormalParameterContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FormalParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FormalParameterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterFormalParameter(s)
	}
}

func (s *FormalParameterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitFormalParameter(s)
	}
}

func (p *Java8Parser) FormalParameter() (localctx IFormalParameterContext) {
	this := p
	_ = this

	localctx = NewFormalParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 152, Java8ParserRULE_formalParameter)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1057)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserFINAL || _la == Java8ParserAT {
		{
			p.SetState(1054)
			p.VariableModifier()
		}

		p.SetState(1059)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1060)
		p.UnannType()
	}
	{
		p.SetState(1061)
		p.VariableDeclaratorId()
	}

	return localctx
}

// IVariableModifierContext is an interface to support dynamic dispatch.
type IVariableModifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsVariableModifierContext differentiates from other interfaces.
	IsVariableModifierContext()
}

type VariableModifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVariableModifierContext() *VariableModifierContext {
	var p = new(VariableModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_variableModifier
	return p
}

func (*VariableModifierContext) IsVariableModifierContext() {}

func NewVariableModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableModifierContext {
	var p = new(VariableModifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_variableModifier

	return p
}

func (s *VariableModifierContext) GetParser() antlr.Parser { return s.parser }

func (s *VariableModifierContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *VariableModifierContext) FINAL() antlr.TerminalNode {
	return s.GetToken(Java8ParserFINAL, 0)
}

func (s *VariableModifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VariableModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VariableModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterVariableModifier(s)
	}
}

func (s *VariableModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitVariableModifier(s)
	}
}

func (p *Java8Parser) VariableModifier() (localctx IVariableModifierContext) {
	this := p
	_ = this

	localctx = NewVariableModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 154, Java8ParserRULE_variableModifier)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1065)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1063)
			p.Annotation()
		}

	case Java8ParserFINAL:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1064)
			p.Match(Java8ParserFINAL)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// ILastFormalParameterContext is an interface to support dynamic dispatch.
type ILastFormalParameterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLastFormalParameterContext differentiates from other interfaces.
	IsLastFormalParameterContext()
}

type LastFormalParameterContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLastFormalParameterContext() *LastFormalParameterContext {
	var p = new(LastFormalParameterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_lastFormalParameter
	return p
}

func (*LastFormalParameterContext) IsLastFormalParameterContext() {}

func NewLastFormalParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LastFormalParameterContext {
	var p = new(LastFormalParameterContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_lastFormalParameter

	return p
}

func (s *LastFormalParameterContext) GetParser() antlr.Parser { return s.parser }

func (s *LastFormalParameterContext) UnannType() IUnannTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannTypeContext)
}

func (s *LastFormalParameterContext) ELLIPSIS() antlr.TerminalNode {
	return s.GetToken(Java8ParserELLIPSIS, 0)
}

func (s *LastFormalParameterContext) VariableDeclaratorId() IVariableDeclaratorIdContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorIdContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorIdContext)
}

func (s *LastFormalParameterContext) AllVariableModifier() []IVariableModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem())
	var tst = make([]IVariableModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IVariableModifierContext)
		}
	}

	return tst
}

func (s *LastFormalParameterContext) VariableModifier(i int) IVariableModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableModifierContext)
}

func (s *LastFormalParameterContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *LastFormalParameterContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *LastFormalParameterContext) FormalParameter() IFormalParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterContext)
}

func (s *LastFormalParameterContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LastFormalParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LastFormalParameterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterLastFormalParameter(s)
	}
}

func (s *LastFormalParameterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitLastFormalParameter(s)
	}
}

func (p *Java8Parser) LastFormalParameter() (localctx ILastFormalParameterContext) {
	this := p
	_ = this

	localctx = NewLastFormalParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 156, Java8ParserRULE_lastFormalParameter)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1084)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 90, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(1070)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserFINAL || _la == Java8ParserAT {
			{
				p.SetState(1067)
				p.VariableModifier()
			}

			p.SetState(1072)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1073)
			p.UnannType()
		}
		p.SetState(1077)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserAT {
			{
				p.SetState(1074)
				p.Annotation()
			}

			p.SetState(1079)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1080)
			p.Match(Java8ParserELLIPSIS)
		}
		{
			p.SetState(1081)
			p.VariableDeclaratorId()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1083)
			p.FormalParameter()
		}

	}

	return localctx
}

// IReceiverParameterContext is an interface to support dynamic dispatch.
type IReceiverParameterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsReceiverParameterContext differentiates from other interfaces.
	IsReceiverParameterContext()
}

type ReceiverParameterContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReceiverParameterContext() *ReceiverParameterContext {
	var p = new(ReceiverParameterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_receiverParameter
	return p
}

func (*ReceiverParameterContext) IsReceiverParameterContext() {}

func NewReceiverParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReceiverParameterContext {
	var p = new(ReceiverParameterContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_receiverParameter

	return p
}

func (s *ReceiverParameterContext) GetParser() antlr.Parser { return s.parser }

func (s *ReceiverParameterContext) UnannType() IUnannTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannTypeContext)
}

func (s *ReceiverParameterContext) THIS() antlr.TerminalNode {
	return s.GetToken(Java8ParserTHIS, 0)
}

func (s *ReceiverParameterContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *ReceiverParameterContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *ReceiverParameterContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *ReceiverParameterContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *ReceiverParameterContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ReceiverParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ReceiverParameterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterReceiverParameter(s)
	}
}

func (s *ReceiverParameterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitReceiverParameter(s)
	}
}

func (p *Java8Parser) ReceiverParameter() (localctx IReceiverParameterContext) {
	this := p
	_ = this

	localctx = NewReceiverParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 158, Java8ParserRULE_receiverParameter)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1089)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserAT {
		{
			p.SetState(1086)
			p.Annotation()
		}

		p.SetState(1091)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1092)
		p.UnannType()
	}
	p.SetState(1095)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserIdentifier {
		{
			p.SetState(1093)
			p.Match(Java8ParserIdentifier)
		}
		{
			p.SetState(1094)
			p.Match(Java8ParserDOT)
		}

	}
	{
		p.SetState(1097)
		p.Match(Java8ParserTHIS)
	}

	return localctx
}

// IThrows_Context is an interface to support dynamic dispatch.
type IThrows_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsThrows_Context differentiates from other interfaces.
	IsThrows_Context()
}

type Throws_Context struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyThrows_Context() *Throws_Context {
	var p = new(Throws_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_throws_
	return p
}

func (*Throws_Context) IsThrows_Context() {}

func NewThrows_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Throws_Context {
	var p = new(Throws_Context)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_throws_

	return p
}

func (s *Throws_Context) GetParser() antlr.Parser { return s.parser }

func (s *Throws_Context) THROWS() antlr.TerminalNode {
	return s.GetToken(Java8ParserTHROWS, 0)
}

func (s *Throws_Context) ExceptionTypeList() IExceptionTypeListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExceptionTypeListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExceptionTypeListContext)
}

func (s *Throws_Context) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Throws_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Throws_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterThrows_(s)
	}
}

func (s *Throws_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitThrows_(s)
	}
}

func (p *Java8Parser) Throws_() (localctx IThrows_Context) {
	this := p
	_ = this

	localctx = NewThrows_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 160, Java8ParserRULE_throws_)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1099)
		p.Match(Java8ParserTHROWS)
	}
	{
		p.SetState(1100)
		p.ExceptionTypeList()
	}

	return localctx
}

// IExceptionTypeListContext is an interface to support dynamic dispatch.
type IExceptionTypeListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExceptionTypeListContext differentiates from other interfaces.
	IsExceptionTypeListContext()
}

type ExceptionTypeListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExceptionTypeListContext() *ExceptionTypeListContext {
	var p = new(ExceptionTypeListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_exceptionTypeList
	return p
}

func (*ExceptionTypeListContext) IsExceptionTypeListContext() {}

func NewExceptionTypeListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExceptionTypeListContext {
	var p = new(ExceptionTypeListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_exceptionTypeList

	return p
}

func (s *ExceptionTypeListContext) GetParser() antlr.Parser { return s.parser }

func (s *ExceptionTypeListContext) AllExceptionType() []IExceptionTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExceptionTypeContext)(nil)).Elem())
	var tst = make([]IExceptionTypeContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IExceptionTypeContext)
		}
	}

	return tst
}

func (s *ExceptionTypeListContext) ExceptionType(i int) IExceptionTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExceptionTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExceptionTypeContext)
}

func (s *ExceptionTypeListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserCOMMA)
}

func (s *ExceptionTypeListContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, i)
}

func (s *ExceptionTypeListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExceptionTypeListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExceptionTypeListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterExceptionTypeList(s)
	}
}

func (s *ExceptionTypeListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitExceptionTypeList(s)
	}
}

func (p *Java8Parser) ExceptionTypeList() (localctx IExceptionTypeListContext) {
	this := p
	_ = this

	localctx = NewExceptionTypeListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 162, Java8ParserRULE_exceptionTypeList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1102)
		p.ExceptionType()
	}
	p.SetState(1107)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserCOMMA {
		{
			p.SetState(1103)
			p.Match(Java8ParserCOMMA)
		}
		{
			p.SetState(1104)
			p.ExceptionType()
		}

		p.SetState(1109)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IExceptionTypeContext is an interface to support dynamic dispatch.
type IExceptionTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExceptionTypeContext differentiates from other interfaces.
	IsExceptionTypeContext()
}

type ExceptionTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExceptionTypeContext() *ExceptionTypeContext {
	var p = new(ExceptionTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_exceptionType
	return p
}

func (*ExceptionTypeContext) IsExceptionTypeContext() {}

func NewExceptionTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExceptionTypeContext {
	var p = new(ExceptionTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_exceptionType

	return p
}

func (s *ExceptionTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *ExceptionTypeContext) ClassType() IClassTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassTypeContext)
}

func (s *ExceptionTypeContext) TypeVariable() ITypeVariableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeVariableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeVariableContext)
}

func (s *ExceptionTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExceptionTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExceptionTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterExceptionType(s)
	}
}

func (s *ExceptionTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitExceptionType(s)
	}
}

func (p *Java8Parser) ExceptionType() (localctx IExceptionTypeContext) {
	this := p
	_ = this

	localctx = NewExceptionTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 164, Java8ParserRULE_exceptionType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1112)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 94, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1110)
			p.ClassType()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1111)
			p.TypeVariable()
		}

	}

	return localctx
}

// IMethodBodyContext is an interface to support dynamic dispatch.
type IMethodBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMethodBodyContext differentiates from other interfaces.
	IsMethodBodyContext()
}

type MethodBodyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMethodBodyContext() *MethodBodyContext {
	var p = new(MethodBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_methodBody
	return p
}

func (*MethodBodyContext) IsMethodBodyContext() {}

func NewMethodBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodBodyContext {
	var p = new(MethodBodyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_methodBody

	return p
}

func (s *MethodBodyContext) GetParser() antlr.Parser { return s.parser }

func (s *MethodBodyContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *MethodBodyContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *MethodBodyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MethodBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MethodBodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterMethodBody(s)
	}
}

func (s *MethodBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitMethodBody(s)
	}
}

func (p *Java8Parser) MethodBody() (localctx IMethodBodyContext) {
	this := p
	_ = this

	localctx = NewMethodBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 166, Java8ParserRULE_methodBody)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1116)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserLBRACE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1114)
			p.Block()
		}

	case Java8ParserSEMI:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1115)
			p.Match(Java8ParserSEMI)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IInstanceInitializerContext is an interface to support dynamic dispatch.
type IInstanceInitializerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInstanceInitializerContext differentiates from other interfaces.
	IsInstanceInitializerContext()
}

type InstanceInitializerContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInstanceInitializerContext() *InstanceInitializerContext {
	var p = new(InstanceInitializerContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_instanceInitializer
	return p
}

func (*InstanceInitializerContext) IsInstanceInitializerContext() {}

func NewInstanceInitializerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InstanceInitializerContext {
	var p = new(InstanceInitializerContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_instanceInitializer

	return p
}

func (s *InstanceInitializerContext) GetParser() antlr.Parser { return s.parser }

func (s *InstanceInitializerContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *InstanceInitializerContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InstanceInitializerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InstanceInitializerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterInstanceInitializer(s)
	}
}

func (s *InstanceInitializerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitInstanceInitializer(s)
	}
}

func (p *Java8Parser) InstanceInitializer() (localctx IInstanceInitializerContext) {
	this := p
	_ = this

	localctx = NewInstanceInitializerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 168, Java8ParserRULE_instanceInitializer)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1118)
		p.Block()
	}

	return localctx
}

// IStaticInitializerContext is an interface to support dynamic dispatch.
type IStaticInitializerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStaticInitializerContext differentiates from other interfaces.
	IsStaticInitializerContext()
}

type StaticInitializerContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStaticInitializerContext() *StaticInitializerContext {
	var p = new(StaticInitializerContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_staticInitializer
	return p
}

func (*StaticInitializerContext) IsStaticInitializerContext() {}

func NewStaticInitializerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StaticInitializerContext {
	var p = new(StaticInitializerContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_staticInitializer

	return p
}

func (s *StaticInitializerContext) GetParser() antlr.Parser { return s.parser }

func (s *StaticInitializerContext) STATIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserSTATIC, 0)
}

func (s *StaticInitializerContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *StaticInitializerContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StaticInitializerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StaticInitializerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterStaticInitializer(s)
	}
}

func (s *StaticInitializerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitStaticInitializer(s)
	}
}

func (p *Java8Parser) StaticInitializer() (localctx IStaticInitializerContext) {
	this := p
	_ = this

	localctx = NewStaticInitializerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 170, Java8ParserRULE_staticInitializer)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1120)
		p.Match(Java8ParserSTATIC)
	}
	{
		p.SetState(1121)
		p.Block()
	}

	return localctx
}

// IConstructorDeclarationContext is an interface to support dynamic dispatch.
type IConstructorDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConstructorDeclarationContext differentiates from other interfaces.
	IsConstructorDeclarationContext()
}

type ConstructorDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstructorDeclarationContext() *ConstructorDeclarationContext {
	var p = new(ConstructorDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_constructorDeclaration
	return p
}

func (*ConstructorDeclarationContext) IsConstructorDeclarationContext() {}

func NewConstructorDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstructorDeclarationContext {
	var p = new(ConstructorDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_constructorDeclaration

	return p
}

func (s *ConstructorDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstructorDeclarationContext) ConstructorDeclarator() IConstructorDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstructorDeclaratorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstructorDeclaratorContext)
}

func (s *ConstructorDeclarationContext) ConstructorBody() IConstructorBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstructorBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstructorBodyContext)
}

func (s *ConstructorDeclarationContext) AllConstructorModifier() []IConstructorModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IConstructorModifierContext)(nil)).Elem())
	var tst = make([]IConstructorModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IConstructorModifierContext)
		}
	}

	return tst
}

func (s *ConstructorDeclarationContext) ConstructorModifier(i int) IConstructorModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstructorModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IConstructorModifierContext)
}

func (s *ConstructorDeclarationContext) Throws_() IThrows_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IThrows_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IThrows_Context)
}

func (s *ConstructorDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstructorDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstructorDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterConstructorDeclaration(s)
	}
}

func (s *ConstructorDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitConstructorDeclaration(s)
	}
}

func (p *Java8Parser) ConstructorDeclaration() (localctx IConstructorDeclarationContext) {
	this := p
	_ = this

	localctx = NewConstructorDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 172, Java8ParserRULE_constructorDeclaration)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1126)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(Java8ParserPRIVATE-33))|(1<<(Java8ParserPROTECTED-33))|(1<<(Java8ParserPUBLIC-33)))) != 0) || _la == Java8ParserAT {
		{
			p.SetState(1123)
			p.ConstructorModifier()
		}

		p.SetState(1128)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1129)
		p.ConstructorDeclarator()
	}
	p.SetState(1131)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserTHROWS {
		{
			p.SetState(1130)
			p.Throws_()
		}

	}
	{
		p.SetState(1133)
		p.ConstructorBody()
	}

	return localctx
}

// IConstructorModifierContext is an interface to support dynamic dispatch.
type IConstructorModifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConstructorModifierContext differentiates from other interfaces.
	IsConstructorModifierContext()
}

type ConstructorModifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstructorModifierContext() *ConstructorModifierContext {
	var p = new(ConstructorModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_constructorModifier
	return p
}

func (*ConstructorModifierContext) IsConstructorModifierContext() {}

func NewConstructorModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstructorModifierContext {
	var p = new(ConstructorModifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_constructorModifier

	return p
}

func (s *ConstructorModifierContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstructorModifierContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *ConstructorModifierContext) PUBLIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserPUBLIC, 0)
}

func (s *ConstructorModifierContext) PROTECTED() antlr.TerminalNode {
	return s.GetToken(Java8ParserPROTECTED, 0)
}

func (s *ConstructorModifierContext) PRIVATE() antlr.TerminalNode {
	return s.GetToken(Java8ParserPRIVATE, 0)
}

func (s *ConstructorModifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstructorModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstructorModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterConstructorModifier(s)
	}
}

func (s *ConstructorModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitConstructorModifier(s)
	}
}

func (p *Java8Parser) ConstructorModifier() (localctx IConstructorModifierContext) {
	this := p
	_ = this

	localctx = NewConstructorModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 174, Java8ParserRULE_constructorModifier)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1139)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1135)
			p.Annotation()
		}

	case Java8ParserPUBLIC:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1136)
			p.Match(Java8ParserPUBLIC)
		}

	case Java8ParserPROTECTED:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1137)
			p.Match(Java8ParserPROTECTED)
		}

	case Java8ParserPRIVATE:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1138)
			p.Match(Java8ParserPRIVATE)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IConstructorDeclaratorContext is an interface to support dynamic dispatch.
type IConstructorDeclaratorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConstructorDeclaratorContext differentiates from other interfaces.
	IsConstructorDeclaratorContext()
}

type ConstructorDeclaratorContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstructorDeclaratorContext() *ConstructorDeclaratorContext {
	var p = new(ConstructorDeclaratorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_constructorDeclarator
	return p
}

func (*ConstructorDeclaratorContext) IsConstructorDeclaratorContext() {}

func NewConstructorDeclaratorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstructorDeclaratorContext {
	var p = new(ConstructorDeclaratorContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_constructorDeclarator

	return p
}

func (s *ConstructorDeclaratorContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstructorDeclaratorContext) SimpleTypeName() ISimpleTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISimpleTypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISimpleTypeNameContext)
}

func (s *ConstructorDeclaratorContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *ConstructorDeclaratorContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *ConstructorDeclaratorContext) TypeParameters() ITypeParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

func (s *ConstructorDeclaratorContext) FormalParameterList() IFormalParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterListContext)
}

func (s *ConstructorDeclaratorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstructorDeclaratorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstructorDeclaratorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterConstructorDeclarator(s)
	}
}

func (s *ConstructorDeclaratorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitConstructorDeclarator(s)
	}
}

func (p *Java8Parser) ConstructorDeclarator() (localctx IConstructorDeclaratorContext) {
	this := p
	_ = this

	localctx = NewConstructorDeclaratorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 176, Java8ParserRULE_constructorDeclarator)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1142)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserLT {
		{
			p.SetState(1141)
			p.TypeParameters()
		}

	}
	{
		p.SetState(1144)
		p.SimpleTypeName()
	}
	{
		p.SetState(1145)
		p.Match(Java8ParserLPAREN)
	}
	p.SetState(1147)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFINAL)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG))) != 0) || _la == Java8ParserSHORT || _la == Java8ParserIdentifier || _la == Java8ParserAT {
		{
			p.SetState(1146)
			p.FormalParameterList()
		}

	}
	{
		p.SetState(1149)
		p.Match(Java8ParserRPAREN)
	}

	return localctx
}

// ISimpleTypeNameContext is an interface to support dynamic dispatch.
type ISimpleTypeNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSimpleTypeNameContext differentiates from other interfaces.
	IsSimpleTypeNameContext()
}

type SimpleTypeNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySimpleTypeNameContext() *SimpleTypeNameContext {
	var p = new(SimpleTypeNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_simpleTypeName
	return p
}

func (*SimpleTypeNameContext) IsSimpleTypeNameContext() {}

func NewSimpleTypeNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleTypeNameContext {
	var p = new(SimpleTypeNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_simpleTypeName

	return p
}

func (s *SimpleTypeNameContext) GetParser() antlr.Parser { return s.parser }

func (s *SimpleTypeNameContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *SimpleTypeNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SimpleTypeNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SimpleTypeNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterSimpleTypeName(s)
	}
}

func (s *SimpleTypeNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitSimpleTypeName(s)
	}
}

func (p *Java8Parser) SimpleTypeName() (localctx ISimpleTypeNameContext) {
	this := p
	_ = this

	localctx = NewSimpleTypeNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 178, Java8ParserRULE_simpleTypeName)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1151)
		p.Match(Java8ParserIdentifier)
	}

	return localctx
}

// IConstructorBodyContext is an interface to support dynamic dispatch.
type IConstructorBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConstructorBodyContext differentiates from other interfaces.
	IsConstructorBodyContext()
}

type ConstructorBodyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstructorBodyContext() *ConstructorBodyContext {
	var p = new(ConstructorBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_constructorBody
	return p
}

func (*ConstructorBodyContext) IsConstructorBodyContext() {}

func NewConstructorBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstructorBodyContext {
	var p = new(ConstructorBodyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_constructorBody

	return p
}

func (s *ConstructorBodyContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstructorBodyContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACE, 0)
}

func (s *ConstructorBodyContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACE, 0)
}

func (s *ConstructorBodyContext) ExplicitConstructorInvocation() IExplicitConstructorInvocationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExplicitConstructorInvocationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExplicitConstructorInvocationContext)
}

func (s *ConstructorBodyContext) BlockStatements() IBlockStatementsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockStatementsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockStatementsContext)
}

func (s *ConstructorBodyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstructorBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstructorBodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterConstructorBody(s)
	}
}

func (s *ConstructorBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitConstructorBody(s)
	}
}

func (p *Java8Parser) ConstructorBody() (localctx IConstructorBodyContext) {
	this := p
	_ = this

	localctx = NewConstructorBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 180, Java8ParserRULE_constructorBody)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1153)
		p.Match(Java8ParserLBRACE)
	}
	p.SetState(1155)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 101, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1154)
			p.ExplicitConstructorInvocation()
		}

	}
	p.SetState(1158)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserABSTRACT)|(1<<Java8ParserASSERT)|(1<<Java8ParserBOOLEAN)|(1<<Java8ParserBREAK)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserCLASS)|(1<<Java8ParserCONTINUE)|(1<<Java8ParserDO)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserENUM)|(1<<Java8ParserFINAL)|(1<<Java8ParserFLOAT)|(1<<Java8ParserFOR)|(1<<Java8ParserIF)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(Java8ParserPRIVATE-33))|(1<<(Java8ParserPROTECTED-33))|(1<<(Java8ParserPUBLIC-33))|(1<<(Java8ParserRETURN-33))|(1<<(Java8ParserSHORT-33))|(1<<(Java8ParserSTATIC-33))|(1<<(Java8ParserSTRICTFP-33))|(1<<(Java8ParserSUPER-33))|(1<<(Java8ParserSWITCH-33))|(1<<(Java8ParserSYNCHRONIZED-33))|(1<<(Java8ParserTHIS-33))|(1<<(Java8ParserTHROW-33))|(1<<(Java8ParserTRY-33))|(1<<(Java8ParserVOID-33))|(1<<(Java8ParserWHILE-33))|(1<<(Java8ParserIntegerLiteral-33))|(1<<(Java8ParserFloatingPointLiteral-33))|(1<<(Java8ParserBooleanLiteral-33))|(1<<(Java8ParserCharacterLiteral-33))|(1<<(Java8ParserStringLiteral-33))|(1<<(Java8ParserNullLiteral-33))|(1<<(Java8ParserLPAREN-33))|(1<<(Java8ParserLBRACE-33))|(1<<(Java8ParserSEMI-33)))) != 0) || (((_la-79)&-(0x1f+1)) == 0 && ((1<<uint((_la-79)))&((1<<(Java8ParserINC-79))|(1<<(Java8ParserDEC-79))|(1<<(Java8ParserIdentifier-79))|(1<<(Java8ParserAT-79)))) != 0) {
		{
			p.SetState(1157)
			p.BlockStatements()
		}

	}
	{
		p.SetState(1160)
		p.Match(Java8ParserRBRACE)
	}

	return localctx
}

// IExplicitConstructorInvocationContext is an interface to support dynamic dispatch.
type IExplicitConstructorInvocationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExplicitConstructorInvocationContext differentiates from other interfaces.
	IsExplicitConstructorInvocationContext()
}

type ExplicitConstructorInvocationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExplicitConstructorInvocationContext() *ExplicitConstructorInvocationContext {
	var p = new(ExplicitConstructorInvocationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_explicitConstructorInvocation
	return p
}

func (*ExplicitConstructorInvocationContext) IsExplicitConstructorInvocationContext() {}

func NewExplicitConstructorInvocationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExplicitConstructorInvocationContext {
	var p = new(ExplicitConstructorInvocationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_explicitConstructorInvocation

	return p
}

func (s *ExplicitConstructorInvocationContext) GetParser() antlr.Parser { return s.parser }

func (s *ExplicitConstructorInvocationContext) THIS() antlr.TerminalNode {
	return s.GetToken(Java8ParserTHIS, 0)
}

func (s *ExplicitConstructorInvocationContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *ExplicitConstructorInvocationContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *ExplicitConstructorInvocationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *ExplicitConstructorInvocationContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *ExplicitConstructorInvocationContext) ArgumentList() IArgumentListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentListContext)
}

func (s *ExplicitConstructorInvocationContext) SUPER() antlr.TerminalNode {
	return s.GetToken(Java8ParserSUPER, 0)
}

func (s *ExplicitConstructorInvocationContext) ExpressionName() IExpressionNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionNameContext)
}

func (s *ExplicitConstructorInvocationContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *ExplicitConstructorInvocationContext) Primary() IPrimaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryContext)
}

func (s *ExplicitConstructorInvocationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExplicitConstructorInvocationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExplicitConstructorInvocationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterExplicitConstructorInvocation(s)
	}
}

func (s *ExplicitConstructorInvocationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitExplicitConstructorInvocation(s)
	}
}

func (p *Java8Parser) ExplicitConstructorInvocation() (localctx IExplicitConstructorInvocationContext) {
	this := p
	_ = this

	localctx = NewExplicitConstructorInvocationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 182, Java8ParserRULE_explicitConstructorInvocation)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1208)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 111, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(1163)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(1162)
				p.TypeArguments()
			}

		}
		{
			p.SetState(1165)
			p.Match(Java8ParserTHIS)
		}
		{
			p.SetState(1166)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(1168)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(1167)
				p.ArgumentList()
			}

		}
		{
			p.SetState(1170)
			p.Match(Java8ParserRPAREN)
		}
		{
			p.SetState(1171)
			p.Match(Java8ParserSEMI)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(1173)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(1172)
				p.TypeArguments()
			}

		}
		{
			p.SetState(1175)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(1176)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(1178)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(1177)
				p.ArgumentList()
			}

		}
		{
			p.SetState(1180)
			p.Match(Java8ParserRPAREN)
		}
		{
			p.SetState(1181)
			p.Match(Java8ParserSEMI)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1182)
			p.ExpressionName()
		}
		{
			p.SetState(1183)
			p.Match(Java8ParserDOT)
		}
		p.SetState(1185)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(1184)
				p.TypeArguments()
			}

		}
		{
			p.SetState(1187)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(1188)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(1190)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(1189)
				p.ArgumentList()
			}

		}
		{
			p.SetState(1192)
			p.Match(Java8ParserRPAREN)
		}
		{
			p.SetState(1193)
			p.Match(Java8ParserSEMI)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1195)
			p.Primary()
		}
		{
			p.SetState(1196)
			p.Match(Java8ParserDOT)
		}
		p.SetState(1198)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(1197)
				p.TypeArguments()
			}

		}
		{
			p.SetState(1200)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(1201)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(1203)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(1202)
				p.ArgumentList()
			}

		}
		{
			p.SetState(1205)
			p.Match(Java8ParserRPAREN)
		}
		{
			p.SetState(1206)
			p.Match(Java8ParserSEMI)
		}

	}

	return localctx
}

// IEnumDeclarationContext is an interface to support dynamic dispatch.
type IEnumDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEnumDeclarationContext differentiates from other interfaces.
	IsEnumDeclarationContext()
}

type EnumDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEnumDeclarationContext() *EnumDeclarationContext {
	var p = new(EnumDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_enumDeclaration
	return p
}

func (*EnumDeclarationContext) IsEnumDeclarationContext() {}

func NewEnumDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumDeclarationContext {
	var p = new(EnumDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_enumDeclaration

	return p
}

func (s *EnumDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *EnumDeclarationContext) ENUM() antlr.TerminalNode {
	return s.GetToken(Java8ParserENUM, 0)
}

func (s *EnumDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *EnumDeclarationContext) EnumBody() IEnumBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumBodyContext)
}

func (s *EnumDeclarationContext) AllClassModifier() []IClassModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IClassModifierContext)(nil)).Elem())
	var tst = make([]IClassModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IClassModifierContext)
		}
	}

	return tst
}

func (s *EnumDeclarationContext) ClassModifier(i int) IClassModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IClassModifierContext)
}

func (s *EnumDeclarationContext) Superinterfaces() ISuperinterfacesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISuperinterfacesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISuperinterfacesContext)
}

func (s *EnumDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EnumDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EnumDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterEnumDeclaration(s)
	}
}

func (s *EnumDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitEnumDeclaration(s)
	}
}

func (p *Java8Parser) EnumDeclaration() (localctx IEnumDeclarationContext) {
	this := p
	_ = this

	localctx = NewEnumDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 184, Java8ParserRULE_enumDeclaration)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1213)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserABSTRACT || _la == Java8ParserFINAL || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(Java8ParserPRIVATE-33))|(1<<(Java8ParserPROTECTED-33))|(1<<(Java8ParserPUBLIC-33))|(1<<(Java8ParserSTATIC-33))|(1<<(Java8ParserSTRICTFP-33)))) != 0) || _la == Java8ParserAT {
		{
			p.SetState(1210)
			p.ClassModifier()
		}

		p.SetState(1215)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1216)
		p.Match(Java8ParserENUM)
	}
	{
		p.SetState(1217)
		p.Match(Java8ParserIdentifier)
	}
	p.SetState(1219)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserIMPLEMENTS {
		{
			p.SetState(1218)
			p.Superinterfaces()
		}

	}
	{
		p.SetState(1221)
		p.EnumBody()
	}

	return localctx
}

// IEnumBodyContext is an interface to support dynamic dispatch.
type IEnumBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEnumBodyContext differentiates from other interfaces.
	IsEnumBodyContext()
}

type EnumBodyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEnumBodyContext() *EnumBodyContext {
	var p = new(EnumBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_enumBody
	return p
}

func (*EnumBodyContext) IsEnumBodyContext() {}

func NewEnumBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumBodyContext {
	var p = new(EnumBodyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_enumBody

	return p
}

func (s *EnumBodyContext) GetParser() antlr.Parser { return s.parser }

func (s *EnumBodyContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACE, 0)
}

func (s *EnumBodyContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACE, 0)
}

func (s *EnumBodyContext) EnumConstantList() IEnumConstantListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumConstantListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumConstantListContext)
}

func (s *EnumBodyContext) COMMA() antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, 0)
}

func (s *EnumBodyContext) EnumBodyDeclarations() IEnumBodyDeclarationsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumBodyDeclarationsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumBodyDeclarationsContext)
}

func (s *EnumBodyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EnumBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EnumBodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterEnumBody(s)
	}
}

func (s *EnumBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitEnumBody(s)
	}
}

func (p *Java8Parser) EnumBody() (localctx IEnumBodyContext) {
	this := p
	_ = this

	localctx = NewEnumBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 186, Java8ParserRULE_enumBody)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1223)
		p.Match(Java8ParserLBRACE)
	}
	p.SetState(1225)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserIdentifier || _la == Java8ParserAT {
		{
			p.SetState(1224)
			p.EnumConstantList()
		}

	}
	p.SetState(1228)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserCOMMA {
		{
			p.SetState(1227)
			p.Match(Java8ParserCOMMA)
		}

	}
	p.SetState(1231)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserSEMI {
		{
			p.SetState(1230)
			p.EnumBodyDeclarations()
		}

	}
	{
		p.SetState(1233)
		p.Match(Java8ParserRBRACE)
	}

	return localctx
}

// IEnumConstantListContext is an interface to support dynamic dispatch.
type IEnumConstantListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEnumConstantListContext differentiates from other interfaces.
	IsEnumConstantListContext()
}

type EnumConstantListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEnumConstantListContext() *EnumConstantListContext {
	var p = new(EnumConstantListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_enumConstantList
	return p
}

func (*EnumConstantListContext) IsEnumConstantListContext() {}

func NewEnumConstantListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumConstantListContext {
	var p = new(EnumConstantListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_enumConstantList

	return p
}

func (s *EnumConstantListContext) GetParser() antlr.Parser { return s.parser }

func (s *EnumConstantListContext) AllEnumConstant() []IEnumConstantContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEnumConstantContext)(nil)).Elem())
	var tst = make([]IEnumConstantContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IEnumConstantContext)
		}
	}

	return tst
}

func (s *EnumConstantListContext) EnumConstant(i int) IEnumConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumConstantContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEnumConstantContext)
}

func (s *EnumConstantListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserCOMMA)
}

func (s *EnumConstantListContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, i)
}

func (s *EnumConstantListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EnumConstantListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EnumConstantListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterEnumConstantList(s)
	}
}

func (s *EnumConstantListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitEnumConstantList(s)
	}
}

func (p *Java8Parser) EnumConstantList() (localctx IEnumConstantListContext) {
	this := p
	_ = this

	localctx = NewEnumConstantListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 188, Java8ParserRULE_enumConstantList)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1235)
		p.EnumConstant()
	}
	p.SetState(1240)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 117, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1236)
				p.Match(Java8ParserCOMMA)
			}
			{
				p.SetState(1237)
				p.EnumConstant()
			}

		}
		p.SetState(1242)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 117, p.GetParserRuleContext())
	}

	return localctx
}

// IEnumConstantContext is an interface to support dynamic dispatch.
type IEnumConstantContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEnumConstantContext differentiates from other interfaces.
	IsEnumConstantContext()
}

type EnumConstantContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEnumConstantContext() *EnumConstantContext {
	var p = new(EnumConstantContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_enumConstant
	return p
}

func (*EnumConstantContext) IsEnumConstantContext() {}

func NewEnumConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumConstantContext {
	var p = new(EnumConstantContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_enumConstant

	return p
}

func (s *EnumConstantContext) GetParser() antlr.Parser { return s.parser }

func (s *EnumConstantContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *EnumConstantContext) AllEnumConstantModifier() []IEnumConstantModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEnumConstantModifierContext)(nil)).Elem())
	var tst = make([]IEnumConstantModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IEnumConstantModifierContext)
		}
	}

	return tst
}

func (s *EnumConstantContext) EnumConstantModifier(i int) IEnumConstantModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumConstantModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEnumConstantModifierContext)
}

func (s *EnumConstantContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *EnumConstantContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *EnumConstantContext) ClassBody() IClassBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassBodyContext)
}

func (s *EnumConstantContext) ArgumentList() IArgumentListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentListContext)
}

func (s *EnumConstantContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EnumConstantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EnumConstantContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterEnumConstant(s)
	}
}

func (s *EnumConstantContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitEnumConstant(s)
	}
}

func (p *Java8Parser) EnumConstant() (localctx IEnumConstantContext) {
	this := p
	_ = this

	localctx = NewEnumConstantContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 190, Java8ParserRULE_enumConstant)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1246)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserAT {
		{
			p.SetState(1243)
			p.EnumConstantModifier()
		}

		p.SetState(1248)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1249)
		p.Match(Java8ParserIdentifier)
	}
	p.SetState(1255)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserLPAREN {
		{
			p.SetState(1250)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(1252)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(1251)
				p.ArgumentList()
			}

		}
		{
			p.SetState(1254)
			p.Match(Java8ParserRPAREN)
		}

	}
	p.SetState(1258)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserLBRACE {
		{
			p.SetState(1257)
			p.ClassBody()
		}

	}

	return localctx
}

// IEnumConstantModifierContext is an interface to support dynamic dispatch.
type IEnumConstantModifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEnumConstantModifierContext differentiates from other interfaces.
	IsEnumConstantModifierContext()
}

type EnumConstantModifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEnumConstantModifierContext() *EnumConstantModifierContext {
	var p = new(EnumConstantModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_enumConstantModifier
	return p
}

func (*EnumConstantModifierContext) IsEnumConstantModifierContext() {}

func NewEnumConstantModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumConstantModifierContext {
	var p = new(EnumConstantModifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_enumConstantModifier

	return p
}

func (s *EnumConstantModifierContext) GetParser() antlr.Parser { return s.parser }

func (s *EnumConstantModifierContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *EnumConstantModifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EnumConstantModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EnumConstantModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterEnumConstantModifier(s)
	}
}

func (s *EnumConstantModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitEnumConstantModifier(s)
	}
}

func (p *Java8Parser) EnumConstantModifier() (localctx IEnumConstantModifierContext) {
	this := p
	_ = this

	localctx = NewEnumConstantModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 192, Java8ParserRULE_enumConstantModifier)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1260)
		p.Annotation()
	}

	return localctx
}

// IEnumBodyDeclarationsContext is an interface to support dynamic dispatch.
type IEnumBodyDeclarationsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEnumBodyDeclarationsContext differentiates from other interfaces.
	IsEnumBodyDeclarationsContext()
}

type EnumBodyDeclarationsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEnumBodyDeclarationsContext() *EnumBodyDeclarationsContext {
	var p = new(EnumBodyDeclarationsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_enumBodyDeclarations
	return p
}

func (*EnumBodyDeclarationsContext) IsEnumBodyDeclarationsContext() {}

func NewEnumBodyDeclarationsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumBodyDeclarationsContext {
	var p = new(EnumBodyDeclarationsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_enumBodyDeclarations

	return p
}

func (s *EnumBodyDeclarationsContext) GetParser() antlr.Parser { return s.parser }

func (s *EnumBodyDeclarationsContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *EnumBodyDeclarationsContext) AllClassBodyDeclaration() []IClassBodyDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IClassBodyDeclarationContext)(nil)).Elem())
	var tst = make([]IClassBodyDeclarationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IClassBodyDeclarationContext)
		}
	}

	return tst
}

func (s *EnumBodyDeclarationsContext) ClassBodyDeclaration(i int) IClassBodyDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassBodyDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IClassBodyDeclarationContext)
}

func (s *EnumBodyDeclarationsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EnumBodyDeclarationsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EnumBodyDeclarationsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterEnumBodyDeclarations(s)
	}
}

func (s *EnumBodyDeclarationsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitEnumBodyDeclarations(s)
	}
}

func (p *Java8Parser) EnumBodyDeclarations() (localctx IEnumBodyDeclarationsContext) {
	this := p
	_ = this

	localctx = NewEnumBodyDeclarationsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 194, Java8ParserRULE_enumBodyDeclarations)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1262)
		p.Match(Java8ParserSEMI)
	}
	p.SetState(1266)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserABSTRACT)|(1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserCLASS)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserENUM)|(1<<Java8ParserFINAL)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserINTERFACE)|(1<<Java8ParserLONG)|(1<<Java8ParserNATIVE))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(Java8ParserPRIVATE-33))|(1<<(Java8ParserPROTECTED-33))|(1<<(Java8ParserPUBLIC-33))|(1<<(Java8ParserSHORT-33))|(1<<(Java8ParserSTATIC-33))|(1<<(Java8ParserSTRICTFP-33))|(1<<(Java8ParserSYNCHRONIZED-33))|(1<<(Java8ParserTRANSIENT-33))|(1<<(Java8ParserVOID-33))|(1<<(Java8ParserVOLATILE-33))|(1<<(Java8ParserLBRACE-33))|(1<<(Java8ParserSEMI-33)))) != 0) || _la == Java8ParserLT || _la == Java8ParserIdentifier || _la == Java8ParserAT {
		{
			p.SetState(1263)
			p.ClassBodyDeclaration()
		}

		p.SetState(1268)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IInterfaceDeclarationContext is an interface to support dynamic dispatch.
type IInterfaceDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInterfaceDeclarationContext differentiates from other interfaces.
	IsInterfaceDeclarationContext()
}

type InterfaceDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInterfaceDeclarationContext() *InterfaceDeclarationContext {
	var p = new(InterfaceDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_interfaceDeclaration
	return p
}

func (*InterfaceDeclarationContext) IsInterfaceDeclarationContext() {}

func NewInterfaceDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InterfaceDeclarationContext {
	var p = new(InterfaceDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_interfaceDeclaration

	return p
}

func (s *InterfaceDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *InterfaceDeclarationContext) NormalInterfaceDeclaration() INormalInterfaceDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INormalInterfaceDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INormalInterfaceDeclarationContext)
}

func (s *InterfaceDeclarationContext) AnnotationTypeDeclaration() IAnnotationTypeDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationTypeDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationTypeDeclarationContext)
}

func (s *InterfaceDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InterfaceDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InterfaceDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterInterfaceDeclaration(s)
	}
}

func (s *InterfaceDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitInterfaceDeclaration(s)
	}
}

func (p *Java8Parser) InterfaceDeclaration() (localctx IInterfaceDeclarationContext) {
	this := p
	_ = this

	localctx = NewInterfaceDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 196, Java8ParserRULE_interfaceDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1271)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 123, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1269)
			p.NormalInterfaceDeclaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1270)
			p.AnnotationTypeDeclaration()
		}

	}

	return localctx
}

// INormalInterfaceDeclarationContext is an interface to support dynamic dispatch.
type INormalInterfaceDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNormalInterfaceDeclarationContext differentiates from other interfaces.
	IsNormalInterfaceDeclarationContext()
}

type NormalInterfaceDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNormalInterfaceDeclarationContext() *NormalInterfaceDeclarationContext {
	var p = new(NormalInterfaceDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_normalInterfaceDeclaration
	return p
}

func (*NormalInterfaceDeclarationContext) IsNormalInterfaceDeclarationContext() {}

func NewNormalInterfaceDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NormalInterfaceDeclarationContext {
	var p = new(NormalInterfaceDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_normalInterfaceDeclaration

	return p
}

func (s *NormalInterfaceDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *NormalInterfaceDeclarationContext) INTERFACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserINTERFACE, 0)
}

func (s *NormalInterfaceDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *NormalInterfaceDeclarationContext) InterfaceBody() IInterfaceBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceBodyContext)
}

func (s *NormalInterfaceDeclarationContext) AllInterfaceModifier() []IInterfaceModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInterfaceModifierContext)(nil)).Elem())
	var tst = make([]IInterfaceModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IInterfaceModifierContext)
		}
	}

	return tst
}

func (s *NormalInterfaceDeclarationContext) InterfaceModifier(i int) IInterfaceModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInterfaceModifierContext)
}

func (s *NormalInterfaceDeclarationContext) TypeParameters() ITypeParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

func (s *NormalInterfaceDeclarationContext) ExtendsInterfaces() IExtendsInterfacesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExtendsInterfacesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExtendsInterfacesContext)
}

func (s *NormalInterfaceDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NormalInterfaceDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *NormalInterfaceDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterNormalInterfaceDeclaration(s)
	}
}

func (s *NormalInterfaceDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitNormalInterfaceDeclaration(s)
	}
}

func (p *Java8Parser) NormalInterfaceDeclaration() (localctx INormalInterfaceDeclarationContext) {
	this := p
	_ = this

	localctx = NewNormalInterfaceDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 198, Java8ParserRULE_normalInterfaceDeclaration)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1276)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserABSTRACT || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(Java8ParserPRIVATE-33))|(1<<(Java8ParserPROTECTED-33))|(1<<(Java8ParserPUBLIC-33))|(1<<(Java8ParserSTATIC-33))|(1<<(Java8ParserSTRICTFP-33)))) != 0) || _la == Java8ParserAT {
		{
			p.SetState(1273)
			p.InterfaceModifier()
		}

		p.SetState(1278)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1279)
		p.Match(Java8ParserINTERFACE)
	}
	{
		p.SetState(1280)
		p.Match(Java8ParserIdentifier)
	}
	p.SetState(1282)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserLT {
		{
			p.SetState(1281)
			p.TypeParameters()
		}

	}
	p.SetState(1285)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserEXTENDS {
		{
			p.SetState(1284)
			p.ExtendsInterfaces()
		}

	}
	{
		p.SetState(1287)
		p.InterfaceBody()
	}

	return localctx
}

// IInterfaceModifierContext is an interface to support dynamic dispatch.
type IInterfaceModifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInterfaceModifierContext differentiates from other interfaces.
	IsInterfaceModifierContext()
}

type InterfaceModifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInterfaceModifierContext() *InterfaceModifierContext {
	var p = new(InterfaceModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_interfaceModifier
	return p
}

func (*InterfaceModifierContext) IsInterfaceModifierContext() {}

func NewInterfaceModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InterfaceModifierContext {
	var p = new(InterfaceModifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_interfaceModifier

	return p
}

func (s *InterfaceModifierContext) GetParser() antlr.Parser { return s.parser }

func (s *InterfaceModifierContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *InterfaceModifierContext) PUBLIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserPUBLIC, 0)
}

func (s *InterfaceModifierContext) PROTECTED() antlr.TerminalNode {
	return s.GetToken(Java8ParserPROTECTED, 0)
}

func (s *InterfaceModifierContext) PRIVATE() antlr.TerminalNode {
	return s.GetToken(Java8ParserPRIVATE, 0)
}

func (s *InterfaceModifierContext) ABSTRACT() antlr.TerminalNode {
	return s.GetToken(Java8ParserABSTRACT, 0)
}

func (s *InterfaceModifierContext) STATIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserSTATIC, 0)
}

func (s *InterfaceModifierContext) STRICTFP() antlr.TerminalNode {
	return s.GetToken(Java8ParserSTRICTFP, 0)
}

func (s *InterfaceModifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InterfaceModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InterfaceModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterInterfaceModifier(s)
	}
}

func (s *InterfaceModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitInterfaceModifier(s)
	}
}

func (p *Java8Parser) InterfaceModifier() (localctx IInterfaceModifierContext) {
	this := p
	_ = this

	localctx = NewInterfaceModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 200, Java8ParserRULE_interfaceModifier)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1296)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1289)
			p.Annotation()
		}

	case Java8ParserPUBLIC:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1290)
			p.Match(Java8ParserPUBLIC)
		}

	case Java8ParserPROTECTED:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1291)
			p.Match(Java8ParserPROTECTED)
		}

	case Java8ParserPRIVATE:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1292)
			p.Match(Java8ParserPRIVATE)
		}

	case Java8ParserABSTRACT:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1293)
			p.Match(Java8ParserABSTRACT)
		}

	case Java8ParserSTATIC:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1294)
			p.Match(Java8ParserSTATIC)
		}

	case Java8ParserSTRICTFP:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1295)
			p.Match(Java8ParserSTRICTFP)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IExtendsInterfacesContext is an interface to support dynamic dispatch.
type IExtendsInterfacesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExtendsInterfacesContext differentiates from other interfaces.
	IsExtendsInterfacesContext()
}

type ExtendsInterfacesContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExtendsInterfacesContext() *ExtendsInterfacesContext {
	var p = new(ExtendsInterfacesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_extendsInterfaces
	return p
}

func (*ExtendsInterfacesContext) IsExtendsInterfacesContext() {}

func NewExtendsInterfacesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExtendsInterfacesContext {
	var p = new(ExtendsInterfacesContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_extendsInterfaces

	return p
}

func (s *ExtendsInterfacesContext) GetParser() antlr.Parser { return s.parser }

func (s *ExtendsInterfacesContext) EXTENDS() antlr.TerminalNode {
	return s.GetToken(Java8ParserEXTENDS, 0)
}

func (s *ExtendsInterfacesContext) InterfaceTypeList() IInterfaceTypeListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceTypeListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceTypeListContext)
}

func (s *ExtendsInterfacesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExtendsInterfacesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExtendsInterfacesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterExtendsInterfaces(s)
	}
}

func (s *ExtendsInterfacesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitExtendsInterfaces(s)
	}
}

func (p *Java8Parser) ExtendsInterfaces() (localctx IExtendsInterfacesContext) {
	this := p
	_ = this

	localctx = NewExtendsInterfacesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 202, Java8ParserRULE_extendsInterfaces)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1298)
		p.Match(Java8ParserEXTENDS)
	}
	{
		p.SetState(1299)
		p.InterfaceTypeList()
	}

	return localctx
}

// IInterfaceBodyContext is an interface to support dynamic dispatch.
type IInterfaceBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInterfaceBodyContext differentiates from other interfaces.
	IsInterfaceBodyContext()
}

type InterfaceBodyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInterfaceBodyContext() *InterfaceBodyContext {
	var p = new(InterfaceBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_interfaceBody
	return p
}

func (*InterfaceBodyContext) IsInterfaceBodyContext() {}

func NewInterfaceBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InterfaceBodyContext {
	var p = new(InterfaceBodyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_interfaceBody

	return p
}

func (s *InterfaceBodyContext) GetParser() antlr.Parser { return s.parser }

func (s *InterfaceBodyContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACE, 0)
}

func (s *InterfaceBodyContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACE, 0)
}

func (s *InterfaceBodyContext) AllInterfaceMemberDeclaration() []IInterfaceMemberDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInterfaceMemberDeclarationContext)(nil)).Elem())
	var tst = make([]IInterfaceMemberDeclarationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IInterfaceMemberDeclarationContext)
		}
	}

	return tst
}

func (s *InterfaceBodyContext) InterfaceMemberDeclaration(i int) IInterfaceMemberDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceMemberDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInterfaceMemberDeclarationContext)
}

func (s *InterfaceBodyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InterfaceBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InterfaceBodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterInterfaceBody(s)
	}
}

func (s *InterfaceBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitInterfaceBody(s)
	}
}

func (p *Java8Parser) InterfaceBody() (localctx IInterfaceBodyContext) {
	this := p
	_ = this

	localctx = NewInterfaceBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 204, Java8ParserRULE_interfaceBody)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1301)
		p.Match(Java8ParserLBRACE)
	}
	p.SetState(1305)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserABSTRACT)|(1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserCLASS)|(1<<Java8ParserDEFAULT)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserENUM)|(1<<Java8ParserFINAL)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserINTERFACE)|(1<<Java8ParserLONG))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(Java8ParserPRIVATE-33))|(1<<(Java8ParserPROTECTED-33))|(1<<(Java8ParserPUBLIC-33))|(1<<(Java8ParserSHORT-33))|(1<<(Java8ParserSTATIC-33))|(1<<(Java8ParserSTRICTFP-33))|(1<<(Java8ParserVOID-33))|(1<<(Java8ParserSEMI-33)))) != 0) || _la == Java8ParserLT || _la == Java8ParserIdentifier || _la == Java8ParserAT {
		{
			p.SetState(1302)
			p.InterfaceMemberDeclaration()
		}

		p.SetState(1307)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1308)
		p.Match(Java8ParserRBRACE)
	}

	return localctx
}

// IInterfaceMemberDeclarationContext is an interface to support dynamic dispatch.
type IInterfaceMemberDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInterfaceMemberDeclarationContext differentiates from other interfaces.
	IsInterfaceMemberDeclarationContext()
}

type InterfaceMemberDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInterfaceMemberDeclarationContext() *InterfaceMemberDeclarationContext {
	var p = new(InterfaceMemberDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_interfaceMemberDeclaration
	return p
}

func (*InterfaceMemberDeclarationContext) IsInterfaceMemberDeclarationContext() {}

func NewInterfaceMemberDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InterfaceMemberDeclarationContext {
	var p = new(InterfaceMemberDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_interfaceMemberDeclaration

	return p
}

func (s *InterfaceMemberDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *InterfaceMemberDeclarationContext) ConstantDeclaration() IConstantDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantDeclarationContext)
}

func (s *InterfaceMemberDeclarationContext) InterfaceMethodDeclaration() IInterfaceMethodDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceMethodDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceMethodDeclarationContext)
}

func (s *InterfaceMemberDeclarationContext) ClassDeclaration() IClassDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassDeclarationContext)
}

func (s *InterfaceMemberDeclarationContext) InterfaceDeclaration() IInterfaceDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceDeclarationContext)
}

func (s *InterfaceMemberDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *InterfaceMemberDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InterfaceMemberDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InterfaceMemberDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterInterfaceMemberDeclaration(s)
	}
}

func (s *InterfaceMemberDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitInterfaceMemberDeclaration(s)
	}
}

func (p *Java8Parser) InterfaceMemberDeclaration() (localctx IInterfaceMemberDeclarationContext) {
	this := p
	_ = this

	localctx = NewInterfaceMemberDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 206, Java8ParserRULE_interfaceMemberDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1315)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 129, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1310)
			p.ConstantDeclaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1311)
			p.InterfaceMethodDeclaration()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1312)
			p.ClassDeclaration()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1313)
			p.InterfaceDeclaration()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1314)
			p.Match(Java8ParserSEMI)
		}

	}

	return localctx
}

// IConstantDeclarationContext is an interface to support dynamic dispatch.
type IConstantDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConstantDeclarationContext differentiates from other interfaces.
	IsConstantDeclarationContext()
}

type ConstantDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstantDeclarationContext() *ConstantDeclarationContext {
	var p = new(ConstantDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_constantDeclaration
	return p
}

func (*ConstantDeclarationContext) IsConstantDeclarationContext() {}

func NewConstantDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantDeclarationContext {
	var p = new(ConstantDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_constantDeclaration

	return p
}

func (s *ConstantDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstantDeclarationContext) UnannType() IUnannTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannTypeContext)
}

func (s *ConstantDeclarationContext) VariableDeclaratorList() IVariableDeclaratorListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorListContext)
}

func (s *ConstantDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *ConstantDeclarationContext) AllConstantModifier() []IConstantModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IConstantModifierContext)(nil)).Elem())
	var tst = make([]IConstantModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IConstantModifierContext)
		}
	}

	return tst
}

func (s *ConstantDeclarationContext) ConstantModifier(i int) IConstantModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IConstantModifierContext)
}

func (s *ConstantDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstantDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstantDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterConstantDeclaration(s)
	}
}

func (s *ConstantDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitConstantDeclaration(s)
	}
}

func (p *Java8Parser) ConstantDeclaration() (localctx IConstantDeclarationContext) {
	this := p
	_ = this

	localctx = NewConstantDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 208, Java8ParserRULE_constantDeclaration)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1320)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la-18)&-(0x1f+1)) == 0 && ((1<<uint((_la-18)))&((1<<(Java8ParserFINAL-18))|(1<<(Java8ParserPUBLIC-18))|(1<<(Java8ParserSTATIC-18)))) != 0) || _la == Java8ParserAT {
		{
			p.SetState(1317)
			p.ConstantModifier()
		}

		p.SetState(1322)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1323)
		p.UnannType()
	}
	{
		p.SetState(1324)
		p.VariableDeclaratorList()
	}
	{
		p.SetState(1325)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// IConstantModifierContext is an interface to support dynamic dispatch.
type IConstantModifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConstantModifierContext differentiates from other interfaces.
	IsConstantModifierContext()
}

type ConstantModifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstantModifierContext() *ConstantModifierContext {
	var p = new(ConstantModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_constantModifier
	return p
}

func (*ConstantModifierContext) IsConstantModifierContext() {}

func NewConstantModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantModifierContext {
	var p = new(ConstantModifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_constantModifier

	return p
}

func (s *ConstantModifierContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstantModifierContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *ConstantModifierContext) PUBLIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserPUBLIC, 0)
}

func (s *ConstantModifierContext) STATIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserSTATIC, 0)
}

func (s *ConstantModifierContext) FINAL() antlr.TerminalNode {
	return s.GetToken(Java8ParserFINAL, 0)
}

func (s *ConstantModifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstantModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstantModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterConstantModifier(s)
	}
}

func (s *ConstantModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitConstantModifier(s)
	}
}

func (p *Java8Parser) ConstantModifier() (localctx IConstantModifierContext) {
	this := p
	_ = this

	localctx = NewConstantModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 210, Java8ParserRULE_constantModifier)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1331)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1327)
			p.Annotation()
		}

	case Java8ParserPUBLIC:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1328)
			p.Match(Java8ParserPUBLIC)
		}

	case Java8ParserSTATIC:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1329)
			p.Match(Java8ParserSTATIC)
		}

	case Java8ParserFINAL:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1330)
			p.Match(Java8ParserFINAL)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IInterfaceMethodDeclarationContext is an interface to support dynamic dispatch.
type IInterfaceMethodDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInterfaceMethodDeclarationContext differentiates from other interfaces.
	IsInterfaceMethodDeclarationContext()
}

type InterfaceMethodDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInterfaceMethodDeclarationContext() *InterfaceMethodDeclarationContext {
	var p = new(InterfaceMethodDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_interfaceMethodDeclaration
	return p
}

func (*InterfaceMethodDeclarationContext) IsInterfaceMethodDeclarationContext() {}

func NewInterfaceMethodDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InterfaceMethodDeclarationContext {
	var p = new(InterfaceMethodDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_interfaceMethodDeclaration

	return p
}

func (s *InterfaceMethodDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *InterfaceMethodDeclarationContext) MethodHeader() IMethodHeaderContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodHeaderContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodHeaderContext)
}

func (s *InterfaceMethodDeclarationContext) MethodBody() IMethodBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodBodyContext)
}

func (s *InterfaceMethodDeclarationContext) AllInterfaceMethodModifier() []IInterfaceMethodModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInterfaceMethodModifierContext)(nil)).Elem())
	var tst = make([]IInterfaceMethodModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IInterfaceMethodModifierContext)
		}
	}

	return tst
}

func (s *InterfaceMethodDeclarationContext) InterfaceMethodModifier(i int) IInterfaceMethodModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceMethodModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInterfaceMethodModifierContext)
}

func (s *InterfaceMethodDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InterfaceMethodDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InterfaceMethodDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterInterfaceMethodDeclaration(s)
	}
}

func (s *InterfaceMethodDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitInterfaceMethodDeclaration(s)
	}
}

func (p *Java8Parser) InterfaceMethodDeclaration() (localctx IInterfaceMethodDeclarationContext) {
	this := p
	_ = this

	localctx = NewInterfaceMethodDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 212, Java8ParserRULE_interfaceMethodDeclaration)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1336)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserABSTRACT || _la == Java8ParserDEFAULT || (((_la-35)&-(0x1f+1)) == 0 && ((1<<uint((_la-35)))&((1<<(Java8ParserPUBLIC-35))|(1<<(Java8ParserSTATIC-35))|(1<<(Java8ParserSTRICTFP-35)))) != 0) || _la == Java8ParserAT {
		{
			p.SetState(1333)
			p.InterfaceMethodModifier()
		}

		p.SetState(1338)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1339)
		p.MethodHeader()
	}
	{
		p.SetState(1340)
		p.MethodBody()
	}

	return localctx
}

// IInterfaceMethodModifierContext is an interface to support dynamic dispatch.
type IInterfaceMethodModifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInterfaceMethodModifierContext differentiates from other interfaces.
	IsInterfaceMethodModifierContext()
}

type InterfaceMethodModifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInterfaceMethodModifierContext() *InterfaceMethodModifierContext {
	var p = new(InterfaceMethodModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_interfaceMethodModifier
	return p
}

func (*InterfaceMethodModifierContext) IsInterfaceMethodModifierContext() {}

func NewInterfaceMethodModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InterfaceMethodModifierContext {
	var p = new(InterfaceMethodModifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_interfaceMethodModifier

	return p
}

func (s *InterfaceMethodModifierContext) GetParser() antlr.Parser { return s.parser }

func (s *InterfaceMethodModifierContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *InterfaceMethodModifierContext) PUBLIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserPUBLIC, 0)
}

func (s *InterfaceMethodModifierContext) ABSTRACT() antlr.TerminalNode {
	return s.GetToken(Java8ParserABSTRACT, 0)
}

func (s *InterfaceMethodModifierContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDEFAULT, 0)
}

func (s *InterfaceMethodModifierContext) STATIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserSTATIC, 0)
}

func (s *InterfaceMethodModifierContext) STRICTFP() antlr.TerminalNode {
	return s.GetToken(Java8ParserSTRICTFP, 0)
}

func (s *InterfaceMethodModifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InterfaceMethodModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InterfaceMethodModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterInterfaceMethodModifier(s)
	}
}

func (s *InterfaceMethodModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitInterfaceMethodModifier(s)
	}
}

func (p *Java8Parser) InterfaceMethodModifier() (localctx IInterfaceMethodModifierContext) {
	this := p
	_ = this

	localctx = NewInterfaceMethodModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 214, Java8ParserRULE_interfaceMethodModifier)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1348)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1342)
			p.Annotation()
		}

	case Java8ParserPUBLIC:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1343)
			p.Match(Java8ParserPUBLIC)
		}

	case Java8ParserABSTRACT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1344)
			p.Match(Java8ParserABSTRACT)
		}

	case Java8ParserDEFAULT:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1345)
			p.Match(Java8ParserDEFAULT)
		}

	case Java8ParserSTATIC:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1346)
			p.Match(Java8ParserSTATIC)
		}

	case Java8ParserSTRICTFP:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1347)
			p.Match(Java8ParserSTRICTFP)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IAnnotationTypeDeclarationContext is an interface to support dynamic dispatch.
type IAnnotationTypeDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAnnotationTypeDeclarationContext differentiates from other interfaces.
	IsAnnotationTypeDeclarationContext()
}

type AnnotationTypeDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAnnotationTypeDeclarationContext() *AnnotationTypeDeclarationContext {
	var p = new(AnnotationTypeDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_annotationTypeDeclaration
	return p
}

func (*AnnotationTypeDeclarationContext) IsAnnotationTypeDeclarationContext() {}

func NewAnnotationTypeDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnnotationTypeDeclarationContext {
	var p = new(AnnotationTypeDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_annotationTypeDeclaration

	return p
}

func (s *AnnotationTypeDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *AnnotationTypeDeclarationContext) AT() antlr.TerminalNode {
	return s.GetToken(Java8ParserAT, 0)
}

func (s *AnnotationTypeDeclarationContext) INTERFACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserINTERFACE, 0)
}

func (s *AnnotationTypeDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *AnnotationTypeDeclarationContext) AnnotationTypeBody() IAnnotationTypeBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationTypeBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationTypeBodyContext)
}

func (s *AnnotationTypeDeclarationContext) AllInterfaceModifier() []IInterfaceModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInterfaceModifierContext)(nil)).Elem())
	var tst = make([]IInterfaceModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IInterfaceModifierContext)
		}
	}

	return tst
}

func (s *AnnotationTypeDeclarationContext) InterfaceModifier(i int) IInterfaceModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInterfaceModifierContext)
}

func (s *AnnotationTypeDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AnnotationTypeDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AnnotationTypeDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterAnnotationTypeDeclaration(s)
	}
}

func (s *AnnotationTypeDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitAnnotationTypeDeclaration(s)
	}
}

func (p *Java8Parser) AnnotationTypeDeclaration() (localctx IAnnotationTypeDeclarationContext) {
	this := p
	_ = this

	localctx = NewAnnotationTypeDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 216, Java8ParserRULE_annotationTypeDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1353)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 134, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1350)
				p.InterfaceModifier()
			}

		}
		p.SetState(1355)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 134, p.GetParserRuleContext())
	}
	{
		p.SetState(1356)
		p.Match(Java8ParserAT)
	}
	{
		p.SetState(1357)
		p.Match(Java8ParserINTERFACE)
	}
	{
		p.SetState(1358)
		p.Match(Java8ParserIdentifier)
	}
	{
		p.SetState(1359)
		p.AnnotationTypeBody()
	}

	return localctx
}

// IAnnotationTypeBodyContext is an interface to support dynamic dispatch.
type IAnnotationTypeBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAnnotationTypeBodyContext differentiates from other interfaces.
	IsAnnotationTypeBodyContext()
}

type AnnotationTypeBodyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAnnotationTypeBodyContext() *AnnotationTypeBodyContext {
	var p = new(AnnotationTypeBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_annotationTypeBody
	return p
}

func (*AnnotationTypeBodyContext) IsAnnotationTypeBodyContext() {}

func NewAnnotationTypeBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnnotationTypeBodyContext {
	var p = new(AnnotationTypeBodyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_annotationTypeBody

	return p
}

func (s *AnnotationTypeBodyContext) GetParser() antlr.Parser { return s.parser }

func (s *AnnotationTypeBodyContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACE, 0)
}

func (s *AnnotationTypeBodyContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACE, 0)
}

func (s *AnnotationTypeBodyContext) AllAnnotationTypeMemberDeclaration() []IAnnotationTypeMemberDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationTypeMemberDeclarationContext)(nil)).Elem())
	var tst = make([]IAnnotationTypeMemberDeclarationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationTypeMemberDeclarationContext)
		}
	}

	return tst
}

func (s *AnnotationTypeBodyContext) AnnotationTypeMemberDeclaration(i int) IAnnotationTypeMemberDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationTypeMemberDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationTypeMemberDeclarationContext)
}

func (s *AnnotationTypeBodyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AnnotationTypeBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AnnotationTypeBodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterAnnotationTypeBody(s)
	}
}

func (s *AnnotationTypeBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitAnnotationTypeBody(s)
	}
}

func (p *Java8Parser) AnnotationTypeBody() (localctx IAnnotationTypeBodyContext) {
	this := p
	_ = this

	localctx = NewAnnotationTypeBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 218, Java8ParserRULE_annotationTypeBody)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1361)
		p.Match(Java8ParserLBRACE)
	}
	p.SetState(1365)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserABSTRACT)|(1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserCLASS)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserENUM)|(1<<Java8ParserFINAL)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserINTERFACE)|(1<<Java8ParserLONG))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(Java8ParserPRIVATE-33))|(1<<(Java8ParserPROTECTED-33))|(1<<(Java8ParserPUBLIC-33))|(1<<(Java8ParserSHORT-33))|(1<<(Java8ParserSTATIC-33))|(1<<(Java8ParserSTRICTFP-33))|(1<<(Java8ParserSEMI-33)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
		{
			p.SetState(1362)
			p.AnnotationTypeMemberDeclaration()
		}

		p.SetState(1367)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1368)
		p.Match(Java8ParserRBRACE)
	}

	return localctx
}

// IAnnotationTypeMemberDeclarationContext is an interface to support dynamic dispatch.
type IAnnotationTypeMemberDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAnnotationTypeMemberDeclarationContext differentiates from other interfaces.
	IsAnnotationTypeMemberDeclarationContext()
}

type AnnotationTypeMemberDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAnnotationTypeMemberDeclarationContext() *AnnotationTypeMemberDeclarationContext {
	var p = new(AnnotationTypeMemberDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_annotationTypeMemberDeclaration
	return p
}

func (*AnnotationTypeMemberDeclarationContext) IsAnnotationTypeMemberDeclarationContext() {}

func NewAnnotationTypeMemberDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnnotationTypeMemberDeclarationContext {
	var p = new(AnnotationTypeMemberDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_annotationTypeMemberDeclaration

	return p
}

func (s *AnnotationTypeMemberDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *AnnotationTypeMemberDeclarationContext) AnnotationTypeElementDeclaration() IAnnotationTypeElementDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationTypeElementDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationTypeElementDeclarationContext)
}

func (s *AnnotationTypeMemberDeclarationContext) ConstantDeclaration() IConstantDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantDeclarationContext)
}

func (s *AnnotationTypeMemberDeclarationContext) ClassDeclaration() IClassDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassDeclarationContext)
}

func (s *AnnotationTypeMemberDeclarationContext) InterfaceDeclaration() IInterfaceDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceDeclarationContext)
}

func (s *AnnotationTypeMemberDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *AnnotationTypeMemberDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AnnotationTypeMemberDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AnnotationTypeMemberDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterAnnotationTypeMemberDeclaration(s)
	}
}

func (s *AnnotationTypeMemberDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitAnnotationTypeMemberDeclaration(s)
	}
}

func (p *Java8Parser) AnnotationTypeMemberDeclaration() (localctx IAnnotationTypeMemberDeclarationContext) {
	this := p
	_ = this

	localctx = NewAnnotationTypeMemberDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 220, Java8ParserRULE_annotationTypeMemberDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1375)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 136, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1370)
			p.AnnotationTypeElementDeclaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1371)
			p.ConstantDeclaration()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1372)
			p.ClassDeclaration()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1373)
			p.InterfaceDeclaration()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1374)
			p.Match(Java8ParserSEMI)
		}

	}

	return localctx
}

// IAnnotationTypeElementDeclarationContext is an interface to support dynamic dispatch.
type IAnnotationTypeElementDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAnnotationTypeElementDeclarationContext differentiates from other interfaces.
	IsAnnotationTypeElementDeclarationContext()
}

type AnnotationTypeElementDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAnnotationTypeElementDeclarationContext() *AnnotationTypeElementDeclarationContext {
	var p = new(AnnotationTypeElementDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_annotationTypeElementDeclaration
	return p
}

func (*AnnotationTypeElementDeclarationContext) IsAnnotationTypeElementDeclarationContext() {}

func NewAnnotationTypeElementDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnnotationTypeElementDeclarationContext {
	var p = new(AnnotationTypeElementDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_annotationTypeElementDeclaration

	return p
}

func (s *AnnotationTypeElementDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *AnnotationTypeElementDeclarationContext) UnannType() IUnannTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannTypeContext)
}

func (s *AnnotationTypeElementDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *AnnotationTypeElementDeclarationContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *AnnotationTypeElementDeclarationContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *AnnotationTypeElementDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *AnnotationTypeElementDeclarationContext) AllAnnotationTypeElementModifier() []IAnnotationTypeElementModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationTypeElementModifierContext)(nil)).Elem())
	var tst = make([]IAnnotationTypeElementModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationTypeElementModifierContext)
		}
	}

	return tst
}

func (s *AnnotationTypeElementDeclarationContext) AnnotationTypeElementModifier(i int) IAnnotationTypeElementModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationTypeElementModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationTypeElementModifierContext)
}

func (s *AnnotationTypeElementDeclarationContext) Dims() IDimsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDimsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDimsContext)
}

func (s *AnnotationTypeElementDeclarationContext) DefaultValue() IDefaultValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDefaultValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDefaultValueContext)
}

func (s *AnnotationTypeElementDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AnnotationTypeElementDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AnnotationTypeElementDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterAnnotationTypeElementDeclaration(s)
	}
}

func (s *AnnotationTypeElementDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitAnnotationTypeElementDeclaration(s)
	}
}

func (p *Java8Parser) AnnotationTypeElementDeclaration() (localctx IAnnotationTypeElementDeclarationContext) {
	this := p
	_ = this

	localctx = NewAnnotationTypeElementDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 222, Java8ParserRULE_annotationTypeElementDeclaration)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1380)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserABSTRACT || _la == Java8ParserPUBLIC || _la == Java8ParserAT {
		{
			p.SetState(1377)
			p.AnnotationTypeElementModifier()
		}

		p.SetState(1382)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1383)
		p.UnannType()
	}
	{
		p.SetState(1384)
		p.Match(Java8ParserIdentifier)
	}
	{
		p.SetState(1385)
		p.Match(Java8ParserLPAREN)
	}
	{
		p.SetState(1386)
		p.Match(Java8ParserRPAREN)
	}
	p.SetState(1388)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserLBRACK || _la == Java8ParserAT {
		{
			p.SetState(1387)
			p.Dims()
		}

	}
	p.SetState(1391)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserDEFAULT {
		{
			p.SetState(1390)
			p.DefaultValue()
		}

	}
	{
		p.SetState(1393)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// IAnnotationTypeElementModifierContext is an interface to support dynamic dispatch.
type IAnnotationTypeElementModifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAnnotationTypeElementModifierContext differentiates from other interfaces.
	IsAnnotationTypeElementModifierContext()
}

type AnnotationTypeElementModifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAnnotationTypeElementModifierContext() *AnnotationTypeElementModifierContext {
	var p = new(AnnotationTypeElementModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_annotationTypeElementModifier
	return p
}

func (*AnnotationTypeElementModifierContext) IsAnnotationTypeElementModifierContext() {}

func NewAnnotationTypeElementModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnnotationTypeElementModifierContext {
	var p = new(AnnotationTypeElementModifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_annotationTypeElementModifier

	return p
}

func (s *AnnotationTypeElementModifierContext) GetParser() antlr.Parser { return s.parser }

func (s *AnnotationTypeElementModifierContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *AnnotationTypeElementModifierContext) PUBLIC() antlr.TerminalNode {
	return s.GetToken(Java8ParserPUBLIC, 0)
}

func (s *AnnotationTypeElementModifierContext) ABSTRACT() antlr.TerminalNode {
	return s.GetToken(Java8ParserABSTRACT, 0)
}

func (s *AnnotationTypeElementModifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AnnotationTypeElementModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AnnotationTypeElementModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterAnnotationTypeElementModifier(s)
	}
}

func (s *AnnotationTypeElementModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitAnnotationTypeElementModifier(s)
	}
}

func (p *Java8Parser) AnnotationTypeElementModifier() (localctx IAnnotationTypeElementModifierContext) {
	this := p
	_ = this

	localctx = NewAnnotationTypeElementModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 224, Java8ParserRULE_annotationTypeElementModifier)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1398)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1395)
			p.Annotation()
		}

	case Java8ParserPUBLIC:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1396)
			p.Match(Java8ParserPUBLIC)
		}

	case Java8ParserABSTRACT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1397)
			p.Match(Java8ParserABSTRACT)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IDefaultValueContext is an interface to support dynamic dispatch.
type IDefaultValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDefaultValueContext differentiates from other interfaces.
	IsDefaultValueContext()
}

type DefaultValueContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDefaultValueContext() *DefaultValueContext {
	var p = new(DefaultValueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_defaultValue
	return p
}

func (*DefaultValueContext) IsDefaultValueContext() {}

func NewDefaultValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefaultValueContext {
	var p = new(DefaultValueContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_defaultValue

	return p
}

func (s *DefaultValueContext) GetParser() antlr.Parser { return s.parser }

func (s *DefaultValueContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDEFAULT, 0)
}

func (s *DefaultValueContext) ElementValue() IElementValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementValueContext)
}

func (s *DefaultValueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DefaultValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DefaultValueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterDefaultValue(s)
	}
}

func (s *DefaultValueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitDefaultValue(s)
	}
}

func (p *Java8Parser) DefaultValue() (localctx IDefaultValueContext) {
	this := p
	_ = this

	localctx = NewDefaultValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 226, Java8ParserRULE_defaultValue)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1400)
		p.Match(Java8ParserDEFAULT)
	}
	{
		p.SetState(1401)
		p.ElementValue()
	}

	return localctx
}

// IAnnotationContext is an interface to support dynamic dispatch.
type IAnnotationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAnnotationContext differentiates from other interfaces.
	IsAnnotationContext()
}

type AnnotationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAnnotationContext() *AnnotationContext {
	var p = new(AnnotationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_annotation
	return p
}

func (*AnnotationContext) IsAnnotationContext() {}

func NewAnnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnnotationContext {
	var p = new(AnnotationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_annotation

	return p
}

func (s *AnnotationContext) GetParser() antlr.Parser { return s.parser }

func (s *AnnotationContext) NormalAnnotation() INormalAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INormalAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INormalAnnotationContext)
}

func (s *AnnotationContext) MarkerAnnotation() IMarkerAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMarkerAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMarkerAnnotationContext)
}

func (s *AnnotationContext) SingleElementAnnotation() ISingleElementAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleElementAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleElementAnnotationContext)
}

func (s *AnnotationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AnnotationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AnnotationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterAnnotation(s)
	}
}

func (s *AnnotationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitAnnotation(s)
	}
}

func (p *Java8Parser) Annotation() (localctx IAnnotationContext) {
	this := p
	_ = this

	localctx = NewAnnotationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 228, Java8ParserRULE_annotation)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1406)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 141, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1403)
			p.NormalAnnotation()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1404)
			p.MarkerAnnotation()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1405)
			p.SingleElementAnnotation()
		}

	}

	return localctx
}

// INormalAnnotationContext is an interface to support dynamic dispatch.
type INormalAnnotationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNormalAnnotationContext differentiates from other interfaces.
	IsNormalAnnotationContext()
}

type NormalAnnotationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNormalAnnotationContext() *NormalAnnotationContext {
	var p = new(NormalAnnotationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_normalAnnotation
	return p
}

func (*NormalAnnotationContext) IsNormalAnnotationContext() {}

func NewNormalAnnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NormalAnnotationContext {
	var p = new(NormalAnnotationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_normalAnnotation

	return p
}

func (s *NormalAnnotationContext) GetParser() antlr.Parser { return s.parser }

func (s *NormalAnnotationContext) AT() antlr.TerminalNode {
	return s.GetToken(Java8ParserAT, 0)
}

func (s *NormalAnnotationContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *NormalAnnotationContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *NormalAnnotationContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *NormalAnnotationContext) ElementValuePairList() IElementValuePairListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementValuePairListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementValuePairListContext)
}

func (s *NormalAnnotationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NormalAnnotationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *NormalAnnotationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterNormalAnnotation(s)
	}
}

func (s *NormalAnnotationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitNormalAnnotation(s)
	}
}

func (p *Java8Parser) NormalAnnotation() (localctx INormalAnnotationContext) {
	this := p
	_ = this

	localctx = NewNormalAnnotationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 230, Java8ParserRULE_normalAnnotation)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1408)
		p.Match(Java8ParserAT)
	}
	{
		p.SetState(1409)
		p.TypeName()
	}
	{
		p.SetState(1410)
		p.Match(Java8ParserLPAREN)
	}
	p.SetState(1412)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserIdentifier {
		{
			p.SetState(1411)
			p.ElementValuePairList()
		}

	}
	{
		p.SetState(1414)
		p.Match(Java8ParserRPAREN)
	}

	return localctx
}

// IElementValuePairListContext is an interface to support dynamic dispatch.
type IElementValuePairListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsElementValuePairListContext differentiates from other interfaces.
	IsElementValuePairListContext()
}

type ElementValuePairListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyElementValuePairListContext() *ElementValuePairListContext {
	var p = new(ElementValuePairListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_elementValuePairList
	return p
}

func (*ElementValuePairListContext) IsElementValuePairListContext() {}

func NewElementValuePairListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementValuePairListContext {
	var p = new(ElementValuePairListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_elementValuePairList

	return p
}

func (s *ElementValuePairListContext) GetParser() antlr.Parser { return s.parser }

func (s *ElementValuePairListContext) AllElementValuePair() []IElementValuePairContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IElementValuePairContext)(nil)).Elem())
	var tst = make([]IElementValuePairContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IElementValuePairContext)
		}
	}

	return tst
}

func (s *ElementValuePairListContext) ElementValuePair(i int) IElementValuePairContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementValuePairContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IElementValuePairContext)
}

func (s *ElementValuePairListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserCOMMA)
}

func (s *ElementValuePairListContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, i)
}

func (s *ElementValuePairListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ElementValuePairListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ElementValuePairListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterElementValuePairList(s)
	}
}

func (s *ElementValuePairListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitElementValuePairList(s)
	}
}

func (p *Java8Parser) ElementValuePairList() (localctx IElementValuePairListContext) {
	this := p
	_ = this

	localctx = NewElementValuePairListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 232, Java8ParserRULE_elementValuePairList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1416)
		p.ElementValuePair()
	}
	p.SetState(1421)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserCOMMA {
		{
			p.SetState(1417)
			p.Match(Java8ParserCOMMA)
		}
		{
			p.SetState(1418)
			p.ElementValuePair()
		}

		p.SetState(1423)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IElementValuePairContext is an interface to support dynamic dispatch.
type IElementValuePairContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsElementValuePairContext differentiates from other interfaces.
	IsElementValuePairContext()
}

type ElementValuePairContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyElementValuePairContext() *ElementValuePairContext {
	var p = new(ElementValuePairContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_elementValuePair
	return p
}

func (*ElementValuePairContext) IsElementValuePairContext() {}

func NewElementValuePairContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementValuePairContext {
	var p = new(ElementValuePairContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_elementValuePair

	return p
}

func (s *ElementValuePairContext) GetParser() antlr.Parser { return s.parser }

func (s *ElementValuePairContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *ElementValuePairContext) ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserASSIGN, 0)
}

func (s *ElementValuePairContext) ElementValue() IElementValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementValueContext)
}

func (s *ElementValuePairContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ElementValuePairContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ElementValuePairContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterElementValuePair(s)
	}
}

func (s *ElementValuePairContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitElementValuePair(s)
	}
}

func (p *Java8Parser) ElementValuePair() (localctx IElementValuePairContext) {
	this := p
	_ = this

	localctx = NewElementValuePairContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 234, Java8ParserRULE_elementValuePair)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1424)
		p.Match(Java8ParserIdentifier)
	}
	{
		p.SetState(1425)
		p.Match(Java8ParserASSIGN)
	}
	{
		p.SetState(1426)
		p.ElementValue()
	}

	return localctx
}

// IElementValueContext is an interface to support dynamic dispatch.
type IElementValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsElementValueContext differentiates from other interfaces.
	IsElementValueContext()
}

type ElementValueContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyElementValueContext() *ElementValueContext {
	var p = new(ElementValueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_elementValue
	return p
}

func (*ElementValueContext) IsElementValueContext() {}

func NewElementValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementValueContext {
	var p = new(ElementValueContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_elementValue

	return p
}

func (s *ElementValueContext) GetParser() antlr.Parser { return s.parser }

func (s *ElementValueContext) ConditionalExpression() IConditionalExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConditionalExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConditionalExpressionContext)
}

func (s *ElementValueContext) ElementValueArrayInitializer() IElementValueArrayInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementValueArrayInitializerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementValueArrayInitializerContext)
}

func (s *ElementValueContext) Annotation() IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *ElementValueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ElementValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ElementValueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterElementValue(s)
	}
}

func (s *ElementValueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitElementValue(s)
	}
}

func (p *Java8Parser) ElementValue() (localctx IElementValueContext) {
	this := p
	_ = this

	localctx = NewElementValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 236, Java8ParserRULE_elementValue)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1431)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 144, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1428)
			p.ConditionalExpression()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1429)
			p.ElementValueArrayInitializer()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1430)
			p.Annotation()
		}

	}

	return localctx
}

// IElementValueArrayInitializerContext is an interface to support dynamic dispatch.
type IElementValueArrayInitializerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsElementValueArrayInitializerContext differentiates from other interfaces.
	IsElementValueArrayInitializerContext()
}

type ElementValueArrayInitializerContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyElementValueArrayInitializerContext() *ElementValueArrayInitializerContext {
	var p = new(ElementValueArrayInitializerContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_elementValueArrayInitializer
	return p
}

func (*ElementValueArrayInitializerContext) IsElementValueArrayInitializerContext() {}

func NewElementValueArrayInitializerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementValueArrayInitializerContext {
	var p = new(ElementValueArrayInitializerContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_elementValueArrayInitializer

	return p
}

func (s *ElementValueArrayInitializerContext) GetParser() antlr.Parser { return s.parser }

func (s *ElementValueArrayInitializerContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACE, 0)
}

func (s *ElementValueArrayInitializerContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACE, 0)
}

func (s *ElementValueArrayInitializerContext) ElementValueList() IElementValueListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementValueListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementValueListContext)
}

func (s *ElementValueArrayInitializerContext) COMMA() antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, 0)
}

func (s *ElementValueArrayInitializerContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ElementValueArrayInitializerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ElementValueArrayInitializerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterElementValueArrayInitializer(s)
	}
}

func (s *ElementValueArrayInitializerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitElementValueArrayInitializer(s)
	}
}

func (p *Java8Parser) ElementValueArrayInitializer() (localctx IElementValueArrayInitializerContext) {
	this := p
	_ = this

	localctx = NewElementValueArrayInitializerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 238, Java8ParserRULE_elementValueArrayInitializer)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1433)
		p.Match(Java8ParserLBRACE)
	}
	p.SetState(1435)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37))|(1<<(Java8ParserLBRACE-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
		{
			p.SetState(1434)
			p.ElementValueList()
		}

	}
	p.SetState(1438)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserCOMMA {
		{
			p.SetState(1437)
			p.Match(Java8ParserCOMMA)
		}

	}
	{
		p.SetState(1440)
		p.Match(Java8ParserRBRACE)
	}

	return localctx
}

// IElementValueListContext is an interface to support dynamic dispatch.
type IElementValueListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsElementValueListContext differentiates from other interfaces.
	IsElementValueListContext()
}

type ElementValueListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyElementValueListContext() *ElementValueListContext {
	var p = new(ElementValueListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_elementValueList
	return p
}

func (*ElementValueListContext) IsElementValueListContext() {}

func NewElementValueListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementValueListContext {
	var p = new(ElementValueListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_elementValueList

	return p
}

func (s *ElementValueListContext) GetParser() antlr.Parser { return s.parser }

func (s *ElementValueListContext) AllElementValue() []IElementValueContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IElementValueContext)(nil)).Elem())
	var tst = make([]IElementValueContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IElementValueContext)
		}
	}

	return tst
}

func (s *ElementValueListContext) ElementValue(i int) IElementValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementValueContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IElementValueContext)
}

func (s *ElementValueListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserCOMMA)
}

func (s *ElementValueListContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, i)
}

func (s *ElementValueListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ElementValueListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ElementValueListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterElementValueList(s)
	}
}

func (s *ElementValueListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitElementValueList(s)
	}
}

func (p *Java8Parser) ElementValueList() (localctx IElementValueListContext) {
	this := p
	_ = this

	localctx = NewElementValueListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 240, Java8ParserRULE_elementValueList)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1442)
		p.ElementValue()
	}
	p.SetState(1447)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 147, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1443)
				p.Match(Java8ParserCOMMA)
			}
			{
				p.SetState(1444)
				p.ElementValue()
			}

		}
		p.SetState(1449)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 147, p.GetParserRuleContext())
	}

	return localctx
}

// IMarkerAnnotationContext is an interface to support dynamic dispatch.
type IMarkerAnnotationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMarkerAnnotationContext differentiates from other interfaces.
	IsMarkerAnnotationContext()
}

type MarkerAnnotationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMarkerAnnotationContext() *MarkerAnnotationContext {
	var p = new(MarkerAnnotationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_markerAnnotation
	return p
}

func (*MarkerAnnotationContext) IsMarkerAnnotationContext() {}

func NewMarkerAnnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MarkerAnnotationContext {
	var p = new(MarkerAnnotationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_markerAnnotation

	return p
}

func (s *MarkerAnnotationContext) GetParser() antlr.Parser { return s.parser }

func (s *MarkerAnnotationContext) AT() antlr.TerminalNode {
	return s.GetToken(Java8ParserAT, 0)
}

func (s *MarkerAnnotationContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *MarkerAnnotationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MarkerAnnotationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MarkerAnnotationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterMarkerAnnotation(s)
	}
}

func (s *MarkerAnnotationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitMarkerAnnotation(s)
	}
}

func (p *Java8Parser) MarkerAnnotation() (localctx IMarkerAnnotationContext) {
	this := p
	_ = this

	localctx = NewMarkerAnnotationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 242, Java8ParserRULE_markerAnnotation)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1450)
		p.Match(Java8ParserAT)
	}
	{
		p.SetState(1451)
		p.TypeName()
	}

	return localctx
}

// ISingleElementAnnotationContext is an interface to support dynamic dispatch.
type ISingleElementAnnotationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSingleElementAnnotationContext differentiates from other interfaces.
	IsSingleElementAnnotationContext()
}

type SingleElementAnnotationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySingleElementAnnotationContext() *SingleElementAnnotationContext {
	var p = new(SingleElementAnnotationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_singleElementAnnotation
	return p
}

func (*SingleElementAnnotationContext) IsSingleElementAnnotationContext() {}

func NewSingleElementAnnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleElementAnnotationContext {
	var p = new(SingleElementAnnotationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_singleElementAnnotation

	return p
}

func (s *SingleElementAnnotationContext) GetParser() antlr.Parser { return s.parser }

func (s *SingleElementAnnotationContext) AT() antlr.TerminalNode {
	return s.GetToken(Java8ParserAT, 0)
}

func (s *SingleElementAnnotationContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *SingleElementAnnotationContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *SingleElementAnnotationContext) ElementValue() IElementValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementValueContext)
}

func (s *SingleElementAnnotationContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *SingleElementAnnotationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SingleElementAnnotationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SingleElementAnnotationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterSingleElementAnnotation(s)
	}
}

func (s *SingleElementAnnotationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitSingleElementAnnotation(s)
	}
}

func (p *Java8Parser) SingleElementAnnotation() (localctx ISingleElementAnnotationContext) {
	this := p
	_ = this

	localctx = NewSingleElementAnnotationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 244, Java8ParserRULE_singleElementAnnotation)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1453)
		p.Match(Java8ParserAT)
	}
	{
		p.SetState(1454)
		p.TypeName()
	}
	{
		p.SetState(1455)
		p.Match(Java8ParserLPAREN)
	}
	{
		p.SetState(1456)
		p.ElementValue()
	}
	{
		p.SetState(1457)
		p.Match(Java8ParserRPAREN)
	}

	return localctx
}

// IArrayInitializerContext is an interface to support dynamic dispatch.
type IArrayInitializerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArrayInitializerContext differentiates from other interfaces.
	IsArrayInitializerContext()
}

type ArrayInitializerContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArrayInitializerContext() *ArrayInitializerContext {
	var p = new(ArrayInitializerContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_arrayInitializer
	return p
}

func (*ArrayInitializerContext) IsArrayInitializerContext() {}

func NewArrayInitializerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayInitializerContext {
	var p = new(ArrayInitializerContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_arrayInitializer

	return p
}

func (s *ArrayInitializerContext) GetParser() antlr.Parser { return s.parser }

func (s *ArrayInitializerContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACE, 0)
}

func (s *ArrayInitializerContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACE, 0)
}

func (s *ArrayInitializerContext) VariableInitializerList() IVariableInitializerListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableInitializerListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableInitializerListContext)
}

func (s *ArrayInitializerContext) COMMA() antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, 0)
}

func (s *ArrayInitializerContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArrayInitializerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArrayInitializerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterArrayInitializer(s)
	}
}

func (s *ArrayInitializerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitArrayInitializer(s)
	}
}

func (p *Java8Parser) ArrayInitializer() (localctx IArrayInitializerContext) {
	this := p
	_ = this

	localctx = NewArrayInitializerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 246, Java8ParserRULE_arrayInitializer)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1459)
		p.Match(Java8ParserLBRACE)
	}
	p.SetState(1461)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37))|(1<<(Java8ParserLBRACE-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
		{
			p.SetState(1460)
			p.VariableInitializerList()
		}

	}
	p.SetState(1464)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserCOMMA {
		{
			p.SetState(1463)
			p.Match(Java8ParserCOMMA)
		}

	}
	{
		p.SetState(1466)
		p.Match(Java8ParserRBRACE)
	}

	return localctx
}

// IVariableInitializerListContext is an interface to support dynamic dispatch.
type IVariableInitializerListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsVariableInitializerListContext differentiates from other interfaces.
	IsVariableInitializerListContext()
}

type VariableInitializerListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVariableInitializerListContext() *VariableInitializerListContext {
	var p = new(VariableInitializerListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_variableInitializerList
	return p
}

func (*VariableInitializerListContext) IsVariableInitializerListContext() {}

func NewVariableInitializerListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableInitializerListContext {
	var p = new(VariableInitializerListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_variableInitializerList

	return p
}

func (s *VariableInitializerListContext) GetParser() antlr.Parser { return s.parser }

func (s *VariableInitializerListContext) AllVariableInitializer() []IVariableInitializerContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVariableInitializerContext)(nil)).Elem())
	var tst = make([]IVariableInitializerContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IVariableInitializerContext)
		}
	}

	return tst
}

func (s *VariableInitializerListContext) VariableInitializer(i int) IVariableInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableInitializerContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableInitializerContext)
}

func (s *VariableInitializerListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserCOMMA)
}

func (s *VariableInitializerListContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, i)
}

func (s *VariableInitializerListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VariableInitializerListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VariableInitializerListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterVariableInitializerList(s)
	}
}

func (s *VariableInitializerListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitVariableInitializerList(s)
	}
}

func (p *Java8Parser) VariableInitializerList() (localctx IVariableInitializerListContext) {
	this := p
	_ = this

	localctx = NewVariableInitializerListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 248, Java8ParserRULE_variableInitializerList)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1468)
		p.VariableInitializer()
	}
	p.SetState(1473)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 150, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1469)
				p.Match(Java8ParserCOMMA)
			}
			{
				p.SetState(1470)
				p.VariableInitializer()
			}

		}
		p.SetState(1475)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 150, p.GetParserRuleContext())
	}

	return localctx
}

// IBlockContext is an interface to support dynamic dispatch.
type IBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBlockContext differentiates from other interfaces.
	IsBlockContext()
}

type BlockContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBlockContext() *BlockContext {
	var p = new(BlockContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_block
	return p
}

func (*BlockContext) IsBlockContext() {}

func NewBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockContext {
	var p = new(BlockContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_block

	return p
}

func (s *BlockContext) GetParser() antlr.Parser { return s.parser }

func (s *BlockContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACE, 0)
}

func (s *BlockContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACE, 0)
}

func (s *BlockContext) BlockStatements() IBlockStatementsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockStatementsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockStatementsContext)
}

func (s *BlockContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BlockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterBlock(s)
	}
}

func (s *BlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitBlock(s)
	}
}

func (p *Java8Parser) Block() (localctx IBlockContext) {
	this := p
	_ = this

	localctx = NewBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 250, Java8ParserRULE_block)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1476)
		p.Match(Java8ParserLBRACE)
	}
	p.SetState(1478)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserABSTRACT)|(1<<Java8ParserASSERT)|(1<<Java8ParserBOOLEAN)|(1<<Java8ParserBREAK)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserCLASS)|(1<<Java8ParserCONTINUE)|(1<<Java8ParserDO)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserENUM)|(1<<Java8ParserFINAL)|(1<<Java8ParserFLOAT)|(1<<Java8ParserFOR)|(1<<Java8ParserIF)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(Java8ParserPRIVATE-33))|(1<<(Java8ParserPROTECTED-33))|(1<<(Java8ParserPUBLIC-33))|(1<<(Java8ParserRETURN-33))|(1<<(Java8ParserSHORT-33))|(1<<(Java8ParserSTATIC-33))|(1<<(Java8ParserSTRICTFP-33))|(1<<(Java8ParserSUPER-33))|(1<<(Java8ParserSWITCH-33))|(1<<(Java8ParserSYNCHRONIZED-33))|(1<<(Java8ParserTHIS-33))|(1<<(Java8ParserTHROW-33))|(1<<(Java8ParserTRY-33))|(1<<(Java8ParserVOID-33))|(1<<(Java8ParserWHILE-33))|(1<<(Java8ParserIntegerLiteral-33))|(1<<(Java8ParserFloatingPointLiteral-33))|(1<<(Java8ParserBooleanLiteral-33))|(1<<(Java8ParserCharacterLiteral-33))|(1<<(Java8ParserStringLiteral-33))|(1<<(Java8ParserNullLiteral-33))|(1<<(Java8ParserLPAREN-33))|(1<<(Java8ParserLBRACE-33))|(1<<(Java8ParserSEMI-33)))) != 0) || (((_la-79)&-(0x1f+1)) == 0 && ((1<<uint((_la-79)))&((1<<(Java8ParserINC-79))|(1<<(Java8ParserDEC-79))|(1<<(Java8ParserIdentifier-79))|(1<<(Java8ParserAT-79)))) != 0) {
		{
			p.SetState(1477)
			p.BlockStatements()
		}

	}
	{
		p.SetState(1480)
		p.Match(Java8ParserRBRACE)
	}

	return localctx
}

// IBlockStatementsContext is an interface to support dynamic dispatch.
type IBlockStatementsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBlockStatementsContext differentiates from other interfaces.
	IsBlockStatementsContext()
}

type BlockStatementsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBlockStatementsContext() *BlockStatementsContext {
	var p = new(BlockStatementsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_blockStatements
	return p
}

func (*BlockStatementsContext) IsBlockStatementsContext() {}

func NewBlockStatementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockStatementsContext {
	var p = new(BlockStatementsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_blockStatements

	return p
}

func (s *BlockStatementsContext) GetParser() antlr.Parser { return s.parser }

func (s *BlockStatementsContext) AllBlockStatement() []IBlockStatementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IBlockStatementContext)(nil)).Elem())
	var tst = make([]IBlockStatementContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IBlockStatementContext)
		}
	}

	return tst
}

func (s *BlockStatementsContext) BlockStatement(i int) IBlockStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IBlockStatementContext)
}

func (s *BlockStatementsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BlockStatementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BlockStatementsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterBlockStatements(s)
	}
}

func (s *BlockStatementsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitBlockStatements(s)
	}
}

func (p *Java8Parser) BlockStatements() (localctx IBlockStatementsContext) {
	this := p
	_ = this

	localctx = NewBlockStatementsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 252, Java8ParserRULE_blockStatements)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1483)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserABSTRACT)|(1<<Java8ParserASSERT)|(1<<Java8ParserBOOLEAN)|(1<<Java8ParserBREAK)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserCLASS)|(1<<Java8ParserCONTINUE)|(1<<Java8ParserDO)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserENUM)|(1<<Java8ParserFINAL)|(1<<Java8ParserFLOAT)|(1<<Java8ParserFOR)|(1<<Java8ParserIF)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(Java8ParserPRIVATE-33))|(1<<(Java8ParserPROTECTED-33))|(1<<(Java8ParserPUBLIC-33))|(1<<(Java8ParserRETURN-33))|(1<<(Java8ParserSHORT-33))|(1<<(Java8ParserSTATIC-33))|(1<<(Java8ParserSTRICTFP-33))|(1<<(Java8ParserSUPER-33))|(1<<(Java8ParserSWITCH-33))|(1<<(Java8ParserSYNCHRONIZED-33))|(1<<(Java8ParserTHIS-33))|(1<<(Java8ParserTHROW-33))|(1<<(Java8ParserTRY-33))|(1<<(Java8ParserVOID-33))|(1<<(Java8ParserWHILE-33))|(1<<(Java8ParserIntegerLiteral-33))|(1<<(Java8ParserFloatingPointLiteral-33))|(1<<(Java8ParserBooleanLiteral-33))|(1<<(Java8ParserCharacterLiteral-33))|(1<<(Java8ParserStringLiteral-33))|(1<<(Java8ParserNullLiteral-33))|(1<<(Java8ParserLPAREN-33))|(1<<(Java8ParserLBRACE-33))|(1<<(Java8ParserSEMI-33)))) != 0) || (((_la-79)&-(0x1f+1)) == 0 && ((1<<uint((_la-79)))&((1<<(Java8ParserINC-79))|(1<<(Java8ParserDEC-79))|(1<<(Java8ParserIdentifier-79))|(1<<(Java8ParserAT-79)))) != 0) {
		{
			p.SetState(1482)
			p.BlockStatement()
		}

		p.SetState(1485)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IBlockStatementContext is an interface to support dynamic dispatch.
type IBlockStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBlockStatementContext differentiates from other interfaces.
	IsBlockStatementContext()
}

type BlockStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBlockStatementContext() *BlockStatementContext {
	var p = new(BlockStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_blockStatement
	return p
}

func (*BlockStatementContext) IsBlockStatementContext() {}

func NewBlockStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockStatementContext {
	var p = new(BlockStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_blockStatement

	return p
}

func (s *BlockStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *BlockStatementContext) LocalVariableDeclarationStatement() ILocalVariableDeclarationStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILocalVariableDeclarationStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILocalVariableDeclarationStatementContext)
}

func (s *BlockStatementContext) ClassDeclaration() IClassDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassDeclarationContext)
}

func (s *BlockStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *BlockStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BlockStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BlockStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterBlockStatement(s)
	}
}

func (s *BlockStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitBlockStatement(s)
	}
}

func (p *Java8Parser) BlockStatement() (localctx IBlockStatementContext) {
	this := p
	_ = this

	localctx = NewBlockStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 254, Java8ParserRULE_blockStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1490)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 153, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1487)
			p.LocalVariableDeclarationStatement()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1488)
			p.ClassDeclaration()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1489)
			p.Statement()
		}

	}

	return localctx
}

// ILocalVariableDeclarationStatementContext is an interface to support dynamic dispatch.
type ILocalVariableDeclarationStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLocalVariableDeclarationStatementContext differentiates from other interfaces.
	IsLocalVariableDeclarationStatementContext()
}

type LocalVariableDeclarationStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLocalVariableDeclarationStatementContext() *LocalVariableDeclarationStatementContext {
	var p = new(LocalVariableDeclarationStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_localVariableDeclarationStatement
	return p
}

func (*LocalVariableDeclarationStatementContext) IsLocalVariableDeclarationStatementContext() {}

func NewLocalVariableDeclarationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LocalVariableDeclarationStatementContext {
	var p = new(LocalVariableDeclarationStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_localVariableDeclarationStatement

	return p
}

func (s *LocalVariableDeclarationStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *LocalVariableDeclarationStatementContext) LocalVariableDeclaration() ILocalVariableDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILocalVariableDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILocalVariableDeclarationContext)
}

func (s *LocalVariableDeclarationStatementContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *LocalVariableDeclarationStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LocalVariableDeclarationStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LocalVariableDeclarationStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterLocalVariableDeclarationStatement(s)
	}
}

func (s *LocalVariableDeclarationStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitLocalVariableDeclarationStatement(s)
	}
}

func (p *Java8Parser) LocalVariableDeclarationStatement() (localctx ILocalVariableDeclarationStatementContext) {
	this := p
	_ = this

	localctx = NewLocalVariableDeclarationStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 256, Java8ParserRULE_localVariableDeclarationStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1492)
		p.LocalVariableDeclaration()
	}
	{
		p.SetState(1493)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// ILocalVariableDeclarationContext is an interface to support dynamic dispatch.
type ILocalVariableDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLocalVariableDeclarationContext differentiates from other interfaces.
	IsLocalVariableDeclarationContext()
}

type LocalVariableDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLocalVariableDeclarationContext() *LocalVariableDeclarationContext {
	var p = new(LocalVariableDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_localVariableDeclaration
	return p
}

func (*LocalVariableDeclarationContext) IsLocalVariableDeclarationContext() {}

func NewLocalVariableDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LocalVariableDeclarationContext {
	var p = new(LocalVariableDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_localVariableDeclaration

	return p
}

func (s *LocalVariableDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *LocalVariableDeclarationContext) UnannType() IUnannTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannTypeContext)
}

func (s *LocalVariableDeclarationContext) VariableDeclaratorList() IVariableDeclaratorListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorListContext)
}

func (s *LocalVariableDeclarationContext) AllVariableModifier() []IVariableModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem())
	var tst = make([]IVariableModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IVariableModifierContext)
		}
	}

	return tst
}

func (s *LocalVariableDeclarationContext) VariableModifier(i int) IVariableModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableModifierContext)
}

func (s *LocalVariableDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LocalVariableDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LocalVariableDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterLocalVariableDeclaration(s)
	}
}

func (s *LocalVariableDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitLocalVariableDeclaration(s)
	}
}

func (p *Java8Parser) LocalVariableDeclaration() (localctx ILocalVariableDeclarationContext) {
	this := p
	_ = this

	localctx = NewLocalVariableDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 258, Java8ParserRULE_localVariableDeclaration)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1498)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserFINAL || _la == Java8ParserAT {
		{
			p.SetState(1495)
			p.VariableModifier()
		}

		p.SetState(1500)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1501)
		p.UnannType()
	}
	{
		p.SetState(1502)
		p.VariableDeclaratorList()
	}

	return localctx
}

// IStatementContext is an interface to support dynamic dispatch.
type IStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStatementContext differentiates from other interfaces.
	IsStatementContext()
}

type StatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStatementContext() *StatementContext {
	var p = new(StatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_statement
	return p
}

func (*StatementContext) IsStatementContext() {}

func NewStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementContext {
	var p = new(StatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_statement

	return p
}

func (s *StatementContext) GetParser() antlr.Parser { return s.parser }

func (s *StatementContext) StatementWithoutTrailingSubstatement() IStatementWithoutTrailingSubstatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementWithoutTrailingSubstatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementWithoutTrailingSubstatementContext)
}

func (s *StatementContext) LabeledStatement() ILabeledStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILabeledStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILabeledStatementContext)
}

func (s *StatementContext) IfThenStatement() IIfThenStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfThenStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfThenStatementContext)
}

func (s *StatementContext) IfThenElseStatement() IIfThenElseStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfThenElseStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfThenElseStatementContext)
}

func (s *StatementContext) WhileStatement() IWhileStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWhileStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWhileStatementContext)
}

func (s *StatementContext) ForStatement() IForStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForStatementContext)
}

func (s *StatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterStatement(s)
	}
}

func (s *StatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitStatement(s)
	}
}

func (p *Java8Parser) Statement() (localctx IStatementContext) {
	this := p
	_ = this

	localctx = NewStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 260, Java8ParserRULE_statement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1510)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 155, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1504)
			p.StatementWithoutTrailingSubstatement()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1505)
			p.LabeledStatement()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1506)
			p.IfThenStatement()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1507)
			p.IfThenElseStatement()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1508)
			p.WhileStatement()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1509)
			p.ForStatement()
		}

	}

	return localctx
}

// IStatementNoShortIfContext is an interface to support dynamic dispatch.
type IStatementNoShortIfContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStatementNoShortIfContext differentiates from other interfaces.
	IsStatementNoShortIfContext()
}

type StatementNoShortIfContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStatementNoShortIfContext() *StatementNoShortIfContext {
	var p = new(StatementNoShortIfContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_statementNoShortIf
	return p
}

func (*StatementNoShortIfContext) IsStatementNoShortIfContext() {}

func NewStatementNoShortIfContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementNoShortIfContext {
	var p = new(StatementNoShortIfContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_statementNoShortIf

	return p
}

func (s *StatementNoShortIfContext) GetParser() antlr.Parser { return s.parser }

func (s *StatementNoShortIfContext) StatementWithoutTrailingSubstatement() IStatementWithoutTrailingSubstatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementWithoutTrailingSubstatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementWithoutTrailingSubstatementContext)
}

func (s *StatementNoShortIfContext) LabeledStatementNoShortIf() ILabeledStatementNoShortIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILabeledStatementNoShortIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILabeledStatementNoShortIfContext)
}

func (s *StatementNoShortIfContext) IfThenElseStatementNoShortIf() IIfThenElseStatementNoShortIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfThenElseStatementNoShortIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfThenElseStatementNoShortIfContext)
}

func (s *StatementNoShortIfContext) WhileStatementNoShortIf() IWhileStatementNoShortIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWhileStatementNoShortIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWhileStatementNoShortIfContext)
}

func (s *StatementNoShortIfContext) ForStatementNoShortIf() IForStatementNoShortIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForStatementNoShortIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForStatementNoShortIfContext)
}

func (s *StatementNoShortIfContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StatementNoShortIfContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StatementNoShortIfContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterStatementNoShortIf(s)
	}
}

func (s *StatementNoShortIfContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitStatementNoShortIf(s)
	}
}

func (p *Java8Parser) StatementNoShortIf() (localctx IStatementNoShortIfContext) {
	this := p
	_ = this

	localctx = NewStatementNoShortIfContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 262, Java8ParserRULE_statementNoShortIf)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1517)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 156, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1512)
			p.StatementWithoutTrailingSubstatement()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1513)
			p.LabeledStatementNoShortIf()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1514)
			p.IfThenElseStatementNoShortIf()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1515)
			p.WhileStatementNoShortIf()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1516)
			p.ForStatementNoShortIf()
		}

	}

	return localctx
}

// IStatementWithoutTrailingSubstatementContext is an interface to support dynamic dispatch.
type IStatementWithoutTrailingSubstatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStatementWithoutTrailingSubstatementContext differentiates from other interfaces.
	IsStatementWithoutTrailingSubstatementContext()
}

type StatementWithoutTrailingSubstatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStatementWithoutTrailingSubstatementContext() *StatementWithoutTrailingSubstatementContext {
	var p = new(StatementWithoutTrailingSubstatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_statementWithoutTrailingSubstatement
	return p
}

func (*StatementWithoutTrailingSubstatementContext) IsStatementWithoutTrailingSubstatementContext() {}

func NewStatementWithoutTrailingSubstatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementWithoutTrailingSubstatementContext {
	var p = new(StatementWithoutTrailingSubstatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_statementWithoutTrailingSubstatement

	return p
}

func (s *StatementWithoutTrailingSubstatementContext) GetParser() antlr.Parser { return s.parser }

func (s *StatementWithoutTrailingSubstatementContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *StatementWithoutTrailingSubstatementContext) EmptyStatement_() IEmptyStatement_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEmptyStatement_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEmptyStatement_Context)
}

func (s *StatementWithoutTrailingSubstatementContext) ExpressionStatement() IExpressionStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionStatementContext)
}

func (s *StatementWithoutTrailingSubstatementContext) AssertStatement() IAssertStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssertStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssertStatementContext)
}

func (s *StatementWithoutTrailingSubstatementContext) SwitchStatement() ISwitchStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISwitchStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISwitchStatementContext)
}

func (s *StatementWithoutTrailingSubstatementContext) DoStatement() IDoStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDoStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDoStatementContext)
}

func (s *StatementWithoutTrailingSubstatementContext) BreakStatement() IBreakStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBreakStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBreakStatementContext)
}

func (s *StatementWithoutTrailingSubstatementContext) ContinueStatement() IContinueStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IContinueStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IContinueStatementContext)
}

func (s *StatementWithoutTrailingSubstatementContext) ReturnStatement() IReturnStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReturnStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReturnStatementContext)
}

func (s *StatementWithoutTrailingSubstatementContext) SynchronizedStatement() ISynchronizedStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISynchronizedStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISynchronizedStatementContext)
}

func (s *StatementWithoutTrailingSubstatementContext) ThrowStatement() IThrowStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IThrowStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IThrowStatementContext)
}

func (s *StatementWithoutTrailingSubstatementContext) TryStatement() ITryStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITryStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITryStatementContext)
}

func (s *StatementWithoutTrailingSubstatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StatementWithoutTrailingSubstatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StatementWithoutTrailingSubstatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterStatementWithoutTrailingSubstatement(s)
	}
}

func (s *StatementWithoutTrailingSubstatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitStatementWithoutTrailingSubstatement(s)
	}
}

func (p *Java8Parser) StatementWithoutTrailingSubstatement() (localctx IStatementWithoutTrailingSubstatementContext) {
	this := p
	_ = this

	localctx = NewStatementWithoutTrailingSubstatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 264, Java8ParserRULE_statementWithoutTrailingSubstatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1531)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserLBRACE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1519)
			p.Block()
		}

	case Java8ParserSEMI:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1520)
			p.EmptyStatement_()
		}

	case Java8ParserBOOLEAN, Java8ParserBYTE, Java8ParserCHAR, Java8ParserDOUBLE, Java8ParserFLOAT, Java8ParserINT, Java8ParserLONG, Java8ParserNEW, Java8ParserSHORT, Java8ParserSUPER, Java8ParserTHIS, Java8ParserVOID, Java8ParserIntegerLiteral, Java8ParserFloatingPointLiteral, Java8ParserBooleanLiteral, Java8ParserCharacterLiteral, Java8ParserStringLiteral, Java8ParserNullLiteral, Java8ParserLPAREN, Java8ParserINC, Java8ParserDEC, Java8ParserIdentifier, Java8ParserAT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1521)
			p.ExpressionStatement()
		}

	case Java8ParserASSERT:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1522)
			p.AssertStatement()
		}

	case Java8ParserSWITCH:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1523)
			p.SwitchStatement()
		}

	case Java8ParserDO:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1524)
			p.DoStatement()
		}

	case Java8ParserBREAK:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1525)
			p.BreakStatement()
		}

	case Java8ParserCONTINUE:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(1526)
			p.ContinueStatement()
		}

	case Java8ParserRETURN:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(1527)
			p.ReturnStatement()
		}

	case Java8ParserSYNCHRONIZED:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(1528)
			p.SynchronizedStatement()
		}

	case Java8ParserTHROW:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(1529)
			p.ThrowStatement()
		}

	case Java8ParserTRY:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(1530)
			p.TryStatement()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IEmptyStatement_Context is an interface to support dynamic dispatch.
type IEmptyStatement_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEmptyStatement_Context differentiates from other interfaces.
	IsEmptyStatement_Context()
}

type EmptyStatement_Context struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEmptyStatement_Context() *EmptyStatement_Context {
	var p = new(EmptyStatement_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_emptyStatement_
	return p
}

func (*EmptyStatement_Context) IsEmptyStatement_Context() {}

func NewEmptyStatement_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EmptyStatement_Context {
	var p = new(EmptyStatement_Context)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_emptyStatement_

	return p
}

func (s *EmptyStatement_Context) GetParser() antlr.Parser { return s.parser }

func (s *EmptyStatement_Context) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *EmptyStatement_Context) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EmptyStatement_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EmptyStatement_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterEmptyStatement_(s)
	}
}

func (s *EmptyStatement_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitEmptyStatement_(s)
	}
}

func (p *Java8Parser) EmptyStatement_() (localctx IEmptyStatement_Context) {
	this := p
	_ = this

	localctx = NewEmptyStatement_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 266, Java8ParserRULE_emptyStatement_)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1533)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// ILabeledStatementContext is an interface to support dynamic dispatch.
type ILabeledStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLabeledStatementContext differentiates from other interfaces.
	IsLabeledStatementContext()
}

type LabeledStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLabeledStatementContext() *LabeledStatementContext {
	var p = new(LabeledStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_labeledStatement
	return p
}

func (*LabeledStatementContext) IsLabeledStatementContext() {}

func NewLabeledStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LabeledStatementContext {
	var p = new(LabeledStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_labeledStatement

	return p
}

func (s *LabeledStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *LabeledStatementContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *LabeledStatementContext) COLON() antlr.TerminalNode {
	return s.GetToken(Java8ParserCOLON, 0)
}

func (s *LabeledStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *LabeledStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LabeledStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LabeledStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterLabeledStatement(s)
	}
}

func (s *LabeledStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitLabeledStatement(s)
	}
}

func (p *Java8Parser) LabeledStatement() (localctx ILabeledStatementContext) {
	this := p
	_ = this

	localctx = NewLabeledStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 268, Java8ParserRULE_labeledStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1535)
		p.Match(Java8ParserIdentifier)
	}
	{
		p.SetState(1536)
		p.Match(Java8ParserCOLON)
	}
	{
		p.SetState(1537)
		p.Statement()
	}

	return localctx
}

// ILabeledStatementNoShortIfContext is an interface to support dynamic dispatch.
type ILabeledStatementNoShortIfContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLabeledStatementNoShortIfContext differentiates from other interfaces.
	IsLabeledStatementNoShortIfContext()
}

type LabeledStatementNoShortIfContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLabeledStatementNoShortIfContext() *LabeledStatementNoShortIfContext {
	var p = new(LabeledStatementNoShortIfContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_labeledStatementNoShortIf
	return p
}

func (*LabeledStatementNoShortIfContext) IsLabeledStatementNoShortIfContext() {}

func NewLabeledStatementNoShortIfContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LabeledStatementNoShortIfContext {
	var p = new(LabeledStatementNoShortIfContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_labeledStatementNoShortIf

	return p
}

func (s *LabeledStatementNoShortIfContext) GetParser() antlr.Parser { return s.parser }

func (s *LabeledStatementNoShortIfContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *LabeledStatementNoShortIfContext) COLON() antlr.TerminalNode {
	return s.GetToken(Java8ParserCOLON, 0)
}

func (s *LabeledStatementNoShortIfContext) StatementNoShortIf() IStatementNoShortIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementNoShortIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementNoShortIfContext)
}

func (s *LabeledStatementNoShortIfContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LabeledStatementNoShortIfContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LabeledStatementNoShortIfContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterLabeledStatementNoShortIf(s)
	}
}

func (s *LabeledStatementNoShortIfContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitLabeledStatementNoShortIf(s)
	}
}

func (p *Java8Parser) LabeledStatementNoShortIf() (localctx ILabeledStatementNoShortIfContext) {
	this := p
	_ = this

	localctx = NewLabeledStatementNoShortIfContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 270, Java8ParserRULE_labeledStatementNoShortIf)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1539)
		p.Match(Java8ParserIdentifier)
	}
	{
		p.SetState(1540)
		p.Match(Java8ParserCOLON)
	}
	{
		p.SetState(1541)
		p.StatementNoShortIf()
	}

	return localctx
}

// IExpressionStatementContext is an interface to support dynamic dispatch.
type IExpressionStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExpressionStatementContext differentiates from other interfaces.
	IsExpressionStatementContext()
}

type ExpressionStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExpressionStatementContext() *ExpressionStatementContext {
	var p = new(ExpressionStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_expressionStatement
	return p
}

func (*ExpressionStatementContext) IsExpressionStatementContext() {}

func NewExpressionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionStatementContext {
	var p = new(ExpressionStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_expressionStatement

	return p
}

func (s *ExpressionStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *ExpressionStatementContext) StatementExpression() IStatementExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementExpressionContext)
}

func (s *ExpressionStatementContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *ExpressionStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExpressionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExpressionStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterExpressionStatement(s)
	}
}

func (s *ExpressionStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitExpressionStatement(s)
	}
}

func (p *Java8Parser) ExpressionStatement() (localctx IExpressionStatementContext) {
	this := p
	_ = this

	localctx = NewExpressionStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 272, Java8ParserRULE_expressionStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1543)
		p.StatementExpression()
	}
	{
		p.SetState(1544)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// IStatementExpressionContext is an interface to support dynamic dispatch.
type IStatementExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStatementExpressionContext differentiates from other interfaces.
	IsStatementExpressionContext()
}

type StatementExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStatementExpressionContext() *StatementExpressionContext {
	var p = new(StatementExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_statementExpression
	return p
}

func (*StatementExpressionContext) IsStatementExpressionContext() {}

func NewStatementExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementExpressionContext {
	var p = new(StatementExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_statementExpression

	return p
}

func (s *StatementExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *StatementExpressionContext) Assignment() IAssignmentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentContext)
}

func (s *StatementExpressionContext) PreIncrementExpression() IPreIncrementExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPreIncrementExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPreIncrementExpressionContext)
}

func (s *StatementExpressionContext) PreDecrementExpression() IPreDecrementExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPreDecrementExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPreDecrementExpressionContext)
}

func (s *StatementExpressionContext) PostIncrementExpression() IPostIncrementExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPostIncrementExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPostIncrementExpressionContext)
}

func (s *StatementExpressionContext) PostDecrementExpression() IPostDecrementExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPostDecrementExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPostDecrementExpressionContext)
}

func (s *StatementExpressionContext) MethodInvocation() IMethodInvocationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodInvocationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodInvocationContext)
}

func (s *StatementExpressionContext) ClassInstanceCreationExpression() IClassInstanceCreationExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassInstanceCreationExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassInstanceCreationExpressionContext)
}

func (s *StatementExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StatementExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StatementExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterStatementExpression(s)
	}
}

func (s *StatementExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitStatementExpression(s)
	}
}

func (p *Java8Parser) StatementExpression() (localctx IStatementExpressionContext) {
	this := p
	_ = this

	localctx = NewStatementExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 274, Java8ParserRULE_statementExpression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1553)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 158, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1546)
			p.Assignment()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1547)
			p.PreIncrementExpression()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1548)
			p.PreDecrementExpression()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1549)
			p.PostIncrementExpression()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1550)
			p.PostDecrementExpression()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1551)
			p.MethodInvocation()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1552)
			p.ClassInstanceCreationExpression()
		}

	}

	return localctx
}

// IIfThenStatementContext is an interface to support dynamic dispatch.
type IIfThenStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIfThenStatementContext differentiates from other interfaces.
	IsIfThenStatementContext()
}

type IfThenStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIfThenStatementContext() *IfThenStatementContext {
	var p = new(IfThenStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_ifThenStatement
	return p
}

func (*IfThenStatementContext) IsIfThenStatementContext() {}

func NewIfThenStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfThenStatementContext {
	var p = new(IfThenStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_ifThenStatement

	return p
}

func (s *IfThenStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *IfThenStatementContext) IF() antlr.TerminalNode {
	return s.GetToken(Java8ParserIF, 0)
}

func (s *IfThenStatementContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *IfThenStatementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *IfThenStatementContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *IfThenStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *IfThenStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IfThenStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IfThenStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterIfThenStatement(s)
	}
}

func (s *IfThenStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitIfThenStatement(s)
	}
}

func (p *Java8Parser) IfThenStatement() (localctx IIfThenStatementContext) {
	this := p
	_ = this

	localctx = NewIfThenStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 276, Java8ParserRULE_ifThenStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1555)
		p.Match(Java8ParserIF)
	}
	{
		p.SetState(1556)
		p.Match(Java8ParserLPAREN)
	}
	{
		p.SetState(1557)
		p.Expression()
	}
	{
		p.SetState(1558)
		p.Match(Java8ParserRPAREN)
	}
	{
		p.SetState(1559)
		p.Statement()
	}

	return localctx
}

// IIfThenElseStatementContext is an interface to support dynamic dispatch.
type IIfThenElseStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIfThenElseStatementContext differentiates from other interfaces.
	IsIfThenElseStatementContext()
}

type IfThenElseStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIfThenElseStatementContext() *IfThenElseStatementContext {
	var p = new(IfThenElseStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_ifThenElseStatement
	return p
}

func (*IfThenElseStatementContext) IsIfThenElseStatementContext() {}

func NewIfThenElseStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfThenElseStatementContext {
	var p = new(IfThenElseStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_ifThenElseStatement

	return p
}

func (s *IfThenElseStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *IfThenElseStatementContext) IF() antlr.TerminalNode {
	return s.GetToken(Java8ParserIF, 0)
}

func (s *IfThenElseStatementContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *IfThenElseStatementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *IfThenElseStatementContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *IfThenElseStatementContext) StatementNoShortIf() IStatementNoShortIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementNoShortIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementNoShortIfContext)
}

func (s *IfThenElseStatementContext) ELSE() antlr.TerminalNode {
	return s.GetToken(Java8ParserELSE, 0)
}

func (s *IfThenElseStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *IfThenElseStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IfThenElseStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IfThenElseStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterIfThenElseStatement(s)
	}
}

func (s *IfThenElseStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitIfThenElseStatement(s)
	}
}

func (p *Java8Parser) IfThenElseStatement() (localctx IIfThenElseStatementContext) {
	this := p
	_ = this

	localctx = NewIfThenElseStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 278, Java8ParserRULE_ifThenElseStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1561)
		p.Match(Java8ParserIF)
	}
	{
		p.SetState(1562)
		p.Match(Java8ParserLPAREN)
	}
	{
		p.SetState(1563)
		p.Expression()
	}
	{
		p.SetState(1564)
		p.Match(Java8ParserRPAREN)
	}
	{
		p.SetState(1565)
		p.StatementNoShortIf()
	}
	{
		p.SetState(1566)
		p.Match(Java8ParserELSE)
	}
	{
		p.SetState(1567)
		p.Statement()
	}

	return localctx
}

// IIfThenElseStatementNoShortIfContext is an interface to support dynamic dispatch.
type IIfThenElseStatementNoShortIfContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIfThenElseStatementNoShortIfContext differentiates from other interfaces.
	IsIfThenElseStatementNoShortIfContext()
}

type IfThenElseStatementNoShortIfContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIfThenElseStatementNoShortIfContext() *IfThenElseStatementNoShortIfContext {
	var p = new(IfThenElseStatementNoShortIfContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_ifThenElseStatementNoShortIf
	return p
}

func (*IfThenElseStatementNoShortIfContext) IsIfThenElseStatementNoShortIfContext() {}

func NewIfThenElseStatementNoShortIfContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfThenElseStatementNoShortIfContext {
	var p = new(IfThenElseStatementNoShortIfContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_ifThenElseStatementNoShortIf

	return p
}

func (s *IfThenElseStatementNoShortIfContext) GetParser() antlr.Parser { return s.parser }

func (s *IfThenElseStatementNoShortIfContext) IF() antlr.TerminalNode {
	return s.GetToken(Java8ParserIF, 0)
}

func (s *IfThenElseStatementNoShortIfContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *IfThenElseStatementNoShortIfContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *IfThenElseStatementNoShortIfContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *IfThenElseStatementNoShortIfContext) AllStatementNoShortIf() []IStatementNoShortIfContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IStatementNoShortIfContext)(nil)).Elem())
	var tst = make([]IStatementNoShortIfContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IStatementNoShortIfContext)
		}
	}

	return tst
}

func (s *IfThenElseStatementNoShortIfContext) StatementNoShortIf(i int) IStatementNoShortIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementNoShortIfContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IStatementNoShortIfContext)
}

func (s *IfThenElseStatementNoShortIfContext) ELSE() antlr.TerminalNode {
	return s.GetToken(Java8ParserELSE, 0)
}

func (s *IfThenElseStatementNoShortIfContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IfThenElseStatementNoShortIfContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IfThenElseStatementNoShortIfContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterIfThenElseStatementNoShortIf(s)
	}
}

func (s *IfThenElseStatementNoShortIfContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitIfThenElseStatementNoShortIf(s)
	}
}

func (p *Java8Parser) IfThenElseStatementNoShortIf() (localctx IIfThenElseStatementNoShortIfContext) {
	this := p
	_ = this

	localctx = NewIfThenElseStatementNoShortIfContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 280, Java8ParserRULE_ifThenElseStatementNoShortIf)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1569)
		p.Match(Java8ParserIF)
	}
	{
		p.SetState(1570)
		p.Match(Java8ParserLPAREN)
	}
	{
		p.SetState(1571)
		p.Expression()
	}
	{
		p.SetState(1572)
		p.Match(Java8ParserRPAREN)
	}
	{
		p.SetState(1573)
		p.StatementNoShortIf()
	}
	{
		p.SetState(1574)
		p.Match(Java8ParserELSE)
	}
	{
		p.SetState(1575)
		p.StatementNoShortIf()
	}

	return localctx
}

// IAssertStatementContext is an interface to support dynamic dispatch.
type IAssertStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssertStatementContext differentiates from other interfaces.
	IsAssertStatementContext()
}

type AssertStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssertStatementContext() *AssertStatementContext {
	var p = new(AssertStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_assertStatement
	return p
}

func (*AssertStatementContext) IsAssertStatementContext() {}

func NewAssertStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssertStatementContext {
	var p = new(AssertStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_assertStatement

	return p
}

func (s *AssertStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *AssertStatementContext) ASSERT() antlr.TerminalNode {
	return s.GetToken(Java8ParserASSERT, 0)
}

func (s *AssertStatementContext) AllExpression() []IExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem())
	var tst = make([]IExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IExpressionContext)
		}
	}

	return tst
}

func (s *AssertStatementContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *AssertStatementContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *AssertStatementContext) COLON() antlr.TerminalNode {
	return s.GetToken(Java8ParserCOLON, 0)
}

func (s *AssertStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssertStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssertStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterAssertStatement(s)
	}
}

func (s *AssertStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitAssertStatement(s)
	}
}

func (p *Java8Parser) AssertStatement() (localctx IAssertStatementContext) {
	this := p
	_ = this

	localctx = NewAssertStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 282, Java8ParserRULE_assertStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1587)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 159, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1577)
			p.Match(Java8ParserASSERT)
		}
		{
			p.SetState(1578)
			p.Expression()
		}
		{
			p.SetState(1579)
			p.Match(Java8ParserSEMI)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1581)
			p.Match(Java8ParserASSERT)
		}
		{
			p.SetState(1582)
			p.Expression()
		}
		{
			p.SetState(1583)
			p.Match(Java8ParserCOLON)
		}
		{
			p.SetState(1584)
			p.Expression()
		}
		{
			p.SetState(1585)
			p.Match(Java8ParserSEMI)
		}

	}

	return localctx
}

// ISwitchStatementContext is an interface to support dynamic dispatch.
type ISwitchStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSwitchStatementContext differentiates from other interfaces.
	IsSwitchStatementContext()
}

type SwitchStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySwitchStatementContext() *SwitchStatementContext {
	var p = new(SwitchStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_switchStatement
	return p
}

func (*SwitchStatementContext) IsSwitchStatementContext() {}

func NewSwitchStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwitchStatementContext {
	var p = new(SwitchStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_switchStatement

	return p
}

func (s *SwitchStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *SwitchStatementContext) SWITCH() antlr.TerminalNode {
	return s.GetToken(Java8ParserSWITCH, 0)
}

func (s *SwitchStatementContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *SwitchStatementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *SwitchStatementContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *SwitchStatementContext) SwitchBlock() ISwitchBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISwitchBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISwitchBlockContext)
}

func (s *SwitchStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SwitchStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SwitchStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterSwitchStatement(s)
	}
}

func (s *SwitchStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitSwitchStatement(s)
	}
}

func (p *Java8Parser) SwitchStatement() (localctx ISwitchStatementContext) {
	this := p
	_ = this

	localctx = NewSwitchStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 284, Java8ParserRULE_switchStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1589)
		p.Match(Java8ParserSWITCH)
	}
	{
		p.SetState(1590)
		p.Match(Java8ParserLPAREN)
	}
	{
		p.SetState(1591)
		p.Expression()
	}
	{
		p.SetState(1592)
		p.Match(Java8ParserRPAREN)
	}
	{
		p.SetState(1593)
		p.SwitchBlock()
	}

	return localctx
}

// ISwitchBlockContext is an interface to support dynamic dispatch.
type ISwitchBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSwitchBlockContext differentiates from other interfaces.
	IsSwitchBlockContext()
}

type SwitchBlockContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySwitchBlockContext() *SwitchBlockContext {
	var p = new(SwitchBlockContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_switchBlock
	return p
}

func (*SwitchBlockContext) IsSwitchBlockContext() {}

func NewSwitchBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwitchBlockContext {
	var p = new(SwitchBlockContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_switchBlock

	return p
}

func (s *SwitchBlockContext) GetParser() antlr.Parser { return s.parser }

func (s *SwitchBlockContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACE, 0)
}

func (s *SwitchBlockContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACE, 0)
}

func (s *SwitchBlockContext) AllSwitchBlockStatementGroup() []ISwitchBlockStatementGroupContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISwitchBlockStatementGroupContext)(nil)).Elem())
	var tst = make([]ISwitchBlockStatementGroupContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISwitchBlockStatementGroupContext)
		}
	}

	return tst
}

func (s *SwitchBlockContext) SwitchBlockStatementGroup(i int) ISwitchBlockStatementGroupContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISwitchBlockStatementGroupContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISwitchBlockStatementGroupContext)
}

func (s *SwitchBlockContext) AllSwitchLabel() []ISwitchLabelContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISwitchLabelContext)(nil)).Elem())
	var tst = make([]ISwitchLabelContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISwitchLabelContext)
		}
	}

	return tst
}

func (s *SwitchBlockContext) SwitchLabel(i int) ISwitchLabelContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISwitchLabelContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISwitchLabelContext)
}

func (s *SwitchBlockContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SwitchBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SwitchBlockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterSwitchBlock(s)
	}
}

func (s *SwitchBlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitSwitchBlock(s)
	}
}

func (p *Java8Parser) SwitchBlock() (localctx ISwitchBlockContext) {
	this := p
	_ = this

	localctx = NewSwitchBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 286, Java8ParserRULE_switchBlock)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1595)
		p.Match(Java8ParserLBRACE)
	}
	p.SetState(1599)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 160, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1596)
				p.SwitchBlockStatementGroup()
			}

		}
		p.SetState(1601)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 160, p.GetParserRuleContext())
	}
	p.SetState(1605)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserCASE || _la == Java8ParserDEFAULT {
		{
			p.SetState(1602)
			p.SwitchLabel()
		}

		p.SetState(1607)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1608)
		p.Match(Java8ParserRBRACE)
	}

	return localctx
}

// ISwitchBlockStatementGroupContext is an interface to support dynamic dispatch.
type ISwitchBlockStatementGroupContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSwitchBlockStatementGroupContext differentiates from other interfaces.
	IsSwitchBlockStatementGroupContext()
}

type SwitchBlockStatementGroupContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySwitchBlockStatementGroupContext() *SwitchBlockStatementGroupContext {
	var p = new(SwitchBlockStatementGroupContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_switchBlockStatementGroup
	return p
}

func (*SwitchBlockStatementGroupContext) IsSwitchBlockStatementGroupContext() {}

func NewSwitchBlockStatementGroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwitchBlockStatementGroupContext {
	var p = new(SwitchBlockStatementGroupContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_switchBlockStatementGroup

	return p
}

func (s *SwitchBlockStatementGroupContext) GetParser() antlr.Parser { return s.parser }

func (s *SwitchBlockStatementGroupContext) SwitchLabels() ISwitchLabelsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISwitchLabelsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISwitchLabelsContext)
}

func (s *SwitchBlockStatementGroupContext) BlockStatements() IBlockStatementsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockStatementsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockStatementsContext)
}

func (s *SwitchBlockStatementGroupContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SwitchBlockStatementGroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SwitchBlockStatementGroupContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterSwitchBlockStatementGroup(s)
	}
}

func (s *SwitchBlockStatementGroupContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitSwitchBlockStatementGroup(s)
	}
}

func (p *Java8Parser) SwitchBlockStatementGroup() (localctx ISwitchBlockStatementGroupContext) {
	this := p
	_ = this

	localctx = NewSwitchBlockStatementGroupContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 288, Java8ParserRULE_switchBlockStatementGroup)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1610)
		p.SwitchLabels()
	}
	{
		p.SetState(1611)
		p.BlockStatements()
	}

	return localctx
}

// ISwitchLabelsContext is an interface to support dynamic dispatch.
type ISwitchLabelsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSwitchLabelsContext differentiates from other interfaces.
	IsSwitchLabelsContext()
}

type SwitchLabelsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySwitchLabelsContext() *SwitchLabelsContext {
	var p = new(SwitchLabelsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_switchLabels
	return p
}

func (*SwitchLabelsContext) IsSwitchLabelsContext() {}

func NewSwitchLabelsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwitchLabelsContext {
	var p = new(SwitchLabelsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_switchLabels

	return p
}

func (s *SwitchLabelsContext) GetParser() antlr.Parser { return s.parser }

func (s *SwitchLabelsContext) AllSwitchLabel() []ISwitchLabelContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISwitchLabelContext)(nil)).Elem())
	var tst = make([]ISwitchLabelContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISwitchLabelContext)
		}
	}

	return tst
}

func (s *SwitchLabelsContext) SwitchLabel(i int) ISwitchLabelContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISwitchLabelContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISwitchLabelContext)
}

func (s *SwitchLabelsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SwitchLabelsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SwitchLabelsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterSwitchLabels(s)
	}
}

func (s *SwitchLabelsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitSwitchLabels(s)
	}
}

func (p *Java8Parser) SwitchLabels() (localctx ISwitchLabelsContext) {
	this := p
	_ = this

	localctx = NewSwitchLabelsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 290, Java8ParserRULE_switchLabels)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1613)
		p.SwitchLabel()
	}
	p.SetState(1617)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserCASE || _la == Java8ParserDEFAULT {
		{
			p.SetState(1614)
			p.SwitchLabel()
		}

		p.SetState(1619)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// ISwitchLabelContext is an interface to support dynamic dispatch.
type ISwitchLabelContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSwitchLabelContext differentiates from other interfaces.
	IsSwitchLabelContext()
}

type SwitchLabelContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySwitchLabelContext() *SwitchLabelContext {
	var p = new(SwitchLabelContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_switchLabel
	return p
}

func (*SwitchLabelContext) IsSwitchLabelContext() {}

func NewSwitchLabelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwitchLabelContext {
	var p = new(SwitchLabelContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_switchLabel

	return p
}

func (s *SwitchLabelContext) GetParser() antlr.Parser { return s.parser }

func (s *SwitchLabelContext) CASE() antlr.TerminalNode {
	return s.GetToken(Java8ParserCASE, 0)
}

func (s *SwitchLabelContext) ConstantExpression() IConstantExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantExpressionContext)
}

func (s *SwitchLabelContext) COLON() antlr.TerminalNode {
	return s.GetToken(Java8ParserCOLON, 0)
}

func (s *SwitchLabelContext) EnumConstantName() IEnumConstantNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumConstantNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumConstantNameContext)
}

func (s *SwitchLabelContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDEFAULT, 0)
}

func (s *SwitchLabelContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SwitchLabelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SwitchLabelContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterSwitchLabel(s)
	}
}

func (s *SwitchLabelContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitSwitchLabel(s)
	}
}

func (p *Java8Parser) SwitchLabel() (localctx ISwitchLabelContext) {
	this := p
	_ = this

	localctx = NewSwitchLabelContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 292, Java8ParserRULE_switchLabel)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1630)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 163, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1620)
			p.Match(Java8ParserCASE)
		}
		{
			p.SetState(1621)
			p.ConstantExpression()
		}
		{
			p.SetState(1622)
			p.Match(Java8ParserCOLON)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1624)
			p.Match(Java8ParserCASE)
		}
		{
			p.SetState(1625)
			p.EnumConstantName()
		}
		{
			p.SetState(1626)
			p.Match(Java8ParserCOLON)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1628)
			p.Match(Java8ParserDEFAULT)
		}
		{
			p.SetState(1629)
			p.Match(Java8ParserCOLON)
		}

	}

	return localctx
}

// IEnumConstantNameContext is an interface to support dynamic dispatch.
type IEnumConstantNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEnumConstantNameContext differentiates from other interfaces.
	IsEnumConstantNameContext()
}

type EnumConstantNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEnumConstantNameContext() *EnumConstantNameContext {
	var p = new(EnumConstantNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_enumConstantName
	return p
}

func (*EnumConstantNameContext) IsEnumConstantNameContext() {}

func NewEnumConstantNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumConstantNameContext {
	var p = new(EnumConstantNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_enumConstantName

	return p
}

func (s *EnumConstantNameContext) GetParser() antlr.Parser { return s.parser }

func (s *EnumConstantNameContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *EnumConstantNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EnumConstantNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EnumConstantNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterEnumConstantName(s)
	}
}

func (s *EnumConstantNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitEnumConstantName(s)
	}
}

func (p *Java8Parser) EnumConstantName() (localctx IEnumConstantNameContext) {
	this := p
	_ = this

	localctx = NewEnumConstantNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 294, Java8ParserRULE_enumConstantName)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1632)
		p.Match(Java8ParserIdentifier)
	}

	return localctx
}

// IWhileStatementContext is an interface to support dynamic dispatch.
type IWhileStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWhileStatementContext differentiates from other interfaces.
	IsWhileStatementContext()
}

type WhileStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWhileStatementContext() *WhileStatementContext {
	var p = new(WhileStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_whileStatement
	return p
}

func (*WhileStatementContext) IsWhileStatementContext() {}

func NewWhileStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhileStatementContext {
	var p = new(WhileStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_whileStatement

	return p
}

func (s *WhileStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *WhileStatementContext) WHILE() antlr.TerminalNode {
	return s.GetToken(Java8ParserWHILE, 0)
}

func (s *WhileStatementContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *WhileStatementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *WhileStatementContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *WhileStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *WhileStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *WhileStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *WhileStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterWhileStatement(s)
	}
}

func (s *WhileStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitWhileStatement(s)
	}
}

func (p *Java8Parser) WhileStatement() (localctx IWhileStatementContext) {
	this := p
	_ = this

	localctx = NewWhileStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 296, Java8ParserRULE_whileStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1634)
		p.Match(Java8ParserWHILE)
	}
	{
		p.SetState(1635)
		p.Match(Java8ParserLPAREN)
	}
	{
		p.SetState(1636)
		p.Expression()
	}
	{
		p.SetState(1637)
		p.Match(Java8ParserRPAREN)
	}
	{
		p.SetState(1638)
		p.Statement()
	}

	return localctx
}

// IWhileStatementNoShortIfContext is an interface to support dynamic dispatch.
type IWhileStatementNoShortIfContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWhileStatementNoShortIfContext differentiates from other interfaces.
	IsWhileStatementNoShortIfContext()
}

type WhileStatementNoShortIfContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWhileStatementNoShortIfContext() *WhileStatementNoShortIfContext {
	var p = new(WhileStatementNoShortIfContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_whileStatementNoShortIf
	return p
}

func (*WhileStatementNoShortIfContext) IsWhileStatementNoShortIfContext() {}

func NewWhileStatementNoShortIfContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhileStatementNoShortIfContext {
	var p = new(WhileStatementNoShortIfContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_whileStatementNoShortIf

	return p
}

func (s *WhileStatementNoShortIfContext) GetParser() antlr.Parser { return s.parser }

func (s *WhileStatementNoShortIfContext) WHILE() antlr.TerminalNode {
	return s.GetToken(Java8ParserWHILE, 0)
}

func (s *WhileStatementNoShortIfContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *WhileStatementNoShortIfContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *WhileStatementNoShortIfContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *WhileStatementNoShortIfContext) StatementNoShortIf() IStatementNoShortIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementNoShortIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementNoShortIfContext)
}

func (s *WhileStatementNoShortIfContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *WhileStatementNoShortIfContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *WhileStatementNoShortIfContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterWhileStatementNoShortIf(s)
	}
}

func (s *WhileStatementNoShortIfContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitWhileStatementNoShortIf(s)
	}
}

func (p *Java8Parser) WhileStatementNoShortIf() (localctx IWhileStatementNoShortIfContext) {
	this := p
	_ = this

	localctx = NewWhileStatementNoShortIfContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 298, Java8ParserRULE_whileStatementNoShortIf)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1640)
		p.Match(Java8ParserWHILE)
	}
	{
		p.SetState(1641)
		p.Match(Java8ParserLPAREN)
	}
	{
		p.SetState(1642)
		p.Expression()
	}
	{
		p.SetState(1643)
		p.Match(Java8ParserRPAREN)
	}
	{
		p.SetState(1644)
		p.StatementNoShortIf()
	}

	return localctx
}

// IDoStatementContext is an interface to support dynamic dispatch.
type IDoStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDoStatementContext differentiates from other interfaces.
	IsDoStatementContext()
}

type DoStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDoStatementContext() *DoStatementContext {
	var p = new(DoStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_doStatement
	return p
}

func (*DoStatementContext) IsDoStatementContext() {}

func NewDoStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DoStatementContext {
	var p = new(DoStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_doStatement

	return p
}

func (s *DoStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *DoStatementContext) DO() antlr.TerminalNode {
	return s.GetToken(Java8ParserDO, 0)
}

func (s *DoStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *DoStatementContext) WHILE() antlr.TerminalNode {
	return s.GetToken(Java8ParserWHILE, 0)
}

func (s *DoStatementContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *DoStatementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *DoStatementContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *DoStatementContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *DoStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DoStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DoStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterDoStatement(s)
	}
}

func (s *DoStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitDoStatement(s)
	}
}

func (p *Java8Parser) DoStatement() (localctx IDoStatementContext) {
	this := p
	_ = this

	localctx = NewDoStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 300, Java8ParserRULE_doStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1646)
		p.Match(Java8ParserDO)
	}
	{
		p.SetState(1647)
		p.Statement()
	}
	{
		p.SetState(1648)
		p.Match(Java8ParserWHILE)
	}
	{
		p.SetState(1649)
		p.Match(Java8ParserLPAREN)
	}
	{
		p.SetState(1650)
		p.Expression()
	}
	{
		p.SetState(1651)
		p.Match(Java8ParserRPAREN)
	}
	{
		p.SetState(1652)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// IForStatementContext is an interface to support dynamic dispatch.
type IForStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForStatementContext differentiates from other interfaces.
	IsForStatementContext()
}

type ForStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyForStatementContext() *ForStatementContext {
	var p = new(ForStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_forStatement
	return p
}

func (*ForStatementContext) IsForStatementContext() {}

func NewForStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForStatementContext {
	var p = new(ForStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_forStatement

	return p
}

func (s *ForStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *ForStatementContext) BasicForStatement() IBasicForStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBasicForStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBasicForStatementContext)
}

func (s *ForStatementContext) EnhancedForStatement() IEnhancedForStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnhancedForStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnhancedForStatementContext)
}

func (s *ForStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ForStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ForStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterForStatement(s)
	}
}

func (s *ForStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitForStatement(s)
	}
}

func (p *Java8Parser) ForStatement() (localctx IForStatementContext) {
	this := p
	_ = this

	localctx = NewForStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 302, Java8ParserRULE_forStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1656)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 164, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1654)
			p.BasicForStatement()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1655)
			p.EnhancedForStatement()
		}

	}

	return localctx
}

// IForStatementNoShortIfContext is an interface to support dynamic dispatch.
type IForStatementNoShortIfContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForStatementNoShortIfContext differentiates from other interfaces.
	IsForStatementNoShortIfContext()
}

type ForStatementNoShortIfContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyForStatementNoShortIfContext() *ForStatementNoShortIfContext {
	var p = new(ForStatementNoShortIfContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_forStatementNoShortIf
	return p
}

func (*ForStatementNoShortIfContext) IsForStatementNoShortIfContext() {}

func NewForStatementNoShortIfContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForStatementNoShortIfContext {
	var p = new(ForStatementNoShortIfContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_forStatementNoShortIf

	return p
}

func (s *ForStatementNoShortIfContext) GetParser() antlr.Parser { return s.parser }

func (s *ForStatementNoShortIfContext) BasicForStatementNoShortIf() IBasicForStatementNoShortIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBasicForStatementNoShortIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBasicForStatementNoShortIfContext)
}

func (s *ForStatementNoShortIfContext) EnhancedForStatementNoShortIf() IEnhancedForStatementNoShortIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnhancedForStatementNoShortIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnhancedForStatementNoShortIfContext)
}

func (s *ForStatementNoShortIfContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ForStatementNoShortIfContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ForStatementNoShortIfContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterForStatementNoShortIf(s)
	}
}

func (s *ForStatementNoShortIfContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitForStatementNoShortIf(s)
	}
}

func (p *Java8Parser) ForStatementNoShortIf() (localctx IForStatementNoShortIfContext) {
	this := p
	_ = this

	localctx = NewForStatementNoShortIfContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 304, Java8ParserRULE_forStatementNoShortIf)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1660)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 165, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1658)
			p.BasicForStatementNoShortIf()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1659)
			p.EnhancedForStatementNoShortIf()
		}

	}

	return localctx
}

// IBasicForStatementContext is an interface to support dynamic dispatch.
type IBasicForStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBasicForStatementContext differentiates from other interfaces.
	IsBasicForStatementContext()
}

type BasicForStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBasicForStatementContext() *BasicForStatementContext {
	var p = new(BasicForStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_basicForStatement
	return p
}

func (*BasicForStatementContext) IsBasicForStatementContext() {}

func NewBasicForStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BasicForStatementContext {
	var p = new(BasicForStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_basicForStatement

	return p
}

func (s *BasicForStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *BasicForStatementContext) FOR() antlr.TerminalNode {
	return s.GetToken(Java8ParserFOR, 0)
}

func (s *BasicForStatementContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *BasicForStatementContext) AllSEMI() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserSEMI)
}

func (s *BasicForStatementContext) SEMI(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, i)
}

func (s *BasicForStatementContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *BasicForStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *BasicForStatementContext) ForInit() IForInitContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForInitContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForInitContext)
}

func (s *BasicForStatementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *BasicForStatementContext) ForUpdate() IForUpdateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForUpdateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForUpdateContext)
}

func (s *BasicForStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BasicForStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BasicForStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterBasicForStatement(s)
	}
}

func (s *BasicForStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitBasicForStatement(s)
	}
}

func (p *Java8Parser) BasicForStatement() (localctx IBasicForStatementContext) {
	this := p
	_ = this

	localctx = NewBasicForStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 306, Java8ParserRULE_basicForStatement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1662)
		p.Match(Java8ParserFOR)
	}
	{
		p.SetState(1663)
		p.Match(Java8ParserLPAREN)
	}
	p.SetState(1665)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFINAL)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-79)&-(0x1f+1)) == 0 && ((1<<uint((_la-79)))&((1<<(Java8ParserINC-79))|(1<<(Java8ParserDEC-79))|(1<<(Java8ParserIdentifier-79))|(1<<(Java8ParserAT-79)))) != 0) {
		{
			p.SetState(1664)
			p.ForInit()
		}

	}
	{
		p.SetState(1667)
		p.Match(Java8ParserSEMI)
	}
	p.SetState(1669)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
		{
			p.SetState(1668)
			p.Expression()
		}

	}
	{
		p.SetState(1671)
		p.Match(Java8ParserSEMI)
	}
	p.SetState(1673)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-79)&-(0x1f+1)) == 0 && ((1<<uint((_la-79)))&((1<<(Java8ParserINC-79))|(1<<(Java8ParserDEC-79))|(1<<(Java8ParserIdentifier-79))|(1<<(Java8ParserAT-79)))) != 0) {
		{
			p.SetState(1672)
			p.ForUpdate()
		}

	}
	{
		p.SetState(1675)
		p.Match(Java8ParserRPAREN)
	}
	{
		p.SetState(1676)
		p.Statement()
	}

	return localctx
}

// IBasicForStatementNoShortIfContext is an interface to support dynamic dispatch.
type IBasicForStatementNoShortIfContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBasicForStatementNoShortIfContext differentiates from other interfaces.
	IsBasicForStatementNoShortIfContext()
}

type BasicForStatementNoShortIfContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBasicForStatementNoShortIfContext() *BasicForStatementNoShortIfContext {
	var p = new(BasicForStatementNoShortIfContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_basicForStatementNoShortIf
	return p
}

func (*BasicForStatementNoShortIfContext) IsBasicForStatementNoShortIfContext() {}

func NewBasicForStatementNoShortIfContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BasicForStatementNoShortIfContext {
	var p = new(BasicForStatementNoShortIfContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_basicForStatementNoShortIf

	return p
}

func (s *BasicForStatementNoShortIfContext) GetParser() antlr.Parser { return s.parser }

func (s *BasicForStatementNoShortIfContext) FOR() antlr.TerminalNode {
	return s.GetToken(Java8ParserFOR, 0)
}

func (s *BasicForStatementNoShortIfContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *BasicForStatementNoShortIfContext) AllSEMI() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserSEMI)
}

func (s *BasicForStatementNoShortIfContext) SEMI(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, i)
}

func (s *BasicForStatementNoShortIfContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *BasicForStatementNoShortIfContext) StatementNoShortIf() IStatementNoShortIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementNoShortIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementNoShortIfContext)
}

func (s *BasicForStatementNoShortIfContext) ForInit() IForInitContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForInitContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForInitContext)
}

func (s *BasicForStatementNoShortIfContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *BasicForStatementNoShortIfContext) ForUpdate() IForUpdateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForUpdateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForUpdateContext)
}

func (s *BasicForStatementNoShortIfContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BasicForStatementNoShortIfContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BasicForStatementNoShortIfContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterBasicForStatementNoShortIf(s)
	}
}

func (s *BasicForStatementNoShortIfContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitBasicForStatementNoShortIf(s)
	}
}

func (p *Java8Parser) BasicForStatementNoShortIf() (localctx IBasicForStatementNoShortIfContext) {
	this := p
	_ = this

	localctx = NewBasicForStatementNoShortIfContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 308, Java8ParserRULE_basicForStatementNoShortIf)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1678)
		p.Match(Java8ParserFOR)
	}
	{
		p.SetState(1679)
		p.Match(Java8ParserLPAREN)
	}
	p.SetState(1681)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFINAL)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-79)&-(0x1f+1)) == 0 && ((1<<uint((_la-79)))&((1<<(Java8ParserINC-79))|(1<<(Java8ParserDEC-79))|(1<<(Java8ParserIdentifier-79))|(1<<(Java8ParserAT-79)))) != 0) {
		{
			p.SetState(1680)
			p.ForInit()
		}

	}
	{
		p.SetState(1683)
		p.Match(Java8ParserSEMI)
	}
	p.SetState(1685)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
		{
			p.SetState(1684)
			p.Expression()
		}

	}
	{
		p.SetState(1687)
		p.Match(Java8ParserSEMI)
	}
	p.SetState(1689)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-79)&-(0x1f+1)) == 0 && ((1<<uint((_la-79)))&((1<<(Java8ParserINC-79))|(1<<(Java8ParserDEC-79))|(1<<(Java8ParserIdentifier-79))|(1<<(Java8ParserAT-79)))) != 0) {
		{
			p.SetState(1688)
			p.ForUpdate()
		}

	}
	{
		p.SetState(1691)
		p.Match(Java8ParserRPAREN)
	}
	{
		p.SetState(1692)
		p.StatementNoShortIf()
	}

	return localctx
}

// IForInitContext is an interface to support dynamic dispatch.
type IForInitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForInitContext differentiates from other interfaces.
	IsForInitContext()
}

type ForInitContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyForInitContext() *ForInitContext {
	var p = new(ForInitContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_forInit
	return p
}

func (*ForInitContext) IsForInitContext() {}

func NewForInitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForInitContext {
	var p = new(ForInitContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_forInit

	return p
}

func (s *ForInitContext) GetParser() antlr.Parser { return s.parser }

func (s *ForInitContext) StatementExpressionList() IStatementExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementExpressionListContext)
}

func (s *ForInitContext) LocalVariableDeclaration() ILocalVariableDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILocalVariableDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILocalVariableDeclarationContext)
}

func (s *ForInitContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ForInitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ForInitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterForInit(s)
	}
}

func (s *ForInitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitForInit(s)
	}
}

func (p *Java8Parser) ForInit() (localctx IForInitContext) {
	this := p
	_ = this

	localctx = NewForInitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 310, Java8ParserRULE_forInit)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1696)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 172, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1694)
			p.StatementExpressionList()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1695)
			p.LocalVariableDeclaration()
		}

	}

	return localctx
}

// IForUpdateContext is an interface to support dynamic dispatch.
type IForUpdateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForUpdateContext differentiates from other interfaces.
	IsForUpdateContext()
}

type ForUpdateContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyForUpdateContext() *ForUpdateContext {
	var p = new(ForUpdateContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_forUpdate
	return p
}

func (*ForUpdateContext) IsForUpdateContext() {}

func NewForUpdateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForUpdateContext {
	var p = new(ForUpdateContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_forUpdate

	return p
}

func (s *ForUpdateContext) GetParser() antlr.Parser { return s.parser }

func (s *ForUpdateContext) StatementExpressionList() IStatementExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementExpressionListContext)
}

func (s *ForUpdateContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ForUpdateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ForUpdateContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterForUpdate(s)
	}
}

func (s *ForUpdateContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitForUpdate(s)
	}
}

func (p *Java8Parser) ForUpdate() (localctx IForUpdateContext) {
	this := p
	_ = this

	localctx = NewForUpdateContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 312, Java8ParserRULE_forUpdate)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1698)
		p.StatementExpressionList()
	}

	return localctx
}

// IStatementExpressionListContext is an interface to support dynamic dispatch.
type IStatementExpressionListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStatementExpressionListContext differentiates from other interfaces.
	IsStatementExpressionListContext()
}

type StatementExpressionListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStatementExpressionListContext() *StatementExpressionListContext {
	var p = new(StatementExpressionListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_statementExpressionList
	return p
}

func (*StatementExpressionListContext) IsStatementExpressionListContext() {}

func NewStatementExpressionListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementExpressionListContext {
	var p = new(StatementExpressionListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_statementExpressionList

	return p
}

func (s *StatementExpressionListContext) GetParser() antlr.Parser { return s.parser }

func (s *StatementExpressionListContext) AllStatementExpression() []IStatementExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IStatementExpressionContext)(nil)).Elem())
	var tst = make([]IStatementExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IStatementExpressionContext)
		}
	}

	return tst
}

func (s *StatementExpressionListContext) StatementExpression(i int) IStatementExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IStatementExpressionContext)
}

func (s *StatementExpressionListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserCOMMA)
}

func (s *StatementExpressionListContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, i)
}

func (s *StatementExpressionListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StatementExpressionListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StatementExpressionListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterStatementExpressionList(s)
	}
}

func (s *StatementExpressionListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitStatementExpressionList(s)
	}
}

func (p *Java8Parser) StatementExpressionList() (localctx IStatementExpressionListContext) {
	this := p
	_ = this

	localctx = NewStatementExpressionListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 314, Java8ParserRULE_statementExpressionList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1700)
		p.StatementExpression()
	}
	p.SetState(1705)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserCOMMA {
		{
			p.SetState(1701)
			p.Match(Java8ParserCOMMA)
		}
		{
			p.SetState(1702)
			p.StatementExpression()
		}

		p.SetState(1707)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IEnhancedForStatementContext is an interface to support dynamic dispatch.
type IEnhancedForStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEnhancedForStatementContext differentiates from other interfaces.
	IsEnhancedForStatementContext()
}

type EnhancedForStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEnhancedForStatementContext() *EnhancedForStatementContext {
	var p = new(EnhancedForStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_enhancedForStatement
	return p
}

func (*EnhancedForStatementContext) IsEnhancedForStatementContext() {}

func NewEnhancedForStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnhancedForStatementContext {
	var p = new(EnhancedForStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_enhancedForStatement

	return p
}

func (s *EnhancedForStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *EnhancedForStatementContext) FOR() antlr.TerminalNode {
	return s.GetToken(Java8ParserFOR, 0)
}

func (s *EnhancedForStatementContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *EnhancedForStatementContext) UnannType() IUnannTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannTypeContext)
}

func (s *EnhancedForStatementContext) VariableDeclaratorId() IVariableDeclaratorIdContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorIdContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorIdContext)
}

func (s *EnhancedForStatementContext) COLON() antlr.TerminalNode {
	return s.GetToken(Java8ParserCOLON, 0)
}

func (s *EnhancedForStatementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *EnhancedForStatementContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *EnhancedForStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *EnhancedForStatementContext) AllVariableModifier() []IVariableModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem())
	var tst = make([]IVariableModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IVariableModifierContext)
		}
	}

	return tst
}

func (s *EnhancedForStatementContext) VariableModifier(i int) IVariableModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableModifierContext)
}

func (s *EnhancedForStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EnhancedForStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EnhancedForStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterEnhancedForStatement(s)
	}
}

func (s *EnhancedForStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitEnhancedForStatement(s)
	}
}

func (p *Java8Parser) EnhancedForStatement() (localctx IEnhancedForStatementContext) {
	this := p
	_ = this

	localctx = NewEnhancedForStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 316, Java8ParserRULE_enhancedForStatement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1708)
		p.Match(Java8ParserFOR)
	}
	{
		p.SetState(1709)
		p.Match(Java8ParserLPAREN)
	}
	p.SetState(1713)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserFINAL || _la == Java8ParserAT {
		{
			p.SetState(1710)
			p.VariableModifier()
		}

		p.SetState(1715)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1716)
		p.UnannType()
	}
	{
		p.SetState(1717)
		p.VariableDeclaratorId()
	}
	{
		p.SetState(1718)
		p.Match(Java8ParserCOLON)
	}
	{
		p.SetState(1719)
		p.Expression()
	}
	{
		p.SetState(1720)
		p.Match(Java8ParserRPAREN)
	}
	{
		p.SetState(1721)
		p.Statement()
	}

	return localctx
}

// IEnhancedForStatementNoShortIfContext is an interface to support dynamic dispatch.
type IEnhancedForStatementNoShortIfContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEnhancedForStatementNoShortIfContext differentiates from other interfaces.
	IsEnhancedForStatementNoShortIfContext()
}

type EnhancedForStatementNoShortIfContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEnhancedForStatementNoShortIfContext() *EnhancedForStatementNoShortIfContext {
	var p = new(EnhancedForStatementNoShortIfContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_enhancedForStatementNoShortIf
	return p
}

func (*EnhancedForStatementNoShortIfContext) IsEnhancedForStatementNoShortIfContext() {}

func NewEnhancedForStatementNoShortIfContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnhancedForStatementNoShortIfContext {
	var p = new(EnhancedForStatementNoShortIfContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_enhancedForStatementNoShortIf

	return p
}

func (s *EnhancedForStatementNoShortIfContext) GetParser() antlr.Parser { return s.parser }

func (s *EnhancedForStatementNoShortIfContext) FOR() antlr.TerminalNode {
	return s.GetToken(Java8ParserFOR, 0)
}

func (s *EnhancedForStatementNoShortIfContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *EnhancedForStatementNoShortIfContext) UnannType() IUnannTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannTypeContext)
}

func (s *EnhancedForStatementNoShortIfContext) VariableDeclaratorId() IVariableDeclaratorIdContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorIdContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorIdContext)
}

func (s *EnhancedForStatementNoShortIfContext) COLON() antlr.TerminalNode {
	return s.GetToken(Java8ParserCOLON, 0)
}

func (s *EnhancedForStatementNoShortIfContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *EnhancedForStatementNoShortIfContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *EnhancedForStatementNoShortIfContext) StatementNoShortIf() IStatementNoShortIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementNoShortIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementNoShortIfContext)
}

func (s *EnhancedForStatementNoShortIfContext) AllVariableModifier() []IVariableModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem())
	var tst = make([]IVariableModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IVariableModifierContext)
		}
	}

	return tst
}

func (s *EnhancedForStatementNoShortIfContext) VariableModifier(i int) IVariableModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableModifierContext)
}

func (s *EnhancedForStatementNoShortIfContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EnhancedForStatementNoShortIfContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EnhancedForStatementNoShortIfContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterEnhancedForStatementNoShortIf(s)
	}
}

func (s *EnhancedForStatementNoShortIfContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitEnhancedForStatementNoShortIf(s)
	}
}

func (p *Java8Parser) EnhancedForStatementNoShortIf() (localctx IEnhancedForStatementNoShortIfContext) {
	this := p
	_ = this

	localctx = NewEnhancedForStatementNoShortIfContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 318, Java8ParserRULE_enhancedForStatementNoShortIf)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1723)
		p.Match(Java8ParserFOR)
	}
	{
		p.SetState(1724)
		p.Match(Java8ParserLPAREN)
	}
	p.SetState(1728)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserFINAL || _la == Java8ParserAT {
		{
			p.SetState(1725)
			p.VariableModifier()
		}

		p.SetState(1730)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1731)
		p.UnannType()
	}
	{
		p.SetState(1732)
		p.VariableDeclaratorId()
	}
	{
		p.SetState(1733)
		p.Match(Java8ParserCOLON)
	}
	{
		p.SetState(1734)
		p.Expression()
	}
	{
		p.SetState(1735)
		p.Match(Java8ParserRPAREN)
	}
	{
		p.SetState(1736)
		p.StatementNoShortIf()
	}

	return localctx
}

// IBreakStatementContext is an interface to support dynamic dispatch.
type IBreakStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBreakStatementContext differentiates from other interfaces.
	IsBreakStatementContext()
}

type BreakStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBreakStatementContext() *BreakStatementContext {
	var p = new(BreakStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_breakStatement
	return p
}

func (*BreakStatementContext) IsBreakStatementContext() {}

func NewBreakStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BreakStatementContext {
	var p = new(BreakStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_breakStatement

	return p
}

func (s *BreakStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *BreakStatementContext) BREAK() antlr.TerminalNode {
	return s.GetToken(Java8ParserBREAK, 0)
}

func (s *BreakStatementContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *BreakStatementContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *BreakStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BreakStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BreakStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterBreakStatement(s)
	}
}

func (s *BreakStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitBreakStatement(s)
	}
}

func (p *Java8Parser) BreakStatement() (localctx IBreakStatementContext) {
	this := p
	_ = this

	localctx = NewBreakStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 320, Java8ParserRULE_breakStatement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1738)
		p.Match(Java8ParserBREAK)
	}
	p.SetState(1740)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserIdentifier {
		{
			p.SetState(1739)
			p.Match(Java8ParserIdentifier)
		}

	}
	{
		p.SetState(1742)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// IContinueStatementContext is an interface to support dynamic dispatch.
type IContinueStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsContinueStatementContext differentiates from other interfaces.
	IsContinueStatementContext()
}

type ContinueStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyContinueStatementContext() *ContinueStatementContext {
	var p = new(ContinueStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_continueStatement
	return p
}

func (*ContinueStatementContext) IsContinueStatementContext() {}

func NewContinueStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ContinueStatementContext {
	var p = new(ContinueStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_continueStatement

	return p
}

func (s *ContinueStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *ContinueStatementContext) CONTINUE() antlr.TerminalNode {
	return s.GetToken(Java8ParserCONTINUE, 0)
}

func (s *ContinueStatementContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *ContinueStatementContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *ContinueStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ContinueStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ContinueStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterContinueStatement(s)
	}
}

func (s *ContinueStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitContinueStatement(s)
	}
}

func (p *Java8Parser) ContinueStatement() (localctx IContinueStatementContext) {
	this := p
	_ = this

	localctx = NewContinueStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 322, Java8ParserRULE_continueStatement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1744)
		p.Match(Java8ParserCONTINUE)
	}
	p.SetState(1746)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserIdentifier {
		{
			p.SetState(1745)
			p.Match(Java8ParserIdentifier)
		}

	}
	{
		p.SetState(1748)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// IReturnStatementContext is an interface to support dynamic dispatch.
type IReturnStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsReturnStatementContext differentiates from other interfaces.
	IsReturnStatementContext()
}

type ReturnStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReturnStatementContext() *ReturnStatementContext {
	var p = new(ReturnStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_returnStatement
	return p
}

func (*ReturnStatementContext) IsReturnStatementContext() {}

func NewReturnStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnStatementContext {
	var p = new(ReturnStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_returnStatement

	return p
}

func (s *ReturnStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *ReturnStatementContext) RETURN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRETURN, 0)
}

func (s *ReturnStatementContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *ReturnStatementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ReturnStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ReturnStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ReturnStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterReturnStatement(s)
	}
}

func (s *ReturnStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitReturnStatement(s)
	}
}

func (p *Java8Parser) ReturnStatement() (localctx IReturnStatementContext) {
	this := p
	_ = this

	localctx = NewReturnStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 324, Java8ParserRULE_returnStatement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1750)
		p.Match(Java8ParserRETURN)
	}
	p.SetState(1752)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
		{
			p.SetState(1751)
			p.Expression()
		}

	}
	{
		p.SetState(1754)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// IThrowStatementContext is an interface to support dynamic dispatch.
type IThrowStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsThrowStatementContext differentiates from other interfaces.
	IsThrowStatementContext()
}

type ThrowStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyThrowStatementContext() *ThrowStatementContext {
	var p = new(ThrowStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_throwStatement
	return p
}

func (*ThrowStatementContext) IsThrowStatementContext() {}

func NewThrowStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ThrowStatementContext {
	var p = new(ThrowStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_throwStatement

	return p
}

func (s *ThrowStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *ThrowStatementContext) THROW() antlr.TerminalNode {
	return s.GetToken(Java8ParserTHROW, 0)
}

func (s *ThrowStatementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ThrowStatementContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *ThrowStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ThrowStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ThrowStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterThrowStatement(s)
	}
}

func (s *ThrowStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitThrowStatement(s)
	}
}

func (p *Java8Parser) ThrowStatement() (localctx IThrowStatementContext) {
	this := p
	_ = this

	localctx = NewThrowStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 326, Java8ParserRULE_throwStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1756)
		p.Match(Java8ParserTHROW)
	}
	{
		p.SetState(1757)
		p.Expression()
	}
	{
		p.SetState(1758)
		p.Match(Java8ParserSEMI)
	}

	return localctx
}

// ISynchronizedStatementContext is an interface to support dynamic dispatch.
type ISynchronizedStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSynchronizedStatementContext differentiates from other interfaces.
	IsSynchronizedStatementContext()
}

type SynchronizedStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySynchronizedStatementContext() *SynchronizedStatementContext {
	var p = new(SynchronizedStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_synchronizedStatement
	return p
}

func (*SynchronizedStatementContext) IsSynchronizedStatementContext() {}

func NewSynchronizedStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SynchronizedStatementContext {
	var p = new(SynchronizedStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_synchronizedStatement

	return p
}

func (s *SynchronizedStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *SynchronizedStatementContext) SYNCHRONIZED() antlr.TerminalNode {
	return s.GetToken(Java8ParserSYNCHRONIZED, 0)
}

func (s *SynchronizedStatementContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *SynchronizedStatementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *SynchronizedStatementContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *SynchronizedStatementContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *SynchronizedStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SynchronizedStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SynchronizedStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterSynchronizedStatement(s)
	}
}

func (s *SynchronizedStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitSynchronizedStatement(s)
	}
}

func (p *Java8Parser) SynchronizedStatement() (localctx ISynchronizedStatementContext) {
	this := p
	_ = this

	localctx = NewSynchronizedStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 328, Java8ParserRULE_synchronizedStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1760)
		p.Match(Java8ParserSYNCHRONIZED)
	}
	{
		p.SetState(1761)
		p.Match(Java8ParserLPAREN)
	}
	{
		p.SetState(1762)
		p.Expression()
	}
	{
		p.SetState(1763)
		p.Match(Java8ParserRPAREN)
	}
	{
		p.SetState(1764)
		p.Block()
	}

	return localctx
}

// ITryStatementContext is an interface to support dynamic dispatch.
type ITryStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTryStatementContext differentiates from other interfaces.
	IsTryStatementContext()
}

type TryStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTryStatementContext() *TryStatementContext {
	var p = new(TryStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_tryStatement
	return p
}

func (*TryStatementContext) IsTryStatementContext() {}

func NewTryStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TryStatementContext {
	var p = new(TryStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_tryStatement

	return p
}

func (s *TryStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *TryStatementContext) TRY() antlr.TerminalNode {
	return s.GetToken(Java8ParserTRY, 0)
}

func (s *TryStatementContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *TryStatementContext) Catches() ICatchesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICatchesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICatchesContext)
}

func (s *TryStatementContext) Finally_() IFinally_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFinally_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFinally_Context)
}

func (s *TryStatementContext) TryWithResourcesStatement() ITryWithResourcesStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITryWithResourcesStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITryWithResourcesStatementContext)
}

func (s *TryStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TryStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TryStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTryStatement(s)
	}
}

func (s *TryStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTryStatement(s)
	}
}

func (p *Java8Parser) TryStatement() (localctx ITryStatementContext) {
	this := p
	_ = this

	localctx = NewTryStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 330, Java8ParserRULE_tryStatement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1778)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 180, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1766)
			p.Match(Java8ParserTRY)
		}
		{
			p.SetState(1767)
			p.Block()
		}
		{
			p.SetState(1768)
			p.Catches()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1770)
			p.Match(Java8ParserTRY)
		}
		{
			p.SetState(1771)
			p.Block()
		}
		p.SetState(1773)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserCATCH {
			{
				p.SetState(1772)
				p.Catches()
			}

		}
		{
			p.SetState(1775)
			p.Finally_()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1777)
			p.TryWithResourcesStatement()
		}

	}

	return localctx
}

// ICatchesContext is an interface to support dynamic dispatch.
type ICatchesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCatchesContext differentiates from other interfaces.
	IsCatchesContext()
}

type CatchesContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCatchesContext() *CatchesContext {
	var p = new(CatchesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_catches
	return p
}

func (*CatchesContext) IsCatchesContext() {}

func NewCatchesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CatchesContext {
	var p = new(CatchesContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_catches

	return p
}

func (s *CatchesContext) GetParser() antlr.Parser { return s.parser }

func (s *CatchesContext) AllCatchClause() []ICatchClauseContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICatchClauseContext)(nil)).Elem())
	var tst = make([]ICatchClauseContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ICatchClauseContext)
		}
	}

	return tst
}

func (s *CatchesContext) CatchClause(i int) ICatchClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICatchClauseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICatchClauseContext)
}

func (s *CatchesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CatchesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CatchesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterCatches(s)
	}
}

func (s *CatchesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitCatches(s)
	}
}

func (p *Java8Parser) Catches() (localctx ICatchesContext) {
	this := p
	_ = this

	localctx = NewCatchesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 332, Java8ParserRULE_catches)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1780)
		p.CatchClause()
	}
	p.SetState(1784)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserCATCH {
		{
			p.SetState(1781)
			p.CatchClause()
		}

		p.SetState(1786)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// ICatchClauseContext is an interface to support dynamic dispatch.
type ICatchClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCatchClauseContext differentiates from other interfaces.
	IsCatchClauseContext()
}

type CatchClauseContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCatchClauseContext() *CatchClauseContext {
	var p = new(CatchClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_catchClause
	return p
}

func (*CatchClauseContext) IsCatchClauseContext() {}

func NewCatchClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CatchClauseContext {
	var p = new(CatchClauseContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_catchClause

	return p
}

func (s *CatchClauseContext) GetParser() antlr.Parser { return s.parser }

func (s *CatchClauseContext) CATCH() antlr.TerminalNode {
	return s.GetToken(Java8ParserCATCH, 0)
}

func (s *CatchClauseContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *CatchClauseContext) CatchFormalParameter() ICatchFormalParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICatchFormalParameterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICatchFormalParameterContext)
}

func (s *CatchClauseContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *CatchClauseContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *CatchClauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CatchClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CatchClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterCatchClause(s)
	}
}

func (s *CatchClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitCatchClause(s)
	}
}

func (p *Java8Parser) CatchClause() (localctx ICatchClauseContext) {
	this := p
	_ = this

	localctx = NewCatchClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 334, Java8ParserRULE_catchClause)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1787)
		p.Match(Java8ParserCATCH)
	}
	{
		p.SetState(1788)
		p.Match(Java8ParserLPAREN)
	}
	{
		p.SetState(1789)
		p.CatchFormalParameter()
	}
	{
		p.SetState(1790)
		p.Match(Java8ParserRPAREN)
	}
	{
		p.SetState(1791)
		p.Block()
	}

	return localctx
}

// ICatchFormalParameterContext is an interface to support dynamic dispatch.
type ICatchFormalParameterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCatchFormalParameterContext differentiates from other interfaces.
	IsCatchFormalParameterContext()
}

type CatchFormalParameterContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCatchFormalParameterContext() *CatchFormalParameterContext {
	var p = new(CatchFormalParameterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_catchFormalParameter
	return p
}

func (*CatchFormalParameterContext) IsCatchFormalParameterContext() {}

func NewCatchFormalParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CatchFormalParameterContext {
	var p = new(CatchFormalParameterContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_catchFormalParameter

	return p
}

func (s *CatchFormalParameterContext) GetParser() antlr.Parser { return s.parser }

func (s *CatchFormalParameterContext) CatchType() ICatchTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICatchTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICatchTypeContext)
}

func (s *CatchFormalParameterContext) VariableDeclaratorId() IVariableDeclaratorIdContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorIdContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorIdContext)
}

func (s *CatchFormalParameterContext) AllVariableModifier() []IVariableModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem())
	var tst = make([]IVariableModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IVariableModifierContext)
		}
	}

	return tst
}

func (s *CatchFormalParameterContext) VariableModifier(i int) IVariableModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableModifierContext)
}

func (s *CatchFormalParameterContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CatchFormalParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CatchFormalParameterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterCatchFormalParameter(s)
	}
}

func (s *CatchFormalParameterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitCatchFormalParameter(s)
	}
}

func (p *Java8Parser) CatchFormalParameter() (localctx ICatchFormalParameterContext) {
	this := p
	_ = this

	localctx = NewCatchFormalParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 336, Java8ParserRULE_catchFormalParameter)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1796)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserFINAL || _la == Java8ParserAT {
		{
			p.SetState(1793)
			p.VariableModifier()
		}

		p.SetState(1798)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1799)
		p.CatchType()
	}
	{
		p.SetState(1800)
		p.VariableDeclaratorId()
	}

	return localctx
}

// ICatchTypeContext is an interface to support dynamic dispatch.
type ICatchTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCatchTypeContext differentiates from other interfaces.
	IsCatchTypeContext()
}

type CatchTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCatchTypeContext() *CatchTypeContext {
	var p = new(CatchTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_catchType
	return p
}

func (*CatchTypeContext) IsCatchTypeContext() {}

func NewCatchTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CatchTypeContext {
	var p = new(CatchTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_catchType

	return p
}

func (s *CatchTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *CatchTypeContext) UnannClassType() IUnannClassTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannClassTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannClassTypeContext)
}

func (s *CatchTypeContext) AllBITOR() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserBITOR)
}

func (s *CatchTypeContext) BITOR(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserBITOR, i)
}

func (s *CatchTypeContext) AllClassType() []IClassTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IClassTypeContext)(nil)).Elem())
	var tst = make([]IClassTypeContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IClassTypeContext)
		}
	}

	return tst
}

func (s *CatchTypeContext) ClassType(i int) IClassTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IClassTypeContext)
}

func (s *CatchTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CatchTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CatchTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterCatchType(s)
	}
}

func (s *CatchTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitCatchType(s)
	}
}

func (p *Java8Parser) CatchType() (localctx ICatchTypeContext) {
	this := p
	_ = this

	localctx = NewCatchTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 338, Java8ParserRULE_catchType)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1802)
		p.UnannClassType()
	}
	p.SetState(1807)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserBITOR {
		{
			p.SetState(1803)
			p.Match(Java8ParserBITOR)
		}
		{
			p.SetState(1804)
			p.ClassType()
		}

		p.SetState(1809)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IFinally_Context is an interface to support dynamic dispatch.
type IFinally_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFinally_Context differentiates from other interfaces.
	IsFinally_Context()
}

type Finally_Context struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFinally_Context() *Finally_Context {
	var p = new(Finally_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_finally_
	return p
}

func (*Finally_Context) IsFinally_Context() {}

func NewFinally_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Finally_Context {
	var p = new(Finally_Context)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_finally_

	return p
}

func (s *Finally_Context) GetParser() antlr.Parser { return s.parser }

func (s *Finally_Context) FINALLY() antlr.TerminalNode {
	return s.GetToken(Java8ParserFINALLY, 0)
}

func (s *Finally_Context) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *Finally_Context) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Finally_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Finally_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterFinally_(s)
	}
}

func (s *Finally_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitFinally_(s)
	}
}

func (p *Java8Parser) Finally_() (localctx IFinally_Context) {
	this := p
	_ = this

	localctx = NewFinally_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 340, Java8ParserRULE_finally_)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1810)
		p.Match(Java8ParserFINALLY)
	}
	{
		p.SetState(1811)
		p.Block()
	}

	return localctx
}

// ITryWithResourcesStatementContext is an interface to support dynamic dispatch.
type ITryWithResourcesStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTryWithResourcesStatementContext differentiates from other interfaces.
	IsTryWithResourcesStatementContext()
}

type TryWithResourcesStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTryWithResourcesStatementContext() *TryWithResourcesStatementContext {
	var p = new(TryWithResourcesStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_tryWithResourcesStatement
	return p
}

func (*TryWithResourcesStatementContext) IsTryWithResourcesStatementContext() {}

func NewTryWithResourcesStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TryWithResourcesStatementContext {
	var p = new(TryWithResourcesStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_tryWithResourcesStatement

	return p
}

func (s *TryWithResourcesStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *TryWithResourcesStatementContext) TRY() antlr.TerminalNode {
	return s.GetToken(Java8ParserTRY, 0)
}

func (s *TryWithResourcesStatementContext) ResourceSpecification() IResourceSpecificationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResourceSpecificationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IResourceSpecificationContext)
}

func (s *TryWithResourcesStatementContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *TryWithResourcesStatementContext) Catches() ICatchesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICatchesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICatchesContext)
}

func (s *TryWithResourcesStatementContext) Finally_() IFinally_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFinally_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFinally_Context)
}

func (s *TryWithResourcesStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TryWithResourcesStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TryWithResourcesStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTryWithResourcesStatement(s)
	}
}

func (s *TryWithResourcesStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTryWithResourcesStatement(s)
	}
}

func (p *Java8Parser) TryWithResourcesStatement() (localctx ITryWithResourcesStatementContext) {
	this := p
	_ = this

	localctx = NewTryWithResourcesStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 342, Java8ParserRULE_tryWithResourcesStatement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1813)
		p.Match(Java8ParserTRY)
	}
	{
		p.SetState(1814)
		p.ResourceSpecification()
	}
	{
		p.SetState(1815)
		p.Block()
	}
	p.SetState(1817)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserCATCH {
		{
			p.SetState(1816)
			p.Catches()
		}

	}
	p.SetState(1820)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserFINALLY {
		{
			p.SetState(1819)
			p.Finally_()
		}

	}

	return localctx
}

// IResourceSpecificationContext is an interface to support dynamic dispatch.
type IResourceSpecificationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsResourceSpecificationContext differentiates from other interfaces.
	IsResourceSpecificationContext()
}

type ResourceSpecificationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyResourceSpecificationContext() *ResourceSpecificationContext {
	var p = new(ResourceSpecificationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_resourceSpecification
	return p
}

func (*ResourceSpecificationContext) IsResourceSpecificationContext() {}

func NewResourceSpecificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResourceSpecificationContext {
	var p = new(ResourceSpecificationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_resourceSpecification

	return p
}

func (s *ResourceSpecificationContext) GetParser() antlr.Parser { return s.parser }

func (s *ResourceSpecificationContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *ResourceSpecificationContext) ResourceList() IResourceListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResourceListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IResourceListContext)
}

func (s *ResourceSpecificationContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *ResourceSpecificationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, 0)
}

func (s *ResourceSpecificationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ResourceSpecificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ResourceSpecificationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterResourceSpecification(s)
	}
}

func (s *ResourceSpecificationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitResourceSpecification(s)
	}
}

func (p *Java8Parser) ResourceSpecification() (localctx IResourceSpecificationContext) {
	this := p
	_ = this

	localctx = NewResourceSpecificationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 344, Java8ParserRULE_resourceSpecification)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1822)
		p.Match(Java8ParserLPAREN)
	}
	{
		p.SetState(1823)
		p.ResourceList()
	}
	p.SetState(1825)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserSEMI {
		{
			p.SetState(1824)
			p.Match(Java8ParserSEMI)
		}

	}
	{
		p.SetState(1827)
		p.Match(Java8ParserRPAREN)
	}

	return localctx
}

// IResourceListContext is an interface to support dynamic dispatch.
type IResourceListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsResourceListContext differentiates from other interfaces.
	IsResourceListContext()
}

type ResourceListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyResourceListContext() *ResourceListContext {
	var p = new(ResourceListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_resourceList
	return p
}

func (*ResourceListContext) IsResourceListContext() {}

func NewResourceListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResourceListContext {
	var p = new(ResourceListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_resourceList

	return p
}

func (s *ResourceListContext) GetParser() antlr.Parser { return s.parser }

func (s *ResourceListContext) AllResource() []IResourceContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IResourceContext)(nil)).Elem())
	var tst = make([]IResourceContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IResourceContext)
		}
	}

	return tst
}

func (s *ResourceListContext) Resource(i int) IResourceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResourceContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IResourceContext)
}

func (s *ResourceListContext) AllSEMI() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserSEMI)
}

func (s *ResourceListContext) SEMI(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserSEMI, i)
}

func (s *ResourceListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ResourceListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ResourceListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterResourceList(s)
	}
}

func (s *ResourceListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitResourceList(s)
	}
}

func (p *Java8Parser) ResourceList() (localctx IResourceListContext) {
	this := p
	_ = this

	localctx = NewResourceListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 346, Java8ParserRULE_resourceList)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1829)
		p.Resource()
	}
	p.SetState(1834)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 187, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1830)
				p.Match(Java8ParserSEMI)
			}
			{
				p.SetState(1831)
				p.Resource()
			}

		}
		p.SetState(1836)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 187, p.GetParserRuleContext())
	}

	return localctx
}

// IResourceContext is an interface to support dynamic dispatch.
type IResourceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsResourceContext differentiates from other interfaces.
	IsResourceContext()
}

type ResourceContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyResourceContext() *ResourceContext {
	var p = new(ResourceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_resource
	return p
}

func (*ResourceContext) IsResourceContext() {}

func NewResourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResourceContext {
	var p = new(ResourceContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_resource

	return p
}

func (s *ResourceContext) GetParser() antlr.Parser { return s.parser }

func (s *ResourceContext) UnannType() IUnannTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannTypeContext)
}

func (s *ResourceContext) VariableDeclaratorId() IVariableDeclaratorIdContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorIdContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorIdContext)
}

func (s *ResourceContext) ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserASSIGN, 0)
}

func (s *ResourceContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ResourceContext) AllVariableModifier() []IVariableModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem())
	var tst = make([]IVariableModifierContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IVariableModifierContext)
		}
	}

	return tst
}

func (s *ResourceContext) VariableModifier(i int) IVariableModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableModifierContext)
}

func (s *ResourceContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ResourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ResourceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterResource(s)
	}
}

func (s *ResourceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitResource(s)
	}
}

func (p *Java8Parser) Resource() (localctx IResourceContext) {
	this := p
	_ = this

	localctx = NewResourceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 348, Java8ParserRULE_resource)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1840)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserFINAL || _la == Java8ParserAT {
		{
			p.SetState(1837)
			p.VariableModifier()
		}

		p.SetState(1842)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1843)
		p.UnannType()
	}
	{
		p.SetState(1844)
		p.VariableDeclaratorId()
	}
	{
		p.SetState(1845)
		p.Match(Java8ParserASSIGN)
	}
	{
		p.SetState(1846)
		p.Expression()
	}

	return localctx
}

// IPrimaryContext is an interface to support dynamic dispatch.
type IPrimaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimaryContext differentiates from other interfaces.
	IsPrimaryContext()
}

type PrimaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimaryContext() *PrimaryContext {
	var p = new(PrimaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_primary
	return p
}

func (*PrimaryContext) IsPrimaryContext() {}

func NewPrimaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryContext {
	var p = new(PrimaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_primary

	return p
}

func (s *PrimaryContext) GetParser() antlr.Parser { return s.parser }

func (s *PrimaryContext) PrimaryNoNewArray_lfno_primary() IPrimaryNoNewArray_lfno_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryNoNewArray_lfno_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryNoNewArray_lfno_primaryContext)
}

func (s *PrimaryContext) ArrayCreationExpression() IArrayCreationExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayCreationExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayCreationExpressionContext)
}

func (s *PrimaryContext) AllPrimaryNoNewArray_lf_primary() []IPrimaryNoNewArray_lf_primaryContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IPrimaryNoNewArray_lf_primaryContext)(nil)).Elem())
	var tst = make([]IPrimaryNoNewArray_lf_primaryContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IPrimaryNoNewArray_lf_primaryContext)
		}
	}

	return tst
}

func (s *PrimaryContext) PrimaryNoNewArray_lf_primary(i int) IPrimaryNoNewArray_lf_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryNoNewArray_lf_primaryContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IPrimaryNoNewArray_lf_primaryContext)
}

func (s *PrimaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPrimary(s)
	}
}

func (s *PrimaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPrimary(s)
	}
}

func (p *Java8Parser) Primary() (localctx IPrimaryContext) {
	this := p
	_ = this

	localctx = NewPrimaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 350, Java8ParserRULE_primary)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1850)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 189, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1848)
			p.PrimaryNoNewArray_lfno_primary()
		}

	case 2:
		{
			p.SetState(1849)
			p.ArrayCreationExpression()
		}

	}
	p.SetState(1855)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 190, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1852)
				p.PrimaryNoNewArray_lf_primary()
			}

		}
		p.SetState(1857)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 190, p.GetParserRuleContext())
	}

	return localctx
}

// IPrimaryNoNewArrayContext is an interface to support dynamic dispatch.
type IPrimaryNoNewArrayContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimaryNoNewArrayContext differentiates from other interfaces.
	IsPrimaryNoNewArrayContext()
}

type PrimaryNoNewArrayContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimaryNoNewArrayContext() *PrimaryNoNewArrayContext {
	var p = new(PrimaryNoNewArrayContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray
	return p
}

func (*PrimaryNoNewArrayContext) IsPrimaryNoNewArrayContext() {}

func NewPrimaryNoNewArrayContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryNoNewArrayContext {
	var p = new(PrimaryNoNewArrayContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray

	return p
}

func (s *PrimaryNoNewArrayContext) GetParser() antlr.Parser { return s.parser }

func (s *PrimaryNoNewArrayContext) Literal() ILiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *PrimaryNoNewArrayContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *PrimaryNoNewArrayContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *PrimaryNoNewArrayContext) CLASS() antlr.TerminalNode {
	return s.GetToken(Java8ParserCLASS, 0)
}

func (s *PrimaryNoNewArrayContext) AllLBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserLBRACK)
}

func (s *PrimaryNoNewArrayContext) LBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACK, i)
}

func (s *PrimaryNoNewArrayContext) AllRBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserRBRACK)
}

func (s *PrimaryNoNewArrayContext) RBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACK, i)
}

func (s *PrimaryNoNewArrayContext) VOID() antlr.TerminalNode {
	return s.GetToken(Java8ParserVOID, 0)
}

func (s *PrimaryNoNewArrayContext) THIS() antlr.TerminalNode {
	return s.GetToken(Java8ParserTHIS, 0)
}

func (s *PrimaryNoNewArrayContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *PrimaryNoNewArrayContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *PrimaryNoNewArrayContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *PrimaryNoNewArrayContext) ClassInstanceCreationExpression() IClassInstanceCreationExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassInstanceCreationExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassInstanceCreationExpressionContext)
}

func (s *PrimaryNoNewArrayContext) FieldAccess() IFieldAccessContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFieldAccessContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFieldAccessContext)
}

func (s *PrimaryNoNewArrayContext) ArrayAccess() IArrayAccessContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayAccessContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayAccessContext)
}

func (s *PrimaryNoNewArrayContext) MethodInvocation() IMethodInvocationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodInvocationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodInvocationContext)
}

func (s *PrimaryNoNewArrayContext) MethodReference() IMethodReferenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodReferenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodReferenceContext)
}

func (s *PrimaryNoNewArrayContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimaryNoNewArrayContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimaryNoNewArrayContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPrimaryNoNewArray(s)
	}
}

func (s *PrimaryNoNewArrayContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPrimaryNoNewArray(s)
	}
}

func (p *Java8Parser) PrimaryNoNewArray() (localctx IPrimaryNoNewArrayContext) {
	this := p
	_ = this

	localctx = NewPrimaryNoNewArrayContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 352, Java8ParserRULE_primaryNoNewArray)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1887)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 192, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1858)
			p.Literal()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1859)
			p.TypeName()
		}
		p.SetState(1864)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserLBRACK {
			{
				p.SetState(1860)
				p.Match(Java8ParserLBRACK)
			}
			{
				p.SetState(1861)
				p.Match(Java8ParserRBRACK)
			}

			p.SetState(1866)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1867)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(1868)
			p.Match(Java8ParserCLASS)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1870)
			p.Match(Java8ParserVOID)
		}
		{
			p.SetState(1871)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(1872)
			p.Match(Java8ParserCLASS)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1873)
			p.Match(Java8ParserTHIS)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1874)
			p.TypeName()
		}
		{
			p.SetState(1875)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(1876)
			p.Match(Java8ParserTHIS)
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1878)
			p.Match(Java8ParserLPAREN)
		}
		{
			p.SetState(1879)
			p.Expression()
		}
		{
			p.SetState(1880)
			p.Match(Java8ParserRPAREN)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1882)
			p.ClassInstanceCreationExpression()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(1883)
			p.FieldAccess()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(1884)
			p.ArrayAccess()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(1885)
			p.MethodInvocation()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(1886)
			p.MethodReference()
		}

	}

	return localctx
}

// IPrimaryNoNewArray_lf_arrayAccessContext is an interface to support dynamic dispatch.
type IPrimaryNoNewArray_lf_arrayAccessContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimaryNoNewArray_lf_arrayAccessContext differentiates from other interfaces.
	IsPrimaryNoNewArray_lf_arrayAccessContext()
}

type PrimaryNoNewArray_lf_arrayAccessContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimaryNoNewArray_lf_arrayAccessContext() *PrimaryNoNewArray_lf_arrayAccessContext {
	var p = new(PrimaryNoNewArray_lf_arrayAccessContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lf_arrayAccess
	return p
}

func (*PrimaryNoNewArray_lf_arrayAccessContext) IsPrimaryNoNewArray_lf_arrayAccessContext() {}

func NewPrimaryNoNewArray_lf_arrayAccessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryNoNewArray_lf_arrayAccessContext {
	var p = new(PrimaryNoNewArray_lf_arrayAccessContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lf_arrayAccess

	return p
}

func (s *PrimaryNoNewArray_lf_arrayAccessContext) GetParser() antlr.Parser { return s.parser }
func (s *PrimaryNoNewArray_lf_arrayAccessContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimaryNoNewArray_lf_arrayAccessContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimaryNoNewArray_lf_arrayAccessContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPrimaryNoNewArray_lf_arrayAccess(s)
	}
}

func (s *PrimaryNoNewArray_lf_arrayAccessContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPrimaryNoNewArray_lf_arrayAccess(s)
	}
}

func (p *Java8Parser) PrimaryNoNewArray_lf_arrayAccess() (localctx IPrimaryNoNewArray_lf_arrayAccessContext) {
	this := p
	_ = this

	localctx = NewPrimaryNoNewArray_lf_arrayAccessContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 354, Java8ParserRULE_primaryNoNewArray_lf_arrayAccess)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)

	return localctx
}

// IPrimaryNoNewArray_lfno_arrayAccessContext is an interface to support dynamic dispatch.
type IPrimaryNoNewArray_lfno_arrayAccessContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimaryNoNewArray_lfno_arrayAccessContext differentiates from other interfaces.
	IsPrimaryNoNewArray_lfno_arrayAccessContext()
}

type PrimaryNoNewArray_lfno_arrayAccessContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimaryNoNewArray_lfno_arrayAccessContext() *PrimaryNoNewArray_lfno_arrayAccessContext {
	var p = new(PrimaryNoNewArray_lfno_arrayAccessContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lfno_arrayAccess
	return p
}

func (*PrimaryNoNewArray_lfno_arrayAccessContext) IsPrimaryNoNewArray_lfno_arrayAccessContext() {}

func NewPrimaryNoNewArray_lfno_arrayAccessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryNoNewArray_lfno_arrayAccessContext {
	var p = new(PrimaryNoNewArray_lfno_arrayAccessContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lfno_arrayAccess

	return p
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) GetParser() antlr.Parser { return s.parser }

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) Literal() ILiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) CLASS() antlr.TerminalNode {
	return s.GetToken(Java8ParserCLASS, 0)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) AllLBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserLBRACK)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) LBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACK, i)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) AllRBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserRBRACK)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) RBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACK, i)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) VOID() antlr.TerminalNode {
	return s.GetToken(Java8ParserVOID, 0)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) THIS() antlr.TerminalNode {
	return s.GetToken(Java8ParserTHIS, 0)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) ClassInstanceCreationExpression() IClassInstanceCreationExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassInstanceCreationExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassInstanceCreationExpressionContext)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) FieldAccess() IFieldAccessContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFieldAccessContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFieldAccessContext)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) MethodInvocation() IMethodInvocationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodInvocationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodInvocationContext)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) MethodReference() IMethodReferenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodReferenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodReferenceContext)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPrimaryNoNewArray_lfno_arrayAccess(s)
	}
}

func (s *PrimaryNoNewArray_lfno_arrayAccessContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPrimaryNoNewArray_lfno_arrayAccess(s)
	}
}

func (p *Java8Parser) PrimaryNoNewArray_lfno_arrayAccess() (localctx IPrimaryNoNewArray_lfno_arrayAccessContext) {
	this := p
	_ = this

	localctx = NewPrimaryNoNewArray_lfno_arrayAccessContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 356, Java8ParserRULE_primaryNoNewArray_lfno_arrayAccess)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1919)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 194, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1891)
			p.Literal()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1892)
			p.TypeName()
		}
		p.SetState(1897)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserLBRACK {
			{
				p.SetState(1893)
				p.Match(Java8ParserLBRACK)
			}
			{
				p.SetState(1894)
				p.Match(Java8ParserRBRACK)
			}

			p.SetState(1899)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1900)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(1901)
			p.Match(Java8ParserCLASS)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1903)
			p.Match(Java8ParserVOID)
		}
		{
			p.SetState(1904)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(1905)
			p.Match(Java8ParserCLASS)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1906)
			p.Match(Java8ParserTHIS)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1907)
			p.TypeName()
		}
		{
			p.SetState(1908)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(1909)
			p.Match(Java8ParserTHIS)
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1911)
			p.Match(Java8ParserLPAREN)
		}
		{
			p.SetState(1912)
			p.Expression()
		}
		{
			p.SetState(1913)
			p.Match(Java8ParserRPAREN)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1915)
			p.ClassInstanceCreationExpression()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(1916)
			p.FieldAccess()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(1917)
			p.MethodInvocation()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(1918)
			p.MethodReference()
		}

	}

	return localctx
}

// IPrimaryNoNewArray_lf_primaryContext is an interface to support dynamic dispatch.
type IPrimaryNoNewArray_lf_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimaryNoNewArray_lf_primaryContext differentiates from other interfaces.
	IsPrimaryNoNewArray_lf_primaryContext()
}

type PrimaryNoNewArray_lf_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimaryNoNewArray_lf_primaryContext() *PrimaryNoNewArray_lf_primaryContext {
	var p = new(PrimaryNoNewArray_lf_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lf_primary
	return p
}

func (*PrimaryNoNewArray_lf_primaryContext) IsPrimaryNoNewArray_lf_primaryContext() {}

func NewPrimaryNoNewArray_lf_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryNoNewArray_lf_primaryContext {
	var p = new(PrimaryNoNewArray_lf_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lf_primary

	return p
}

func (s *PrimaryNoNewArray_lf_primaryContext) GetParser() antlr.Parser { return s.parser }

func (s *PrimaryNoNewArray_lf_primaryContext) ClassInstanceCreationExpression_lf_primary() IClassInstanceCreationExpression_lf_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassInstanceCreationExpression_lf_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassInstanceCreationExpression_lf_primaryContext)
}

func (s *PrimaryNoNewArray_lf_primaryContext) FieldAccess_lf_primary() IFieldAccess_lf_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFieldAccess_lf_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFieldAccess_lf_primaryContext)
}

func (s *PrimaryNoNewArray_lf_primaryContext) ArrayAccess_lf_primary() IArrayAccess_lf_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayAccess_lf_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayAccess_lf_primaryContext)
}

func (s *PrimaryNoNewArray_lf_primaryContext) MethodInvocation_lf_primary() IMethodInvocation_lf_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodInvocation_lf_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodInvocation_lf_primaryContext)
}

func (s *PrimaryNoNewArray_lf_primaryContext) MethodReference_lf_primary() IMethodReference_lf_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodReference_lf_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodReference_lf_primaryContext)
}

func (s *PrimaryNoNewArray_lf_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimaryNoNewArray_lf_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimaryNoNewArray_lf_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPrimaryNoNewArray_lf_primary(s)
	}
}

func (s *PrimaryNoNewArray_lf_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPrimaryNoNewArray_lf_primary(s)
	}
}

func (p *Java8Parser) PrimaryNoNewArray_lf_primary() (localctx IPrimaryNoNewArray_lf_primaryContext) {
	this := p
	_ = this

	localctx = NewPrimaryNoNewArray_lf_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 358, Java8ParserRULE_primaryNoNewArray_lf_primary)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1926)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 195, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1921)
			p.ClassInstanceCreationExpression_lf_primary()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1922)
			p.FieldAccess_lf_primary()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1923)
			p.ArrayAccess_lf_primary()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1924)
			p.MethodInvocation_lf_primary()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1925)
			p.MethodReference_lf_primary()
		}

	}

	return localctx
}

// IPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext is an interface to support dynamic dispatch.
type IPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext differentiates from other interfaces.
	IsPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext()
}

type PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext() *PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext {
	var p = new(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary
	return p
}

func (*PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext) IsPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext() {
}

func NewPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext {
	var p = new(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary

	return p
}

func (s *PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext) GetParser() antlr.Parser {
	return s.parser
}
func (s *PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(s)
	}
}

func (s *PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(s)
	}
}

func (p *Java8Parser) PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() (localctx IPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext) {
	this := p
	_ = this

	localctx = NewPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 360, Java8ParserRULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)

	return localctx
}

// IPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext is an interface to support dynamic dispatch.
type IPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext differentiates from other interfaces.
	IsPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext()
}

type PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext() *PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext {
	var p = new(PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary
	return p
}

func (*PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext) IsPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext() {
}

func NewPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext {
	var p = new(PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary

	return p
}

func (s *PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext) GetParser() antlr.Parser {
	return s.parser
}

func (s *PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext) ClassInstanceCreationExpression_lf_primary() IClassInstanceCreationExpression_lf_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassInstanceCreationExpression_lf_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassInstanceCreationExpression_lf_primaryContext)
}

func (s *PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext) FieldAccess_lf_primary() IFieldAccess_lf_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFieldAccess_lf_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFieldAccess_lf_primaryContext)
}

func (s *PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext) MethodInvocation_lf_primary() IMethodInvocation_lf_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodInvocation_lf_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodInvocation_lf_primaryContext)
}

func (s *PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext) MethodReference_lf_primary() IMethodReference_lf_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodReference_lf_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodReference_lf_primaryContext)
}

func (s *PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(s)
	}
}

func (s *PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(s)
	}
}

func (p *Java8Parser) PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() (localctx IPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext) {
	this := p
	_ = this

	localctx = NewPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 362, Java8ParserRULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1934)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 196, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1930)
			p.ClassInstanceCreationExpression_lf_primary()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1931)
			p.FieldAccess_lf_primary()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1932)
			p.MethodInvocation_lf_primary()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1933)
			p.MethodReference_lf_primary()
		}

	}

	return localctx
}

// IPrimaryNoNewArray_lfno_primaryContext is an interface to support dynamic dispatch.
type IPrimaryNoNewArray_lfno_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimaryNoNewArray_lfno_primaryContext differentiates from other interfaces.
	IsPrimaryNoNewArray_lfno_primaryContext()
}

type PrimaryNoNewArray_lfno_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimaryNoNewArray_lfno_primaryContext() *PrimaryNoNewArray_lfno_primaryContext {
	var p = new(PrimaryNoNewArray_lfno_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lfno_primary
	return p
}

func (*PrimaryNoNewArray_lfno_primaryContext) IsPrimaryNoNewArray_lfno_primaryContext() {}

func NewPrimaryNoNewArray_lfno_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryNoNewArray_lfno_primaryContext {
	var p = new(PrimaryNoNewArray_lfno_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lfno_primary

	return p
}

func (s *PrimaryNoNewArray_lfno_primaryContext) GetParser() antlr.Parser { return s.parser }

func (s *PrimaryNoNewArray_lfno_primaryContext) Literal() ILiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) CLASS() antlr.TerminalNode {
	return s.GetToken(Java8ParserCLASS, 0)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) AllLBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserLBRACK)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) LBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACK, i)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) AllRBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserRBRACK)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) RBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACK, i)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) UnannPrimitiveType() IUnannPrimitiveTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannPrimitiveTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannPrimitiveTypeContext)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) VOID() antlr.TerminalNode {
	return s.GetToken(Java8ParserVOID, 0)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) THIS() antlr.TerminalNode {
	return s.GetToken(Java8ParserTHIS, 0)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) ClassInstanceCreationExpression_lfno_primary() IClassInstanceCreationExpression_lfno_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassInstanceCreationExpression_lfno_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassInstanceCreationExpression_lfno_primaryContext)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) FieldAccess_lfno_primary() IFieldAccess_lfno_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFieldAccess_lfno_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFieldAccess_lfno_primaryContext)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) ArrayAccess_lfno_primary() IArrayAccess_lfno_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayAccess_lfno_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayAccess_lfno_primaryContext)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) MethodInvocation_lfno_primary() IMethodInvocation_lfno_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodInvocation_lfno_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodInvocation_lfno_primaryContext)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) MethodReference_lfno_primary() IMethodReference_lfno_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodReference_lfno_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodReference_lfno_primaryContext)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimaryNoNewArray_lfno_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimaryNoNewArray_lfno_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPrimaryNoNewArray_lfno_primary(s)
	}
}

func (s *PrimaryNoNewArray_lfno_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPrimaryNoNewArray_lfno_primary(s)
	}
}

func (p *Java8Parser) PrimaryNoNewArray_lfno_primary() (localctx IPrimaryNoNewArray_lfno_primaryContext) {
	this := p
	_ = this

	localctx = NewPrimaryNoNewArray_lfno_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 364, Java8ParserRULE_primaryNoNewArray_lfno_primary)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1976)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 199, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1936)
			p.Literal()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1937)
			p.TypeName()
		}
		p.SetState(1942)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserLBRACK {
			{
				p.SetState(1938)
				p.Match(Java8ParserLBRACK)
			}
			{
				p.SetState(1939)
				p.Match(Java8ParserRBRACK)
			}

			p.SetState(1944)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1945)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(1946)
			p.Match(Java8ParserCLASS)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1948)
			p.UnannPrimitiveType()
		}
		p.SetState(1953)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserLBRACK {
			{
				p.SetState(1949)
				p.Match(Java8ParserLBRACK)
			}
			{
				p.SetState(1950)
				p.Match(Java8ParserRBRACK)
			}

			p.SetState(1955)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1956)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(1957)
			p.Match(Java8ParserCLASS)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1959)
			p.Match(Java8ParserVOID)
		}
		{
			p.SetState(1960)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(1961)
			p.Match(Java8ParserCLASS)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1962)
			p.Match(Java8ParserTHIS)
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1963)
			p.TypeName()
		}
		{
			p.SetState(1964)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(1965)
			p.Match(Java8ParserTHIS)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1967)
			p.Match(Java8ParserLPAREN)
		}
		{
			p.SetState(1968)
			p.Expression()
		}
		{
			p.SetState(1969)
			p.Match(Java8ParserRPAREN)
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(1971)
			p.ClassInstanceCreationExpression_lfno_primary()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(1972)
			p.FieldAccess_lfno_primary()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(1973)
			p.ArrayAccess_lfno_primary()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(1974)
			p.MethodInvocation_lfno_primary()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(1975)
			p.MethodReference_lfno_primary()
		}

	}

	return localctx
}

// IPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext is an interface to support dynamic dispatch.
type IPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext differentiates from other interfaces.
	IsPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext()
}

type PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext() *PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext {
	var p = new(PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary
	return p
}

func (*PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext) IsPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext() {
}

func NewPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext {
	var p = new(PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary

	return p
}

func (s *PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext) GetParser() antlr.Parser {
	return s.parser
}
func (s *PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(s)
	}
}

func (s *PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(s)
	}
}

func (p *Java8Parser) PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() (localctx IPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext) {
	this := p
	_ = this

	localctx = NewPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 366, Java8ParserRULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)

	return localctx
}

// IPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext is an interface to support dynamic dispatch.
type IPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext differentiates from other interfaces.
	IsPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext()
}

type PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext() *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext {
	var p = new(PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary
	return p
}

func (*PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) IsPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext() {
}

func NewPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext {
	var p = new(PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary

	return p
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) GetParser() antlr.Parser {
	return s.parser
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) Literal() ILiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) CLASS() antlr.TerminalNode {
	return s.GetToken(Java8ParserCLASS, 0)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) AllLBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserLBRACK)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) LBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACK, i)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) AllRBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserRBRACK)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) RBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACK, i)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) UnannPrimitiveType() IUnannPrimitiveTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnannPrimitiveTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnannPrimitiveTypeContext)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) VOID() antlr.TerminalNode {
	return s.GetToken(Java8ParserVOID, 0)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) THIS() antlr.TerminalNode {
	return s.GetToken(Java8ParserTHIS, 0)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) ClassInstanceCreationExpression_lfno_primary() IClassInstanceCreationExpression_lfno_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassInstanceCreationExpression_lfno_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassInstanceCreationExpression_lfno_primaryContext)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) FieldAccess_lfno_primary() IFieldAccess_lfno_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFieldAccess_lfno_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFieldAccess_lfno_primaryContext)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) MethodInvocation_lfno_primary() IMethodInvocation_lfno_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodInvocation_lfno_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodInvocation_lfno_primaryContext)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) MethodReference_lfno_primary() IMethodReference_lfno_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodReference_lfno_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodReference_lfno_primaryContext)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(s)
	}
}

func (s *PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(s)
	}
}

func (p *Java8Parser) PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() (localctx IPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext) {
	this := p
	_ = this

	localctx = NewPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 368, Java8ParserRULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2019)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 202, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1980)
			p.Literal()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1981)
			p.TypeName()
		}
		p.SetState(1986)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserLBRACK {
			{
				p.SetState(1982)
				p.Match(Java8ParserLBRACK)
			}
			{
				p.SetState(1983)
				p.Match(Java8ParserRBRACK)
			}

			p.SetState(1988)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1989)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(1990)
			p.Match(Java8ParserCLASS)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1992)
			p.UnannPrimitiveType()
		}
		p.SetState(1997)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserLBRACK {
			{
				p.SetState(1993)
				p.Match(Java8ParserLBRACK)
			}
			{
				p.SetState(1994)
				p.Match(Java8ParserRBRACK)
			}

			p.SetState(1999)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(2000)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2001)
			p.Match(Java8ParserCLASS)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2003)
			p.Match(Java8ParserVOID)
		}
		{
			p.SetState(2004)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2005)
			p.Match(Java8ParserCLASS)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(2006)
			p.Match(Java8ParserTHIS)
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(2007)
			p.TypeName()
		}
		{
			p.SetState(2008)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2009)
			p.Match(Java8ParserTHIS)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(2011)
			p.Match(Java8ParserLPAREN)
		}
		{
			p.SetState(2012)
			p.Expression()
		}
		{
			p.SetState(2013)
			p.Match(Java8ParserRPAREN)
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(2015)
			p.ClassInstanceCreationExpression_lfno_primary()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(2016)
			p.FieldAccess_lfno_primary()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(2017)
			p.MethodInvocation_lfno_primary()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(2018)
			p.MethodReference_lfno_primary()
		}

	}

	return localctx
}

// IClassInstanceCreationExpressionContext is an interface to support dynamic dispatch.
type IClassInstanceCreationExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassInstanceCreationExpressionContext differentiates from other interfaces.
	IsClassInstanceCreationExpressionContext()
}

type ClassInstanceCreationExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassInstanceCreationExpressionContext() *ClassInstanceCreationExpressionContext {
	var p = new(ClassInstanceCreationExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_classInstanceCreationExpression
	return p
}

func (*ClassInstanceCreationExpressionContext) IsClassInstanceCreationExpressionContext() {}

func NewClassInstanceCreationExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassInstanceCreationExpressionContext {
	var p = new(ClassInstanceCreationExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_classInstanceCreationExpression

	return p
}

func (s *ClassInstanceCreationExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassInstanceCreationExpressionContext) NEW() antlr.TerminalNode {
	return s.GetToken(Java8ParserNEW, 0)
}

func (s *ClassInstanceCreationExpressionContext) AllIdentifier() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserIdentifier)
}

func (s *ClassInstanceCreationExpressionContext) Identifier(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, i)
}

func (s *ClassInstanceCreationExpressionContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *ClassInstanceCreationExpressionContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *ClassInstanceCreationExpressionContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *ClassInstanceCreationExpressionContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *ClassInstanceCreationExpressionContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *ClassInstanceCreationExpressionContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserDOT)
}

func (s *ClassInstanceCreationExpressionContext) DOT(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, i)
}

func (s *ClassInstanceCreationExpressionContext) TypeArgumentsOrDiamond() ITypeArgumentsOrDiamondContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsOrDiamondContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsOrDiamondContext)
}

func (s *ClassInstanceCreationExpressionContext) ArgumentList() IArgumentListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentListContext)
}

func (s *ClassInstanceCreationExpressionContext) ClassBody() IClassBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassBodyContext)
}

func (s *ClassInstanceCreationExpressionContext) ExpressionName() IExpressionNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionNameContext)
}

func (s *ClassInstanceCreationExpressionContext) Primary() IPrimaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryContext)
}

func (s *ClassInstanceCreationExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassInstanceCreationExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassInstanceCreationExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterClassInstanceCreationExpression(s)
	}
}

func (s *ClassInstanceCreationExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitClassInstanceCreationExpression(s)
	}
}

func (p *Java8Parser) ClassInstanceCreationExpression() (localctx IClassInstanceCreationExpressionContext) {
	this := p
	_ = this

	localctx = NewClassInstanceCreationExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 370, Java8ParserRULE_classInstanceCreationExpression)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2104)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 220, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2021)
			p.Match(Java8ParserNEW)
		}
		p.SetState(2023)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2022)
				p.TypeArguments()
			}

		}
		p.SetState(2028)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserAT {
			{
				p.SetState(2025)
				p.Annotation()
			}

			p.SetState(2030)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(2031)
			p.Match(Java8ParserIdentifier)
		}
		p.SetState(2042)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserDOT {
			{
				p.SetState(2032)
				p.Match(Java8ParserDOT)
			}
			p.SetState(2036)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == Java8ParserAT {
				{
					p.SetState(2033)
					p.Annotation()
				}

				p.SetState(2038)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(2039)
				p.Match(Java8ParserIdentifier)
			}

			p.SetState(2044)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		p.SetState(2046)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2045)
				p.TypeArgumentsOrDiamond()
			}

		}
		{
			p.SetState(2048)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2050)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2049)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2052)
			p.Match(Java8ParserRPAREN)
		}
		p.SetState(2054)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLBRACE {
			{
				p.SetState(2053)
				p.ClassBody()
			}

		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2056)
			p.ExpressionName()
		}
		{
			p.SetState(2057)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2058)
			p.Match(Java8ParserNEW)
		}
		p.SetState(2060)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2059)
				p.TypeArguments()
			}

		}
		p.SetState(2065)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserAT {
			{
				p.SetState(2062)
				p.Annotation()
			}

			p.SetState(2067)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(2068)
			p.Match(Java8ParserIdentifier)
		}
		p.SetState(2070)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2069)
				p.TypeArgumentsOrDiamond()
			}

		}
		{
			p.SetState(2072)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2074)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2073)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2076)
			p.Match(Java8ParserRPAREN)
		}
		p.SetState(2078)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLBRACE {
			{
				p.SetState(2077)
				p.ClassBody()
			}

		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2080)
			p.Primary()
		}
		{
			p.SetState(2081)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2082)
			p.Match(Java8ParserNEW)
		}
		p.SetState(2084)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2083)
				p.TypeArguments()
			}

		}
		p.SetState(2089)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserAT {
			{
				p.SetState(2086)
				p.Annotation()
			}

			p.SetState(2091)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(2092)
			p.Match(Java8ParserIdentifier)
		}
		p.SetState(2094)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2093)
				p.TypeArgumentsOrDiamond()
			}

		}
		{
			p.SetState(2096)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2098)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2097)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2100)
			p.Match(Java8ParserRPAREN)
		}
		p.SetState(2102)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLBRACE {
			{
				p.SetState(2101)
				p.ClassBody()
			}

		}

	}

	return localctx
}

// IClassInstanceCreationExpression_lf_primaryContext is an interface to support dynamic dispatch.
type IClassInstanceCreationExpression_lf_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassInstanceCreationExpression_lf_primaryContext differentiates from other interfaces.
	IsClassInstanceCreationExpression_lf_primaryContext()
}

type ClassInstanceCreationExpression_lf_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassInstanceCreationExpression_lf_primaryContext() *ClassInstanceCreationExpression_lf_primaryContext {
	var p = new(ClassInstanceCreationExpression_lf_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_classInstanceCreationExpression_lf_primary
	return p
}

func (*ClassInstanceCreationExpression_lf_primaryContext) IsClassInstanceCreationExpression_lf_primaryContext() {
}

func NewClassInstanceCreationExpression_lf_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassInstanceCreationExpression_lf_primaryContext {
	var p = new(ClassInstanceCreationExpression_lf_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_classInstanceCreationExpression_lf_primary

	return p
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassInstanceCreationExpression_lf_primaryContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) NEW() antlr.TerminalNode {
	return s.GetToken(Java8ParserNEW, 0)
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) TypeArgumentsOrDiamond() ITypeArgumentsOrDiamondContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsOrDiamondContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsOrDiamondContext)
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) ArgumentList() IArgumentListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentListContext)
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) ClassBody() IClassBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassBodyContext)
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterClassInstanceCreationExpression_lf_primary(s)
	}
}

func (s *ClassInstanceCreationExpression_lf_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitClassInstanceCreationExpression_lf_primary(s)
	}
}

func (p *Java8Parser) ClassInstanceCreationExpression_lf_primary() (localctx IClassInstanceCreationExpression_lf_primaryContext) {
	this := p
	_ = this

	localctx = NewClassInstanceCreationExpression_lf_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 372, Java8ParserRULE_classInstanceCreationExpression_lf_primary)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2106)
		p.Match(Java8ParserDOT)
	}
	{
		p.SetState(2107)
		p.Match(Java8ParserNEW)
	}
	p.SetState(2109)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserLT {
		{
			p.SetState(2108)
			p.TypeArguments()
		}

	}
	p.SetState(2114)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserAT {
		{
			p.SetState(2111)
			p.Annotation()
		}

		p.SetState(2116)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(2117)
		p.Match(Java8ParserIdentifier)
	}
	p.SetState(2119)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserLT {
		{
			p.SetState(2118)
			p.TypeArgumentsOrDiamond()
		}

	}
	{
		p.SetState(2121)
		p.Match(Java8ParserLPAREN)
	}
	p.SetState(2123)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
		{
			p.SetState(2122)
			p.ArgumentList()
		}

	}
	{
		p.SetState(2125)
		p.Match(Java8ParserRPAREN)
	}
	p.SetState(2127)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 225, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(2126)
			p.ClassBody()
		}

	}

	return localctx
}

// IClassInstanceCreationExpression_lfno_primaryContext is an interface to support dynamic dispatch.
type IClassInstanceCreationExpression_lfno_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassInstanceCreationExpression_lfno_primaryContext differentiates from other interfaces.
	IsClassInstanceCreationExpression_lfno_primaryContext()
}

type ClassInstanceCreationExpression_lfno_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassInstanceCreationExpression_lfno_primaryContext() *ClassInstanceCreationExpression_lfno_primaryContext {
	var p = new(ClassInstanceCreationExpression_lfno_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_classInstanceCreationExpression_lfno_primary
	return p
}

func (*ClassInstanceCreationExpression_lfno_primaryContext) IsClassInstanceCreationExpression_lfno_primaryContext() {
}

func NewClassInstanceCreationExpression_lfno_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassInstanceCreationExpression_lfno_primaryContext {
	var p = new(ClassInstanceCreationExpression_lfno_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_classInstanceCreationExpression_lfno_primary

	return p
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) GetParser() antlr.Parser {
	return s.parser
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) NEW() antlr.TerminalNode {
	return s.GetToken(Java8ParserNEW, 0)
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) AllIdentifier() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserIdentifier)
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) Identifier(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, i)
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserDOT)
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) DOT(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, i)
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) TypeArgumentsOrDiamond() ITypeArgumentsOrDiamondContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsOrDiamondContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsOrDiamondContext)
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) ArgumentList() IArgumentListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentListContext)
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) ClassBody() IClassBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassBodyContext)
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) ExpressionName() IExpressionNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionNameContext)
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterClassInstanceCreationExpression_lfno_primary(s)
	}
}

func (s *ClassInstanceCreationExpression_lfno_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitClassInstanceCreationExpression_lfno_primary(s)
	}
}

func (p *Java8Parser) ClassInstanceCreationExpression_lfno_primary() (localctx IClassInstanceCreationExpression_lfno_primaryContext) {
	this := p
	_ = this

	localctx = NewClassInstanceCreationExpression_lfno_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 374, Java8ParserRULE_classInstanceCreationExpression_lfno_primary)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2188)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserNEW:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2129)
			p.Match(Java8ParserNEW)
		}
		p.SetState(2131)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2130)
				p.TypeArguments()
			}

		}
		p.SetState(2136)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserAT {
			{
				p.SetState(2133)
				p.Annotation()
			}

			p.SetState(2138)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(2139)
			p.Match(Java8ParserIdentifier)
		}
		p.SetState(2150)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserDOT {
			{
				p.SetState(2140)
				p.Match(Java8ParserDOT)
			}
			p.SetState(2144)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == Java8ParserAT {
				{
					p.SetState(2141)
					p.Annotation()
				}

				p.SetState(2146)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(2147)
				p.Match(Java8ParserIdentifier)
			}

			p.SetState(2152)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		p.SetState(2154)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2153)
				p.TypeArgumentsOrDiamond()
			}

		}
		{
			p.SetState(2156)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2158)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2157)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2160)
			p.Match(Java8ParserRPAREN)
		}
		p.SetState(2162)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 232, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2161)
				p.ClassBody()
			}

		}

	case Java8ParserIdentifier:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2164)
			p.ExpressionName()
		}
		{
			p.SetState(2165)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2166)
			p.Match(Java8ParserNEW)
		}
		p.SetState(2168)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2167)
				p.TypeArguments()
			}

		}
		p.SetState(2173)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserAT {
			{
				p.SetState(2170)
				p.Annotation()
			}

			p.SetState(2175)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(2176)
			p.Match(Java8ParserIdentifier)
		}
		p.SetState(2178)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2177)
				p.TypeArgumentsOrDiamond()
			}

		}
		{
			p.SetState(2180)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2182)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2181)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2184)
			p.Match(Java8ParserRPAREN)
		}
		p.SetState(2186)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 237, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2185)
				p.ClassBody()
			}

		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// ITypeArgumentsOrDiamondContext is an interface to support dynamic dispatch.
type ITypeArgumentsOrDiamondContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeArgumentsOrDiamondContext differentiates from other interfaces.
	IsTypeArgumentsOrDiamondContext()
}

type TypeArgumentsOrDiamondContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypeArgumentsOrDiamondContext() *TypeArgumentsOrDiamondContext {
	var p = new(TypeArgumentsOrDiamondContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_typeArgumentsOrDiamond
	return p
}

func (*TypeArgumentsOrDiamondContext) IsTypeArgumentsOrDiamondContext() {}

func NewTypeArgumentsOrDiamondContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeArgumentsOrDiamondContext {
	var p = new(TypeArgumentsOrDiamondContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_typeArgumentsOrDiamond

	return p
}

func (s *TypeArgumentsOrDiamondContext) GetParser() antlr.Parser { return s.parser }

func (s *TypeArgumentsOrDiamondContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *TypeArgumentsOrDiamondContext) LT() antlr.TerminalNode {
	return s.GetToken(Java8ParserLT, 0)
}

func (s *TypeArgumentsOrDiamondContext) GT() antlr.TerminalNode {
	return s.GetToken(Java8ParserGT, 0)
}

func (s *TypeArgumentsOrDiamondContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeArgumentsOrDiamondContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypeArgumentsOrDiamondContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterTypeArgumentsOrDiamond(s)
	}
}

func (s *TypeArgumentsOrDiamondContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitTypeArgumentsOrDiamond(s)
	}
}

func (p *Java8Parser) TypeArgumentsOrDiamond() (localctx ITypeArgumentsOrDiamondContext) {
	this := p
	_ = this

	localctx = NewTypeArgumentsOrDiamondContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 376, Java8ParserRULE_typeArgumentsOrDiamond)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2193)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 239, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2190)
			p.TypeArguments()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2191)
			p.Match(Java8ParserLT)
		}
		{
			p.SetState(2192)
			p.Match(Java8ParserGT)
		}

	}

	return localctx
}

// IFieldAccessContext is an interface to support dynamic dispatch.
type IFieldAccessContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFieldAccessContext differentiates from other interfaces.
	IsFieldAccessContext()
}

type FieldAccessContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFieldAccessContext() *FieldAccessContext {
	var p = new(FieldAccessContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_fieldAccess
	return p
}

func (*FieldAccessContext) IsFieldAccessContext() {}

func NewFieldAccessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldAccessContext {
	var p = new(FieldAccessContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_fieldAccess

	return p
}

func (s *FieldAccessContext) GetParser() antlr.Parser { return s.parser }

func (s *FieldAccessContext) Primary() IPrimaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryContext)
}

func (s *FieldAccessContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserDOT)
}

func (s *FieldAccessContext) DOT(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, i)
}

func (s *FieldAccessContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *FieldAccessContext) SUPER() antlr.TerminalNode {
	return s.GetToken(Java8ParserSUPER, 0)
}

func (s *FieldAccessContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *FieldAccessContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FieldAccessContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FieldAccessContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterFieldAccess(s)
	}
}

func (s *FieldAccessContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitFieldAccess(s)
	}
}

func (p *Java8Parser) FieldAccess() (localctx IFieldAccessContext) {
	this := p
	_ = this

	localctx = NewFieldAccessContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 378, Java8ParserRULE_fieldAccess)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2208)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 240, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2195)
			p.Primary()
		}
		{
			p.SetState(2196)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2197)
			p.Match(Java8ParserIdentifier)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2199)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(2200)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2201)
			p.Match(Java8ParserIdentifier)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2202)
			p.TypeName()
		}
		{
			p.SetState(2203)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2204)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(2205)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2206)
			p.Match(Java8ParserIdentifier)
		}

	}

	return localctx
}

// IFieldAccess_lf_primaryContext is an interface to support dynamic dispatch.
type IFieldAccess_lf_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFieldAccess_lf_primaryContext differentiates from other interfaces.
	IsFieldAccess_lf_primaryContext()
}

type FieldAccess_lf_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFieldAccess_lf_primaryContext() *FieldAccess_lf_primaryContext {
	var p = new(FieldAccess_lf_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_fieldAccess_lf_primary
	return p
}

func (*FieldAccess_lf_primaryContext) IsFieldAccess_lf_primaryContext() {}

func NewFieldAccess_lf_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldAccess_lf_primaryContext {
	var p = new(FieldAccess_lf_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_fieldAccess_lf_primary

	return p
}

func (s *FieldAccess_lf_primaryContext) GetParser() antlr.Parser { return s.parser }

func (s *FieldAccess_lf_primaryContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *FieldAccess_lf_primaryContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *FieldAccess_lf_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FieldAccess_lf_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FieldAccess_lf_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterFieldAccess_lf_primary(s)
	}
}

func (s *FieldAccess_lf_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitFieldAccess_lf_primary(s)
	}
}

func (p *Java8Parser) FieldAccess_lf_primary() (localctx IFieldAccess_lf_primaryContext) {
	this := p
	_ = this

	localctx = NewFieldAccess_lf_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 380, Java8ParserRULE_fieldAccess_lf_primary)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2210)
		p.Match(Java8ParserDOT)
	}
	{
		p.SetState(2211)
		p.Match(Java8ParserIdentifier)
	}

	return localctx
}

// IFieldAccess_lfno_primaryContext is an interface to support dynamic dispatch.
type IFieldAccess_lfno_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFieldAccess_lfno_primaryContext differentiates from other interfaces.
	IsFieldAccess_lfno_primaryContext()
}

type FieldAccess_lfno_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFieldAccess_lfno_primaryContext() *FieldAccess_lfno_primaryContext {
	var p = new(FieldAccess_lfno_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_fieldAccess_lfno_primary
	return p
}

func (*FieldAccess_lfno_primaryContext) IsFieldAccess_lfno_primaryContext() {}

func NewFieldAccess_lfno_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldAccess_lfno_primaryContext {
	var p = new(FieldAccess_lfno_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_fieldAccess_lfno_primary

	return p
}

func (s *FieldAccess_lfno_primaryContext) GetParser() antlr.Parser { return s.parser }

func (s *FieldAccess_lfno_primaryContext) SUPER() antlr.TerminalNode {
	return s.GetToken(Java8ParserSUPER, 0)
}

func (s *FieldAccess_lfno_primaryContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserDOT)
}

func (s *FieldAccess_lfno_primaryContext) DOT(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, i)
}

func (s *FieldAccess_lfno_primaryContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *FieldAccess_lfno_primaryContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *FieldAccess_lfno_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FieldAccess_lfno_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FieldAccess_lfno_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterFieldAccess_lfno_primary(s)
	}
}

func (s *FieldAccess_lfno_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitFieldAccess_lfno_primary(s)
	}
}

func (p *Java8Parser) FieldAccess_lfno_primary() (localctx IFieldAccess_lfno_primaryContext) {
	this := p
	_ = this

	localctx = NewFieldAccess_lfno_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 382, Java8ParserRULE_fieldAccess_lfno_primary)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2222)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserSUPER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2213)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(2214)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2215)
			p.Match(Java8ParserIdentifier)
		}

	case Java8ParserIdentifier:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2216)
			p.TypeName()
		}
		{
			p.SetState(2217)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2218)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(2219)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2220)
			p.Match(Java8ParserIdentifier)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IArrayAccessContext is an interface to support dynamic dispatch.
type IArrayAccessContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArrayAccessContext differentiates from other interfaces.
	IsArrayAccessContext()
}

type ArrayAccessContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArrayAccessContext() *ArrayAccessContext {
	var p = new(ArrayAccessContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_arrayAccess
	return p
}

func (*ArrayAccessContext) IsArrayAccessContext() {}

func NewArrayAccessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayAccessContext {
	var p = new(ArrayAccessContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_arrayAccess

	return p
}

func (s *ArrayAccessContext) GetParser() antlr.Parser { return s.parser }

func (s *ArrayAccessContext) ExpressionName() IExpressionNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionNameContext)
}

func (s *ArrayAccessContext) AllLBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserLBRACK)
}

func (s *ArrayAccessContext) LBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACK, i)
}

func (s *ArrayAccessContext) AllExpression() []IExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem())
	var tst = make([]IExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IExpressionContext)
		}
	}

	return tst
}

func (s *ArrayAccessContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ArrayAccessContext) AllRBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserRBRACK)
}

func (s *ArrayAccessContext) RBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACK, i)
}

func (s *ArrayAccessContext) PrimaryNoNewArray_lfno_arrayAccess() IPrimaryNoNewArray_lfno_arrayAccessContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryNoNewArray_lfno_arrayAccessContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryNoNewArray_lfno_arrayAccessContext)
}

func (s *ArrayAccessContext) AllPrimaryNoNewArray_lf_arrayAccess() []IPrimaryNoNewArray_lf_arrayAccessContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IPrimaryNoNewArray_lf_arrayAccessContext)(nil)).Elem())
	var tst = make([]IPrimaryNoNewArray_lf_arrayAccessContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IPrimaryNoNewArray_lf_arrayAccessContext)
		}
	}

	return tst
}

func (s *ArrayAccessContext) PrimaryNoNewArray_lf_arrayAccess(i int) IPrimaryNoNewArray_lf_arrayAccessContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryNoNewArray_lf_arrayAccessContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IPrimaryNoNewArray_lf_arrayAccessContext)
}

func (s *ArrayAccessContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArrayAccessContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArrayAccessContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterArrayAccess(s)
	}
}

func (s *ArrayAccessContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitArrayAccess(s)
	}
}

func (p *Java8Parser) ArrayAccess() (localctx IArrayAccessContext) {
	this := p
	_ = this

	localctx = NewArrayAccessContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 384, Java8ParserRULE_arrayAccess)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2234)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 242, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(2224)
			p.ExpressionName()
		}
		{
			p.SetState(2225)
			p.Match(Java8ParserLBRACK)
		}
		{
			p.SetState(2226)
			p.Expression()
		}
		{
			p.SetState(2227)
			p.Match(Java8ParserRBRACK)
		}

	case 2:
		{
			p.SetState(2229)
			p.PrimaryNoNewArray_lfno_arrayAccess()
		}
		{
			p.SetState(2230)
			p.Match(Java8ParserLBRACK)
		}
		{
			p.SetState(2231)
			p.Expression()
		}
		{
			p.SetState(2232)
			p.Match(Java8ParserRBRACK)
		}

	}
	p.SetState(2243)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserLBRACK {
		{
			p.SetState(2236)
			p.PrimaryNoNewArray_lf_arrayAccess()
		}
		{
			p.SetState(2237)
			p.Match(Java8ParserLBRACK)
		}
		{
			p.SetState(2238)
			p.Expression()
		}
		{
			p.SetState(2239)
			p.Match(Java8ParserRBRACK)
		}

		p.SetState(2245)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IArrayAccess_lf_primaryContext is an interface to support dynamic dispatch.
type IArrayAccess_lf_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArrayAccess_lf_primaryContext differentiates from other interfaces.
	IsArrayAccess_lf_primaryContext()
}

type ArrayAccess_lf_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArrayAccess_lf_primaryContext() *ArrayAccess_lf_primaryContext {
	var p = new(ArrayAccess_lf_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_arrayAccess_lf_primary
	return p
}

func (*ArrayAccess_lf_primaryContext) IsArrayAccess_lf_primaryContext() {}

func NewArrayAccess_lf_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayAccess_lf_primaryContext {
	var p = new(ArrayAccess_lf_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_arrayAccess_lf_primary

	return p
}

func (s *ArrayAccess_lf_primaryContext) GetParser() antlr.Parser { return s.parser }

func (s *ArrayAccess_lf_primaryContext) PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() IPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext)
}

func (s *ArrayAccess_lf_primaryContext) AllLBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserLBRACK)
}

func (s *ArrayAccess_lf_primaryContext) LBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACK, i)
}

func (s *ArrayAccess_lf_primaryContext) AllExpression() []IExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem())
	var tst = make([]IExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IExpressionContext)
		}
	}

	return tst
}

func (s *ArrayAccess_lf_primaryContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ArrayAccess_lf_primaryContext) AllRBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserRBRACK)
}

func (s *ArrayAccess_lf_primaryContext) RBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACK, i)
}

func (s *ArrayAccess_lf_primaryContext) AllPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() []IPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext)(nil)).Elem())
	var tst = make([]IPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext)
		}
	}

	return tst
}

func (s *ArrayAccess_lf_primaryContext) PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(i int) IPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext)
}

func (s *ArrayAccess_lf_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArrayAccess_lf_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArrayAccess_lf_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterArrayAccess_lf_primary(s)
	}
}

func (s *ArrayAccess_lf_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitArrayAccess_lf_primary(s)
	}
}

func (p *Java8Parser) ArrayAccess_lf_primary() (localctx IArrayAccess_lf_primaryContext) {
	this := p
	_ = this

	localctx = NewArrayAccess_lf_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 386, Java8ParserRULE_arrayAccess_lf_primary)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2246)
		p.PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary()
	}
	{
		p.SetState(2247)
		p.Match(Java8ParserLBRACK)
	}
	{
		p.SetState(2248)
		p.Expression()
	}
	{
		p.SetState(2249)
		p.Match(Java8ParserRBRACK)
	}

	p.SetState(2258)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 244, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(2251)
				p.PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary()
			}
			{
				p.SetState(2252)
				p.Match(Java8ParserLBRACK)
			}
			{
				p.SetState(2253)
				p.Expression()
			}
			{
				p.SetState(2254)
				p.Match(Java8ParserRBRACK)
			}

		}
		p.SetState(2260)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 244, p.GetParserRuleContext())
	}

	return localctx
}

// IArrayAccess_lfno_primaryContext is an interface to support dynamic dispatch.
type IArrayAccess_lfno_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArrayAccess_lfno_primaryContext differentiates from other interfaces.
	IsArrayAccess_lfno_primaryContext()
}

type ArrayAccess_lfno_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArrayAccess_lfno_primaryContext() *ArrayAccess_lfno_primaryContext {
	var p = new(ArrayAccess_lfno_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_arrayAccess_lfno_primary
	return p
}

func (*ArrayAccess_lfno_primaryContext) IsArrayAccess_lfno_primaryContext() {}

func NewArrayAccess_lfno_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayAccess_lfno_primaryContext {
	var p = new(ArrayAccess_lfno_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_arrayAccess_lfno_primary

	return p
}

func (s *ArrayAccess_lfno_primaryContext) GetParser() antlr.Parser { return s.parser }

func (s *ArrayAccess_lfno_primaryContext) ExpressionName() IExpressionNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionNameContext)
}

func (s *ArrayAccess_lfno_primaryContext) AllLBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserLBRACK)
}

func (s *ArrayAccess_lfno_primaryContext) LBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACK, i)
}

func (s *ArrayAccess_lfno_primaryContext) AllExpression() []IExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem())
	var tst = make([]IExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IExpressionContext)
		}
	}

	return tst
}

func (s *ArrayAccess_lfno_primaryContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ArrayAccess_lfno_primaryContext) AllRBRACK() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserRBRACK)
}

func (s *ArrayAccess_lfno_primaryContext) RBRACK(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACK, i)
}

func (s *ArrayAccess_lfno_primaryContext) PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() IPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext)
}

func (s *ArrayAccess_lfno_primaryContext) AllPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() []IPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext)(nil)).Elem())
	var tst = make([]IPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext)
		}
	}

	return tst
}

func (s *ArrayAccess_lfno_primaryContext) PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(i int) IPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext)
}

func (s *ArrayAccess_lfno_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArrayAccess_lfno_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArrayAccess_lfno_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterArrayAccess_lfno_primary(s)
	}
}

func (s *ArrayAccess_lfno_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitArrayAccess_lfno_primary(s)
	}
}

func (p *Java8Parser) ArrayAccess_lfno_primary() (localctx IArrayAccess_lfno_primaryContext) {
	this := p
	_ = this

	localctx = NewArrayAccess_lfno_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 388, Java8ParserRULE_arrayAccess_lfno_primary)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2271)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 245, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(2261)
			p.ExpressionName()
		}
		{
			p.SetState(2262)
			p.Match(Java8ParserLBRACK)
		}
		{
			p.SetState(2263)
			p.Expression()
		}
		{
			p.SetState(2264)
			p.Match(Java8ParserRBRACK)
		}

	case 2:
		{
			p.SetState(2266)
			p.PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary()
		}
		{
			p.SetState(2267)
			p.Match(Java8ParserLBRACK)
		}
		{
			p.SetState(2268)
			p.Expression()
		}
		{
			p.SetState(2269)
			p.Match(Java8ParserRBRACK)
		}

	}
	p.SetState(2280)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 246, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(2273)
				p.PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary()
			}
			{
				p.SetState(2274)
				p.Match(Java8ParserLBRACK)
			}
			{
				p.SetState(2275)
				p.Expression()
			}
			{
				p.SetState(2276)
				p.Match(Java8ParserRBRACK)
			}

		}
		p.SetState(2282)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 246, p.GetParserRuleContext())
	}

	return localctx
}

// IMethodInvocationContext is an interface to support dynamic dispatch.
type IMethodInvocationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMethodInvocationContext differentiates from other interfaces.
	IsMethodInvocationContext()
}

type MethodInvocationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMethodInvocationContext() *MethodInvocationContext {
	var p = new(MethodInvocationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_methodInvocation
	return p
}

func (*MethodInvocationContext) IsMethodInvocationContext() {}

func NewMethodInvocationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodInvocationContext {
	var p = new(MethodInvocationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_methodInvocation

	return p
}

func (s *MethodInvocationContext) GetParser() antlr.Parser { return s.parser }

func (s *MethodInvocationContext) MethodName() IMethodNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodNameContext)
}

func (s *MethodInvocationContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *MethodInvocationContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *MethodInvocationContext) ArgumentList() IArgumentListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentListContext)
}

func (s *MethodInvocationContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *MethodInvocationContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserDOT)
}

func (s *MethodInvocationContext) DOT(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, i)
}

func (s *MethodInvocationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *MethodInvocationContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *MethodInvocationContext) ExpressionName() IExpressionNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionNameContext)
}

func (s *MethodInvocationContext) Primary() IPrimaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryContext)
}

func (s *MethodInvocationContext) SUPER() antlr.TerminalNode {
	return s.GetToken(Java8ParserSUPER, 0)
}

func (s *MethodInvocationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MethodInvocationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MethodInvocationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterMethodInvocation(s)
	}
}

func (s *MethodInvocationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitMethodInvocation(s)
	}
}

func (p *Java8Parser) MethodInvocation() (localctx IMethodInvocationContext) {
	this := p
	_ = this

	localctx = NewMethodInvocationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 390, Java8ParserRULE_methodInvocation)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2351)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 258, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2283)
			p.MethodName()
		}
		{
			p.SetState(2284)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2286)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2285)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2288)
			p.Match(Java8ParserRPAREN)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2290)
			p.TypeName()
		}
		{
			p.SetState(2291)
			p.Match(Java8ParserDOT)
		}
		p.SetState(2293)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2292)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2295)
			p.Match(Java8ParserIdentifier)
		}
		{
			p.SetState(2296)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2298)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2297)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2300)
			p.Match(Java8ParserRPAREN)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2302)
			p.ExpressionName()
		}
		{
			p.SetState(2303)
			p.Match(Java8ParserDOT)
		}
		p.SetState(2305)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2304)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2307)
			p.Match(Java8ParserIdentifier)
		}
		{
			p.SetState(2308)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2310)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2309)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2312)
			p.Match(Java8ParserRPAREN)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2314)
			p.Primary()
		}
		{
			p.SetState(2315)
			p.Match(Java8ParserDOT)
		}
		p.SetState(2317)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2316)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2319)
			p.Match(Java8ParserIdentifier)
		}
		{
			p.SetState(2320)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2322)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2321)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2324)
			p.Match(Java8ParserRPAREN)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(2326)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(2327)
			p.Match(Java8ParserDOT)
		}
		p.SetState(2329)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2328)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2331)
			p.Match(Java8ParserIdentifier)
		}
		{
			p.SetState(2332)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2334)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2333)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2336)
			p.Match(Java8ParserRPAREN)
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(2337)
			p.TypeName()
		}
		{
			p.SetState(2338)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2339)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(2340)
			p.Match(Java8ParserDOT)
		}
		p.SetState(2342)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2341)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2344)
			p.Match(Java8ParserIdentifier)
		}
		{
			p.SetState(2345)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2347)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2346)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2349)
			p.Match(Java8ParserRPAREN)
		}

	}

	return localctx
}

// IMethodInvocation_lf_primaryContext is an interface to support dynamic dispatch.
type IMethodInvocation_lf_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMethodInvocation_lf_primaryContext differentiates from other interfaces.
	IsMethodInvocation_lf_primaryContext()
}

type MethodInvocation_lf_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMethodInvocation_lf_primaryContext() *MethodInvocation_lf_primaryContext {
	var p = new(MethodInvocation_lf_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_methodInvocation_lf_primary
	return p
}

func (*MethodInvocation_lf_primaryContext) IsMethodInvocation_lf_primaryContext() {}

func NewMethodInvocation_lf_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodInvocation_lf_primaryContext {
	var p = new(MethodInvocation_lf_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_methodInvocation_lf_primary

	return p
}

func (s *MethodInvocation_lf_primaryContext) GetParser() antlr.Parser { return s.parser }

func (s *MethodInvocation_lf_primaryContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *MethodInvocation_lf_primaryContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *MethodInvocation_lf_primaryContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *MethodInvocation_lf_primaryContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *MethodInvocation_lf_primaryContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *MethodInvocation_lf_primaryContext) ArgumentList() IArgumentListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentListContext)
}

func (s *MethodInvocation_lf_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MethodInvocation_lf_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MethodInvocation_lf_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterMethodInvocation_lf_primary(s)
	}
}

func (s *MethodInvocation_lf_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitMethodInvocation_lf_primary(s)
	}
}

func (p *Java8Parser) MethodInvocation_lf_primary() (localctx IMethodInvocation_lf_primaryContext) {
	this := p
	_ = this

	localctx = NewMethodInvocation_lf_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 392, Java8ParserRULE_methodInvocation_lf_primary)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2353)
		p.Match(Java8ParserDOT)
	}
	p.SetState(2355)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserLT {
		{
			p.SetState(2354)
			p.TypeArguments()
		}

	}
	{
		p.SetState(2357)
		p.Match(Java8ParserIdentifier)
	}
	{
		p.SetState(2358)
		p.Match(Java8ParserLPAREN)
	}
	p.SetState(2360)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
		{
			p.SetState(2359)
			p.ArgumentList()
		}

	}
	{
		p.SetState(2362)
		p.Match(Java8ParserRPAREN)
	}

	return localctx
}

// IMethodInvocation_lfno_primaryContext is an interface to support dynamic dispatch.
type IMethodInvocation_lfno_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMethodInvocation_lfno_primaryContext differentiates from other interfaces.
	IsMethodInvocation_lfno_primaryContext()
}

type MethodInvocation_lfno_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMethodInvocation_lfno_primaryContext() *MethodInvocation_lfno_primaryContext {
	var p = new(MethodInvocation_lfno_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_methodInvocation_lfno_primary
	return p
}

func (*MethodInvocation_lfno_primaryContext) IsMethodInvocation_lfno_primaryContext() {}

func NewMethodInvocation_lfno_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodInvocation_lfno_primaryContext {
	var p = new(MethodInvocation_lfno_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_methodInvocation_lfno_primary

	return p
}

func (s *MethodInvocation_lfno_primaryContext) GetParser() antlr.Parser { return s.parser }

func (s *MethodInvocation_lfno_primaryContext) MethodName() IMethodNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodNameContext)
}

func (s *MethodInvocation_lfno_primaryContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *MethodInvocation_lfno_primaryContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *MethodInvocation_lfno_primaryContext) ArgumentList() IArgumentListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentListContext)
}

func (s *MethodInvocation_lfno_primaryContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *MethodInvocation_lfno_primaryContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserDOT)
}

func (s *MethodInvocation_lfno_primaryContext) DOT(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, i)
}

func (s *MethodInvocation_lfno_primaryContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *MethodInvocation_lfno_primaryContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *MethodInvocation_lfno_primaryContext) ExpressionName() IExpressionNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionNameContext)
}

func (s *MethodInvocation_lfno_primaryContext) SUPER() antlr.TerminalNode {
	return s.GetToken(Java8ParserSUPER, 0)
}

func (s *MethodInvocation_lfno_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MethodInvocation_lfno_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MethodInvocation_lfno_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterMethodInvocation_lfno_primary(s)
	}
}

func (s *MethodInvocation_lfno_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitMethodInvocation_lfno_primary(s)
	}
}

func (p *Java8Parser) MethodInvocation_lfno_primary() (localctx IMethodInvocation_lfno_primaryContext) {
	this := p
	_ = this

	localctx = NewMethodInvocation_lfno_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 394, Java8ParserRULE_methodInvocation_lfno_primary)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2420)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 270, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2364)
			p.MethodName()
		}
		{
			p.SetState(2365)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2367)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2366)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2369)
			p.Match(Java8ParserRPAREN)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2371)
			p.TypeName()
		}
		{
			p.SetState(2372)
			p.Match(Java8ParserDOT)
		}
		p.SetState(2374)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2373)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2376)
			p.Match(Java8ParserIdentifier)
		}
		{
			p.SetState(2377)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2379)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2378)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2381)
			p.Match(Java8ParserRPAREN)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2383)
			p.ExpressionName()
		}
		{
			p.SetState(2384)
			p.Match(Java8ParserDOT)
		}
		p.SetState(2386)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2385)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2388)
			p.Match(Java8ParserIdentifier)
		}
		{
			p.SetState(2389)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2391)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2390)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2393)
			p.Match(Java8ParserRPAREN)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2395)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(2396)
			p.Match(Java8ParserDOT)
		}
		p.SetState(2398)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2397)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2400)
			p.Match(Java8ParserIdentifier)
		}
		{
			p.SetState(2401)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2403)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2402)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2405)
			p.Match(Java8ParserRPAREN)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(2406)
			p.TypeName()
		}
		{
			p.SetState(2407)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2408)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(2409)
			p.Match(Java8ParserDOT)
		}
		p.SetState(2411)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2410)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2413)
			p.Match(Java8ParserIdentifier)
		}
		{
			p.SetState(2414)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2416)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG)|(1<<Java8ParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(Java8ParserSHORT-37))|(1<<(Java8ParserSUPER-37))|(1<<(Java8ParserTHIS-37))|(1<<(Java8ParserVOID-37))|(1<<(Java8ParserIntegerLiteral-37))|(1<<(Java8ParserFloatingPointLiteral-37))|(1<<(Java8ParserBooleanLiteral-37))|(1<<(Java8ParserCharacterLiteral-37))|(1<<(Java8ParserStringLiteral-37))|(1<<(Java8ParserNullLiteral-37))|(1<<(Java8ParserLPAREN-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(Java8ParserBANG-69))|(1<<(Java8ParserTILDE-69))|(1<<(Java8ParserINC-69))|(1<<(Java8ParserDEC-69))|(1<<(Java8ParserADD-69))|(1<<(Java8ParserSUB-69)))) != 0) || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2415)
				p.ArgumentList()
			}

		}
		{
			p.SetState(2418)
			p.Match(Java8ParserRPAREN)
		}

	}

	return localctx
}

// IArgumentListContext is an interface to support dynamic dispatch.
type IArgumentListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArgumentListContext differentiates from other interfaces.
	IsArgumentListContext()
}

type ArgumentListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArgumentListContext() *ArgumentListContext {
	var p = new(ArgumentListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_argumentList
	return p
}

func (*ArgumentListContext) IsArgumentListContext() {}

func NewArgumentListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentListContext {
	var p = new(ArgumentListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_argumentList

	return p
}

func (s *ArgumentListContext) GetParser() antlr.Parser { return s.parser }

func (s *ArgumentListContext) AllExpression() []IExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem())
	var tst = make([]IExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IExpressionContext)
		}
	}

	return tst
}

func (s *ArgumentListContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ArgumentListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserCOMMA)
}

func (s *ArgumentListContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, i)
}

func (s *ArgumentListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArgumentListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArgumentListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterArgumentList(s)
	}
}

func (s *ArgumentListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitArgumentList(s)
	}
}

func (p *Java8Parser) ArgumentList() (localctx IArgumentListContext) {
	this := p
	_ = this

	localctx = NewArgumentListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 396, Java8ParserRULE_argumentList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2422)
		p.Expression()
	}
	p.SetState(2427)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserCOMMA {
		{
			p.SetState(2423)
			p.Match(Java8ParserCOMMA)
		}
		{
			p.SetState(2424)
			p.Expression()
		}

		p.SetState(2429)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IMethodReferenceContext is an interface to support dynamic dispatch.
type IMethodReferenceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMethodReferenceContext differentiates from other interfaces.
	IsMethodReferenceContext()
}

type MethodReferenceContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMethodReferenceContext() *MethodReferenceContext {
	var p = new(MethodReferenceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_methodReference
	return p
}

func (*MethodReferenceContext) IsMethodReferenceContext() {}

func NewMethodReferenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodReferenceContext {
	var p = new(MethodReferenceContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_methodReference

	return p
}

func (s *MethodReferenceContext) GetParser() antlr.Parser { return s.parser }

func (s *MethodReferenceContext) ExpressionName() IExpressionNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionNameContext)
}

func (s *MethodReferenceContext) COLONCOLON() antlr.TerminalNode {
	return s.GetToken(Java8ParserCOLONCOLON, 0)
}

func (s *MethodReferenceContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *MethodReferenceContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *MethodReferenceContext) ReferenceType() IReferenceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReferenceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReferenceTypeContext)
}

func (s *MethodReferenceContext) Primary() IPrimaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryContext)
}

func (s *MethodReferenceContext) SUPER() antlr.TerminalNode {
	return s.GetToken(Java8ParserSUPER, 0)
}

func (s *MethodReferenceContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *MethodReferenceContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *MethodReferenceContext) ClassType() IClassTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassTypeContext)
}

func (s *MethodReferenceContext) NEW() antlr.TerminalNode {
	return s.GetToken(Java8ParserNEW, 0)
}

func (s *MethodReferenceContext) ArrayType() IArrayTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayTypeContext)
}

func (s *MethodReferenceContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MethodReferenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MethodReferenceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterMethodReference(s)
	}
}

func (s *MethodReferenceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitMethodReference(s)
	}
}

func (p *Java8Parser) MethodReference() (localctx IMethodReferenceContext) {
	this := p
	_ = this

	localctx = NewMethodReferenceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 398, Java8ParserRULE_methodReference)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2477)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 278, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2430)
			p.ExpressionName()
		}
		{
			p.SetState(2431)
			p.Match(Java8ParserCOLONCOLON)
		}
		p.SetState(2433)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2432)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2435)
			p.Match(Java8ParserIdentifier)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2437)
			p.ReferenceType()
		}
		{
			p.SetState(2438)
			p.Match(Java8ParserCOLONCOLON)
		}
		p.SetState(2440)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2439)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2442)
			p.Match(Java8ParserIdentifier)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2444)
			p.Primary()
		}
		{
			p.SetState(2445)
			p.Match(Java8ParserCOLONCOLON)
		}
		p.SetState(2447)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2446)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2449)
			p.Match(Java8ParserIdentifier)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2451)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(2452)
			p.Match(Java8ParserCOLONCOLON)
		}
		p.SetState(2454)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2453)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2456)
			p.Match(Java8ParserIdentifier)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(2457)
			p.TypeName()
		}
		{
			p.SetState(2458)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2459)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(2460)
			p.Match(Java8ParserCOLONCOLON)
		}
		p.SetState(2462)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2461)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2464)
			p.Match(Java8ParserIdentifier)
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(2466)
			p.ClassType()
		}
		{
			p.SetState(2467)
			p.Match(Java8ParserCOLONCOLON)
		}
		p.SetState(2469)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2468)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2471)
			p.Match(Java8ParserNEW)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(2473)
			p.ArrayType()
		}
		{
			p.SetState(2474)
			p.Match(Java8ParserCOLONCOLON)
		}
		{
			p.SetState(2475)
			p.Match(Java8ParserNEW)
		}

	}

	return localctx
}

// IMethodReference_lf_primaryContext is an interface to support dynamic dispatch.
type IMethodReference_lf_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMethodReference_lf_primaryContext differentiates from other interfaces.
	IsMethodReference_lf_primaryContext()
}

type MethodReference_lf_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMethodReference_lf_primaryContext() *MethodReference_lf_primaryContext {
	var p = new(MethodReference_lf_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_methodReference_lf_primary
	return p
}

func (*MethodReference_lf_primaryContext) IsMethodReference_lf_primaryContext() {}

func NewMethodReference_lf_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodReference_lf_primaryContext {
	var p = new(MethodReference_lf_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_methodReference_lf_primary

	return p
}

func (s *MethodReference_lf_primaryContext) GetParser() antlr.Parser { return s.parser }

func (s *MethodReference_lf_primaryContext) COLONCOLON() antlr.TerminalNode {
	return s.GetToken(Java8ParserCOLONCOLON, 0)
}

func (s *MethodReference_lf_primaryContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *MethodReference_lf_primaryContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *MethodReference_lf_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MethodReference_lf_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MethodReference_lf_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterMethodReference_lf_primary(s)
	}
}

func (s *MethodReference_lf_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitMethodReference_lf_primary(s)
	}
}

func (p *Java8Parser) MethodReference_lf_primary() (localctx IMethodReference_lf_primaryContext) {
	this := p
	_ = this

	localctx = NewMethodReference_lf_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 400, Java8ParserRULE_methodReference_lf_primary)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2479)
		p.Match(Java8ParserCOLONCOLON)
	}
	p.SetState(2481)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == Java8ParserLT {
		{
			p.SetState(2480)
			p.TypeArguments()
		}

	}
	{
		p.SetState(2483)
		p.Match(Java8ParserIdentifier)
	}

	return localctx
}

// IMethodReference_lfno_primaryContext is an interface to support dynamic dispatch.
type IMethodReference_lfno_primaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMethodReference_lfno_primaryContext differentiates from other interfaces.
	IsMethodReference_lfno_primaryContext()
}

type MethodReference_lfno_primaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMethodReference_lfno_primaryContext() *MethodReference_lfno_primaryContext {
	var p = new(MethodReference_lfno_primaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_methodReference_lfno_primary
	return p
}

func (*MethodReference_lfno_primaryContext) IsMethodReference_lfno_primaryContext() {}

func NewMethodReference_lfno_primaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MethodReference_lfno_primaryContext {
	var p = new(MethodReference_lfno_primaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_methodReference_lfno_primary

	return p
}

func (s *MethodReference_lfno_primaryContext) GetParser() antlr.Parser { return s.parser }

func (s *MethodReference_lfno_primaryContext) ExpressionName() IExpressionNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionNameContext)
}

func (s *MethodReference_lfno_primaryContext) COLONCOLON() antlr.TerminalNode {
	return s.GetToken(Java8ParserCOLONCOLON, 0)
}

func (s *MethodReference_lfno_primaryContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *MethodReference_lfno_primaryContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *MethodReference_lfno_primaryContext) ReferenceType() IReferenceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReferenceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReferenceTypeContext)
}

func (s *MethodReference_lfno_primaryContext) SUPER() antlr.TerminalNode {
	return s.GetToken(Java8ParserSUPER, 0)
}

func (s *MethodReference_lfno_primaryContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *MethodReference_lfno_primaryContext) DOT() antlr.TerminalNode {
	return s.GetToken(Java8ParserDOT, 0)
}

func (s *MethodReference_lfno_primaryContext) ClassType() IClassTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassTypeContext)
}

func (s *MethodReference_lfno_primaryContext) NEW() antlr.TerminalNode {
	return s.GetToken(Java8ParserNEW, 0)
}

func (s *MethodReference_lfno_primaryContext) ArrayType() IArrayTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayTypeContext)
}

func (s *MethodReference_lfno_primaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MethodReference_lfno_primaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MethodReference_lfno_primaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterMethodReference_lfno_primary(s)
	}
}

func (s *MethodReference_lfno_primaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitMethodReference_lfno_primary(s)
	}
}

func (p *Java8Parser) MethodReference_lfno_primary() (localctx IMethodReference_lfno_primaryContext) {
	this := p
	_ = this

	localctx = NewMethodReference_lfno_primaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 402, Java8ParserRULE_methodReference_lfno_primary)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2525)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 285, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2485)
			p.ExpressionName()
		}
		{
			p.SetState(2486)
			p.Match(Java8ParserCOLONCOLON)
		}
		p.SetState(2488)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2487)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2490)
			p.Match(Java8ParserIdentifier)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2492)
			p.ReferenceType()
		}
		{
			p.SetState(2493)
			p.Match(Java8ParserCOLONCOLON)
		}
		p.SetState(2495)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2494)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2497)
			p.Match(Java8ParserIdentifier)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2499)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(2500)
			p.Match(Java8ParserCOLONCOLON)
		}
		p.SetState(2502)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2501)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2504)
			p.Match(Java8ParserIdentifier)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2505)
			p.TypeName()
		}
		{
			p.SetState(2506)
			p.Match(Java8ParserDOT)
		}
		{
			p.SetState(2507)
			p.Match(Java8ParserSUPER)
		}
		{
			p.SetState(2508)
			p.Match(Java8ParserCOLONCOLON)
		}
		p.SetState(2510)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2509)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2512)
			p.Match(Java8ParserIdentifier)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(2514)
			p.ClassType()
		}
		{
			p.SetState(2515)
			p.Match(Java8ParserCOLONCOLON)
		}
		p.SetState(2517)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == Java8ParserLT {
			{
				p.SetState(2516)
				p.TypeArguments()
			}

		}
		{
			p.SetState(2519)
			p.Match(Java8ParserNEW)
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(2521)
			p.ArrayType()
		}
		{
			p.SetState(2522)
			p.Match(Java8ParserCOLONCOLON)
		}
		{
			p.SetState(2523)
			p.Match(Java8ParserNEW)
		}

	}

	return localctx
}

// IArrayCreationExpressionContext is an interface to support dynamic dispatch.
type IArrayCreationExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArrayCreationExpressionContext differentiates from other interfaces.
	IsArrayCreationExpressionContext()
}

type ArrayCreationExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArrayCreationExpressionContext() *ArrayCreationExpressionContext {
	var p = new(ArrayCreationExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_arrayCreationExpression
	return p
}

func (*ArrayCreationExpressionContext) IsArrayCreationExpressionContext() {}

func NewArrayCreationExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayCreationExpressionContext {
	var p = new(ArrayCreationExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_arrayCreationExpression

	return p
}

func (s *ArrayCreationExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *ArrayCreationExpressionContext) NEW() antlr.TerminalNode {
	return s.GetToken(Java8ParserNEW, 0)
}

func (s *ArrayCreationExpressionContext) PrimitiveType() IPrimitiveTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimitiveTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimitiveTypeContext)
}

func (s *ArrayCreationExpressionContext) DimExprs() IDimExprsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDimExprsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDimExprsContext)
}

func (s *ArrayCreationExpressionContext) Dims() IDimsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDimsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDimsContext)
}

func (s *ArrayCreationExpressionContext) ClassOrInterfaceType() IClassOrInterfaceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassOrInterfaceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassOrInterfaceTypeContext)
}

func (s *ArrayCreationExpressionContext) ArrayInitializer() IArrayInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayInitializerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayInitializerContext)
}

func (s *ArrayCreationExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArrayCreationExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArrayCreationExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterArrayCreationExpression(s)
	}
}

func (s *ArrayCreationExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitArrayCreationExpression(s)
	}
}

func (p *Java8Parser) ArrayCreationExpression() (localctx IArrayCreationExpressionContext) {
	this := p
	_ = this

	localctx = NewArrayCreationExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 404, Java8ParserRULE_arrayCreationExpression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2549)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 288, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2527)
			p.Match(Java8ParserNEW)
		}
		{
			p.SetState(2528)
			p.PrimitiveType()
		}
		{
			p.SetState(2529)
			p.DimExprs()
		}
		p.SetState(2531)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 286, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2530)
				p.Dims()
			}

		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2533)
			p.Match(Java8ParserNEW)
		}
		{
			p.SetState(2534)
			p.ClassOrInterfaceType()
		}
		{
			p.SetState(2535)
			p.DimExprs()
		}
		p.SetState(2537)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 287, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(2536)
				p.Dims()
			}

		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2539)
			p.Match(Java8ParserNEW)
		}
		{
			p.SetState(2540)
			p.PrimitiveType()
		}
		{
			p.SetState(2541)
			p.Dims()
		}
		{
			p.SetState(2542)
			p.ArrayInitializer()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2544)
			p.Match(Java8ParserNEW)
		}
		{
			p.SetState(2545)
			p.ClassOrInterfaceType()
		}
		{
			p.SetState(2546)
			p.Dims()
		}
		{
			p.SetState(2547)
			p.ArrayInitializer()
		}

	}

	return localctx
}

// IDimExprsContext is an interface to support dynamic dispatch.
type IDimExprsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDimExprsContext differentiates from other interfaces.
	IsDimExprsContext()
}

type DimExprsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDimExprsContext() *DimExprsContext {
	var p = new(DimExprsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_dimExprs
	return p
}

func (*DimExprsContext) IsDimExprsContext() {}

func NewDimExprsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DimExprsContext {
	var p = new(DimExprsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_dimExprs

	return p
}

func (s *DimExprsContext) GetParser() antlr.Parser { return s.parser }

func (s *DimExprsContext) AllDimExpr() []IDimExprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDimExprContext)(nil)).Elem())
	var tst = make([]IDimExprContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IDimExprContext)
		}
	}

	return tst
}

func (s *DimExprsContext) DimExpr(i int) IDimExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDimExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDimExprContext)
}

func (s *DimExprsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DimExprsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DimExprsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterDimExprs(s)
	}
}

func (s *DimExprsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitDimExprs(s)
	}
}

func (p *Java8Parser) DimExprs() (localctx IDimExprsContext) {
	this := p
	_ = this

	localctx = NewDimExprsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 406, Java8ParserRULE_dimExprs)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2551)
		p.DimExpr()
	}
	p.SetState(2555)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 289, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(2552)
				p.DimExpr()
			}

		}
		p.SetState(2557)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 289, p.GetParserRuleContext())
	}

	return localctx
}

// IDimExprContext is an interface to support dynamic dispatch.
type IDimExprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDimExprContext differentiates from other interfaces.
	IsDimExprContext()
}

type DimExprContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDimExprContext() *DimExprContext {
	var p = new(DimExprContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_dimExpr
	return p
}

func (*DimExprContext) IsDimExprContext() {}

func NewDimExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DimExprContext {
	var p = new(DimExprContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_dimExpr

	return p
}

func (s *DimExprContext) GetParser() antlr.Parser { return s.parser }

func (s *DimExprContext) LBRACK() antlr.TerminalNode {
	return s.GetToken(Java8ParserLBRACK, 0)
}

func (s *DimExprContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *DimExprContext) RBRACK() antlr.TerminalNode {
	return s.GetToken(Java8ParserRBRACK, 0)
}

func (s *DimExprContext) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAnnotationContext)
		}
	}

	return tst
}

func (s *DimExprContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *DimExprContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DimExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DimExprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterDimExpr(s)
	}
}

func (s *DimExprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitDimExpr(s)
	}
}

func (p *Java8Parser) DimExpr() (localctx IDimExprContext) {
	this := p
	_ = this

	localctx = NewDimExprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 408, Java8ParserRULE_dimExpr)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2561)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserAT {
		{
			p.SetState(2558)
			p.Annotation()
		}

		p.SetState(2563)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(2564)
		p.Match(Java8ParserLBRACK)
	}
	{
		p.SetState(2565)
		p.Expression()
	}
	{
		p.SetState(2566)
		p.Match(Java8ParserRBRACK)
	}

	return localctx
}

// IConstantExpressionContext is an interface to support dynamic dispatch.
type IConstantExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConstantExpressionContext differentiates from other interfaces.
	IsConstantExpressionContext()
}

type ConstantExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstantExpressionContext() *ConstantExpressionContext {
	var p = new(ConstantExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_constantExpression
	return p
}

func (*ConstantExpressionContext) IsConstantExpressionContext() {}

func NewConstantExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantExpressionContext {
	var p = new(ConstantExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_constantExpression

	return p
}

func (s *ConstantExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstantExpressionContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ConstantExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstantExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstantExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterConstantExpression(s)
	}
}

func (s *ConstantExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitConstantExpression(s)
	}
}

func (p *Java8Parser) ConstantExpression() (localctx IConstantExpressionContext) {
	this := p
	_ = this

	localctx = NewConstantExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 410, Java8ParserRULE_constantExpression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2568)
		p.Expression()
	}

	return localctx
}

// IExpressionContext is an interface to support dynamic dispatch.
type IExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExpressionContext differentiates from other interfaces.
	IsExpressionContext()
}

type ExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExpressionContext() *ExpressionContext {
	var p = new(ExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_expression
	return p
}

func (*ExpressionContext) IsExpressionContext() {}

func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext {
	var p = new(ExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_expression

	return p
}

func (s *ExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *ExpressionContext) LambdaExpression() ILambdaExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILambdaExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILambdaExpressionContext)
}

func (s *ExpressionContext) AssignmentExpression() IAssignmentExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentExpressionContext)
}

func (s *ExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterExpression(s)
	}
}

func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitExpression(s)
	}
}

func (p *Java8Parser) Expression() (localctx IExpressionContext) {
	this := p
	_ = this

	localctx = NewExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 412, Java8ParserRULE_expression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2572)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 291, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2570)
			p.LambdaExpression()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2571)
			p.AssignmentExpression()
		}

	}

	return localctx
}

// ILambdaExpressionContext is an interface to support dynamic dispatch.
type ILambdaExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLambdaExpressionContext differentiates from other interfaces.
	IsLambdaExpressionContext()
}

type LambdaExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLambdaExpressionContext() *LambdaExpressionContext {
	var p = new(LambdaExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_lambdaExpression
	return p
}

func (*LambdaExpressionContext) IsLambdaExpressionContext() {}

func NewLambdaExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LambdaExpressionContext {
	var p = new(LambdaExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_lambdaExpression

	return p
}

func (s *LambdaExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *LambdaExpressionContext) LambdaParameters() ILambdaParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILambdaParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILambdaParametersContext)
}

func (s *LambdaExpressionContext) ARROW() antlr.TerminalNode {
	return s.GetToken(Java8ParserARROW, 0)
}

func (s *LambdaExpressionContext) LambdaBody() ILambdaBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILambdaBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILambdaBodyContext)
}

func (s *LambdaExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LambdaExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LambdaExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterLambdaExpression(s)
	}
}

func (s *LambdaExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitLambdaExpression(s)
	}
}

func (p *Java8Parser) LambdaExpression() (localctx ILambdaExpressionContext) {
	this := p
	_ = this

	localctx = NewLambdaExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 414, Java8ParserRULE_lambdaExpression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2574)
		p.LambdaParameters()
	}
	{
		p.SetState(2575)
		p.Match(Java8ParserARROW)
	}
	{
		p.SetState(2576)
		p.LambdaBody()
	}

	return localctx
}

// ILambdaParametersContext is an interface to support dynamic dispatch.
type ILambdaParametersContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLambdaParametersContext differentiates from other interfaces.
	IsLambdaParametersContext()
}

type LambdaParametersContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLambdaParametersContext() *LambdaParametersContext {
	var p = new(LambdaParametersContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_lambdaParameters
	return p
}

func (*LambdaParametersContext) IsLambdaParametersContext() {}

func NewLambdaParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LambdaParametersContext {
	var p = new(LambdaParametersContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_lambdaParameters

	return p
}

func (s *LambdaParametersContext) GetParser() antlr.Parser { return s.parser }

func (s *LambdaParametersContext) Identifier() antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, 0)
}

func (s *LambdaParametersContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *LambdaParametersContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *LambdaParametersContext) FormalParameterList() IFormalParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterListContext)
}

func (s *LambdaParametersContext) InferredFormalParameterList() IInferredFormalParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInferredFormalParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInferredFormalParameterListContext)
}

func (s *LambdaParametersContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LambdaParametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LambdaParametersContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterLambdaParameters(s)
	}
}

func (s *LambdaParametersContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitLambdaParameters(s)
	}
}

func (p *Java8Parser) LambdaParameters() (localctx ILambdaParametersContext) {
	this := p
	_ = this

	localctx = NewLambdaParametersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 416, Java8ParserRULE_lambdaParameters)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2588)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 293, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2578)
			p.Match(Java8ParserIdentifier)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2579)
			p.Match(Java8ParserLPAREN)
		}
		p.SetState(2581)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<Java8ParserBOOLEAN)|(1<<Java8ParserBYTE)|(1<<Java8ParserCHAR)|(1<<Java8ParserDOUBLE)|(1<<Java8ParserFINAL)|(1<<Java8ParserFLOAT)|(1<<Java8ParserINT)|(1<<Java8ParserLONG))) != 0) || _la == Java8ParserSHORT || _la == Java8ParserIdentifier || _la == Java8ParserAT {
			{
				p.SetState(2580)
				p.FormalParameterList()
			}

		}
		{
			p.SetState(2583)
			p.Match(Java8ParserRPAREN)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2584)
			p.Match(Java8ParserLPAREN)
		}
		{
			p.SetState(2585)
			p.InferredFormalParameterList()
		}
		{
			p.SetState(2586)
			p.Match(Java8ParserRPAREN)
		}

	}

	return localctx
}

// IInferredFormalParameterListContext is an interface to support dynamic dispatch.
type IInferredFormalParameterListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInferredFormalParameterListContext differentiates from other interfaces.
	IsInferredFormalParameterListContext()
}

type InferredFormalParameterListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInferredFormalParameterListContext() *InferredFormalParameterListContext {
	var p = new(InferredFormalParameterListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_inferredFormalParameterList
	return p
}

func (*InferredFormalParameterListContext) IsInferredFormalParameterListContext() {}

func NewInferredFormalParameterListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InferredFormalParameterListContext {
	var p = new(InferredFormalParameterListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_inferredFormalParameterList

	return p
}

func (s *InferredFormalParameterListContext) GetParser() antlr.Parser { return s.parser }

func (s *InferredFormalParameterListContext) AllIdentifier() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserIdentifier)
}

func (s *InferredFormalParameterListContext) Identifier(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserIdentifier, i)
}

func (s *InferredFormalParameterListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserCOMMA)
}

func (s *InferredFormalParameterListContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserCOMMA, i)
}

func (s *InferredFormalParameterListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InferredFormalParameterListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InferredFormalParameterListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterInferredFormalParameterList(s)
	}
}

func (s *InferredFormalParameterListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitInferredFormalParameterList(s)
	}
}

func (p *Java8Parser) InferredFormalParameterList() (localctx IInferredFormalParameterListContext) {
	this := p
	_ = this

	localctx = NewInferredFormalParameterListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 418, Java8ParserRULE_inferredFormalParameterList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2590)
		p.Match(Java8ParserIdentifier)
	}
	p.SetState(2595)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == Java8ParserCOMMA {
		{
			p.SetState(2591)
			p.Match(Java8ParserCOMMA)
		}
		{
			p.SetState(2592)
			p.Match(Java8ParserIdentifier)
		}

		p.SetState(2597)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// ILambdaBodyContext is an interface to support dynamic dispatch.
type ILambdaBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLambdaBodyContext differentiates from other interfaces.
	IsLambdaBodyContext()
}

type LambdaBodyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLambdaBodyContext() *LambdaBodyContext {
	var p = new(LambdaBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_lambdaBody
	return p
}

func (*LambdaBodyContext) IsLambdaBodyContext() {}

func NewLambdaBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LambdaBodyContext {
	var p = new(LambdaBodyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_lambdaBody

	return p
}

func (s *LambdaBodyContext) GetParser() antlr.Parser { return s.parser }

func (s *LambdaBodyContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *LambdaBodyContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *LambdaBodyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LambdaBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LambdaBodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterLambdaBody(s)
	}
}

func (s *LambdaBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitLambdaBody(s)
	}
}

func (p *Java8Parser) LambdaBody() (localctx ILambdaBodyContext) {
	this := p
	_ = this

	localctx = NewLambdaBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 420, Java8ParserRULE_lambdaBody)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2600)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserBOOLEAN, Java8ParserBYTE, Java8ParserCHAR, Java8ParserDOUBLE, Java8ParserFLOAT, Java8ParserINT, Java8ParserLONG, Java8ParserNEW, Java8ParserSHORT, Java8ParserSUPER, Java8ParserTHIS, Java8ParserVOID, Java8ParserIntegerLiteral, Java8ParserFloatingPointLiteral, Java8ParserBooleanLiteral, Java8ParserCharacterLiteral, Java8ParserStringLiteral, Java8ParserNullLiteral, Java8ParserLPAREN, Java8ParserBANG, Java8ParserTILDE, Java8ParserINC, Java8ParserDEC, Java8ParserADD, Java8ParserSUB, Java8ParserIdentifier, Java8ParserAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2598)
			p.Expression()
		}

	case Java8ParserLBRACE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2599)
			p.Block()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IAssignmentExpressionContext is an interface to support dynamic dispatch.
type IAssignmentExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssignmentExpressionContext differentiates from other interfaces.
	IsAssignmentExpressionContext()
}

type AssignmentExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssignmentExpressionContext() *AssignmentExpressionContext {
	var p = new(AssignmentExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_assignmentExpression
	return p
}

func (*AssignmentExpressionContext) IsAssignmentExpressionContext() {}

func NewAssignmentExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentExpressionContext {
	var p = new(AssignmentExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_assignmentExpression

	return p
}

func (s *AssignmentExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *AssignmentExpressionContext) ConditionalExpression() IConditionalExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConditionalExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConditionalExpressionContext)
}

func (s *AssignmentExpressionContext) Assignment() IAssignmentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentContext)
}

func (s *AssignmentExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssignmentExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssignmentExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterAssignmentExpression(s)
	}
}

func (s *AssignmentExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitAssignmentExpression(s)
	}
}

func (p *Java8Parser) AssignmentExpression() (localctx IAssignmentExpressionContext) {
	this := p
	_ = this

	localctx = NewAssignmentExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 422, Java8ParserRULE_assignmentExpression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2604)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 296, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2602)
			p.ConditionalExpression()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2603)
			p.Assignment()
		}

	}

	return localctx
}

// IAssignmentContext is an interface to support dynamic dispatch.
type IAssignmentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssignmentContext differentiates from other interfaces.
	IsAssignmentContext()
}

type AssignmentContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssignmentContext() *AssignmentContext {
	var p = new(AssignmentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_assignment
	return p
}

func (*AssignmentContext) IsAssignmentContext() {}

func NewAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentContext {
	var p = new(AssignmentContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_assignment

	return p
}

func (s *AssignmentContext) GetParser() antlr.Parser { return s.parser }

func (s *AssignmentContext) LeftHandSide() ILeftHandSideContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILeftHandSideContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILeftHandSideContext)
}

func (s *AssignmentContext) AssignmentOperator() IAssignmentOperatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentOperatorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentOperatorContext)
}

func (s *AssignmentContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *AssignmentContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssignmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssignmentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterAssignment(s)
	}
}

func (s *AssignmentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitAssignment(s)
	}
}

func (p *Java8Parser) Assignment() (localctx IAssignmentContext) {
	this := p
	_ = this

	localctx = NewAssignmentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 424, Java8ParserRULE_assignment)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2606)
		p.LeftHandSide()
	}
	{
		p.SetState(2607)
		p.AssignmentOperator()
	}
	{
		p.SetState(2608)
		p.Expression()
	}

	return localctx
}

// ILeftHandSideContext is an interface to support dynamic dispatch.
type ILeftHandSideContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLeftHandSideContext differentiates from other interfaces.
	IsLeftHandSideContext()
}

type LeftHandSideContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLeftHandSideContext() *LeftHandSideContext {
	var p = new(LeftHandSideContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_leftHandSide
	return p
}

func (*LeftHandSideContext) IsLeftHandSideContext() {}

func NewLeftHandSideContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LeftHandSideContext {
	var p = new(LeftHandSideContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_leftHandSide

	return p
}

func (s *LeftHandSideContext) GetParser() antlr.Parser { return s.parser }

func (s *LeftHandSideContext) ExpressionName() IExpressionNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionNameContext)
}

func (s *LeftHandSideContext) FieldAccess() IFieldAccessContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFieldAccessContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFieldAccessContext)
}

func (s *LeftHandSideContext) ArrayAccess() IArrayAccessContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayAccessContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayAccessContext)
}

func (s *LeftHandSideContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LeftHandSideContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LeftHandSideContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterLeftHandSide(s)
	}
}

func (s *LeftHandSideContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitLeftHandSide(s)
	}
}

func (p *Java8Parser) LeftHandSide() (localctx ILeftHandSideContext) {
	this := p
	_ = this

	localctx = NewLeftHandSideContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 426, Java8ParserRULE_leftHandSide)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2613)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 297, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2610)
			p.ExpressionName()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2611)
			p.FieldAccess()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2612)
			p.ArrayAccess()
		}

	}

	return localctx
}

// IAssignmentOperatorContext is an interface to support dynamic dispatch.
type IAssignmentOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssignmentOperatorContext differentiates from other interfaces.
	IsAssignmentOperatorContext()
}

type AssignmentOperatorContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssignmentOperatorContext() *AssignmentOperatorContext {
	var p = new(AssignmentOperatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_assignmentOperator
	return p
}

func (*AssignmentOperatorContext) IsAssignmentOperatorContext() {}

func NewAssignmentOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentOperatorContext {
	var p = new(AssignmentOperatorContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_assignmentOperator

	return p
}

func (s *AssignmentOperatorContext) GetParser() antlr.Parser { return s.parser }

func (s *AssignmentOperatorContext) ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserASSIGN, 0)
}

func (s *AssignmentOperatorContext) MUL_ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserMUL_ASSIGN, 0)
}

func (s *AssignmentOperatorContext) DIV_ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserDIV_ASSIGN, 0)
}

func (s *AssignmentOperatorContext) MOD_ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserMOD_ASSIGN, 0)
}

func (s *AssignmentOperatorContext) ADD_ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserADD_ASSIGN, 0)
}

func (s *AssignmentOperatorContext) SUB_ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserSUB_ASSIGN, 0)
}

func (s *AssignmentOperatorContext) LSHIFT_ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLSHIFT_ASSIGN, 0)
}

func (s *AssignmentOperatorContext) RSHIFT_ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRSHIFT_ASSIGN, 0)
}

func (s *AssignmentOperatorContext) URSHIFT_ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserURSHIFT_ASSIGN, 0)
}

func (s *AssignmentOperatorContext) AND_ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserAND_ASSIGN, 0)
}

func (s *AssignmentOperatorContext) XOR_ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserXOR_ASSIGN, 0)
}

func (s *AssignmentOperatorContext) OR_ASSIGN() antlr.TerminalNode {
	return s.GetToken(Java8ParserOR_ASSIGN, 0)
}

func (s *AssignmentOperatorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssignmentOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssignmentOperatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterAssignmentOperator(s)
	}
}

func (s *AssignmentOperatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitAssignmentOperator(s)
	}
}

func (p *Java8Parser) AssignmentOperator() (localctx IAssignmentOperatorContext) {
	this := p
	_ = this

	localctx = NewAssignmentOperatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 428, Java8ParserRULE_assignmentOperator)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2615)
		_la = p.GetTokenStream().LA(1)

		if !((((_la-66)&-(0x1f+1)) == 0 && ((1<<uint((_la-66)))&((1<<(Java8ParserASSIGN-66))|(1<<(Java8ParserADD_ASSIGN-66))|(1<<(Java8ParserSUB_ASSIGN-66))|(1<<(Java8ParserMUL_ASSIGN-66))|(1<<(Java8ParserDIV_ASSIGN-66))|(1<<(Java8ParserAND_ASSIGN-66))|(1<<(Java8ParserOR_ASSIGN-66))|(1<<(Java8ParserXOR_ASSIGN-66)))) != 0) || (((_la-98)&-(0x1f+1)) == 0 && ((1<<uint((_la-98)))&((1<<(Java8ParserMOD_ASSIGN-98))|(1<<(Java8ParserLSHIFT_ASSIGN-98))|(1<<(Java8ParserRSHIFT_ASSIGN-98))|(1<<(Java8ParserURSHIFT_ASSIGN-98)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IConditionalExpressionContext is an interface to support dynamic dispatch.
type IConditionalExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConditionalExpressionContext differentiates from other interfaces.
	IsConditionalExpressionContext()
}

type ConditionalExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConditionalExpressionContext() *ConditionalExpressionContext {
	var p = new(ConditionalExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_conditionalExpression
	return p
}

func (*ConditionalExpressionContext) IsConditionalExpressionContext() {}

func NewConditionalExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionalExpressionContext {
	var p = new(ConditionalExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_conditionalExpression

	return p
}

func (s *ConditionalExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *ConditionalExpressionContext) ConditionalOrExpression() IConditionalOrExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConditionalOrExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConditionalOrExpressionContext)
}

func (s *ConditionalExpressionContext) QUESTION() antlr.TerminalNode {
	return s.GetToken(Java8ParserQUESTION, 0)
}

func (s *ConditionalExpressionContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ConditionalExpressionContext) COLON() antlr.TerminalNode {
	return s.GetToken(Java8ParserCOLON, 0)
}

func (s *ConditionalExpressionContext) ConditionalExpression() IConditionalExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConditionalExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConditionalExpressionContext)
}

func (s *ConditionalExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConditionalExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConditionalExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterConditionalExpression(s)
	}
}

func (s *ConditionalExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitConditionalExpression(s)
	}
}

func (p *Java8Parser) ConditionalExpression() (localctx IConditionalExpressionContext) {
	this := p
	_ = this

	localctx = NewConditionalExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 430, Java8ParserRULE_conditionalExpression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2624)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 298, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2617)
			p.conditionalOrExpression(0)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2618)
			p.conditionalOrExpression(0)
		}
		{
			p.SetState(2619)
			p.Match(Java8ParserQUESTION)
		}
		{
			p.SetState(2620)
			p.Expression()
		}
		{
			p.SetState(2621)
			p.Match(Java8ParserCOLON)
		}
		{
			p.SetState(2622)
			p.ConditionalExpression()
		}

	}

	return localctx
}

// IConditionalOrExpressionContext is an interface to support dynamic dispatch.
type IConditionalOrExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConditionalOrExpressionContext differentiates from other interfaces.
	IsConditionalOrExpressionContext()
}

type ConditionalOrExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConditionalOrExpressionContext() *ConditionalOrExpressionContext {
	var p = new(ConditionalOrExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_conditionalOrExpression
	return p
}

func (*ConditionalOrExpressionContext) IsConditionalOrExpressionContext() {}

func NewConditionalOrExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionalOrExpressionContext {
	var p = new(ConditionalOrExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_conditionalOrExpression

	return p
}

func (s *ConditionalOrExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *ConditionalOrExpressionContext) ConditionalAndExpression() IConditionalAndExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConditionalAndExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConditionalAndExpressionContext)
}

func (s *ConditionalOrExpressionContext) ConditionalOrExpression() IConditionalOrExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConditionalOrExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConditionalOrExpressionContext)
}

func (s *ConditionalOrExpressionContext) OR() antlr.TerminalNode {
	return s.GetToken(Java8ParserOR, 0)
}

func (s *ConditionalOrExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConditionalOrExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConditionalOrExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterConditionalOrExpression(s)
	}
}

func (s *ConditionalOrExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitConditionalOrExpression(s)
	}
}

func (p *Java8Parser) ConditionalOrExpression() (localctx IConditionalOrExpressionContext) {
	return p.conditionalOrExpression(0)
}

func (p *Java8Parser) conditionalOrExpression(_p int) (localctx IConditionalOrExpressionContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewConditionalOrExpressionContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IConditionalOrExpressionContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 432
	p.EnterRecursionRule(localctx, 432, Java8ParserRULE_conditionalOrExpression, _p)

	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2627)
		p.conditionalAndExpression(0)
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(2634)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 299, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			localctx = NewConditionalOrExpressionContext(p, _parentctx, _parentState)
			p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_conditionalOrExpression)
			p.SetState(2629)

			if !(p.Precpred(p.GetParserRuleContext(), 1)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
			}
			{
				p.SetState(2630)
				p.Match(Java8ParserOR)
			}
			{
				p.SetState(2631)
				p.conditionalAndExpression(0)
			}

		}
		p.SetState(2636)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 299, p.GetParserRuleContext())
	}

	return localctx
}

// IConditionalAndExpressionContext is an interface to support dynamic dispatch.
type IConditionalAndExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConditionalAndExpressionContext differentiates from other interfaces.
	IsConditionalAndExpressionContext()
}

type ConditionalAndExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConditionalAndExpressionContext() *ConditionalAndExpressionContext {
	var p = new(ConditionalAndExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_conditionalAndExpression
	return p
}

func (*ConditionalAndExpressionContext) IsConditionalAndExpressionContext() {}

func NewConditionalAndExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionalAndExpressionContext {
	var p = new(ConditionalAndExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_conditionalAndExpression

	return p
}

func (s *ConditionalAndExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *ConditionalAndExpressionContext) InclusiveOrExpression() IInclusiveOrExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInclusiveOrExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInclusiveOrExpressionContext)
}

func (s *ConditionalAndExpressionContext) ConditionalAndExpression() IConditionalAndExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConditionalAndExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConditionalAndExpressionContext)
}

func (s *ConditionalAndExpressionContext) AND() antlr.TerminalNode {
	return s.GetToken(Java8ParserAND, 0)
}

func (s *ConditionalAndExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConditionalAndExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConditionalAndExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterConditionalAndExpression(s)
	}
}

func (s *ConditionalAndExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitConditionalAndExpression(s)
	}
}

func (p *Java8Parser) ConditionalAndExpression() (localctx IConditionalAndExpressionContext) {
	return p.conditionalAndExpression(0)
}

func (p *Java8Parser) conditionalAndExpression(_p int) (localctx IConditionalAndExpressionContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewConditionalAndExpressionContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IConditionalAndExpressionContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 434
	p.EnterRecursionRule(localctx, 434, Java8ParserRULE_conditionalAndExpression, _p)

	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2638)
		p.inclusiveOrExpression(0)
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(2645)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 300, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			localctx = NewConditionalAndExpressionContext(p, _parentctx, _parentState)
			p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_conditionalAndExpression)
			p.SetState(2640)

			if !(p.Precpred(p.GetParserRuleContext(), 1)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
			}
			{
				p.SetState(2641)
				p.Match(Java8ParserAND)
			}
			{
				p.SetState(2642)
				p.inclusiveOrExpression(0)
			}

		}
		p.SetState(2647)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 300, p.GetParserRuleContext())
	}

	return localctx
}

// IInclusiveOrExpressionContext is an interface to support dynamic dispatch.
type IInclusiveOrExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInclusiveOrExpressionContext differentiates from other interfaces.
	IsInclusiveOrExpressionContext()
}

type InclusiveOrExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInclusiveOrExpressionContext() *InclusiveOrExpressionContext {
	var p = new(InclusiveOrExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_inclusiveOrExpression
	return p
}

func (*InclusiveOrExpressionContext) IsInclusiveOrExpressionContext() {}

func NewInclusiveOrExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InclusiveOrExpressionContext {
	var p = new(InclusiveOrExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_inclusiveOrExpression

	return p
}

func (s *InclusiveOrExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *InclusiveOrExpressionContext) ExclusiveOrExpression() IExclusiveOrExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExclusiveOrExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExclusiveOrExpressionContext)
}

func (s *InclusiveOrExpressionContext) InclusiveOrExpression() IInclusiveOrExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInclusiveOrExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInclusiveOrExpressionContext)
}

func (s *InclusiveOrExpressionContext) BITOR() antlr.TerminalNode {
	return s.GetToken(Java8ParserBITOR, 0)
}

func (s *InclusiveOrExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InclusiveOrExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InclusiveOrExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterInclusiveOrExpression(s)
	}
}

func (s *InclusiveOrExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitInclusiveOrExpression(s)
	}
}

func (p *Java8Parser) InclusiveOrExpression() (localctx IInclusiveOrExpressionContext) {
	return p.inclusiveOrExpression(0)
}

func (p *Java8Parser) inclusiveOrExpression(_p int) (localctx IInclusiveOrExpressionContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewInclusiveOrExpressionContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IInclusiveOrExpressionContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 436
	p.EnterRecursionRule(localctx, 436, Java8ParserRULE_inclusiveOrExpression, _p)

	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2649)
		p.exclusiveOrExpression(0)
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(2656)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 301, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			localctx = NewInclusiveOrExpressionContext(p, _parentctx, _parentState)
			p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_inclusiveOrExpression)
			p.SetState(2651)

			if !(p.Precpred(p.GetParserRuleContext(), 1)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
			}
			{
				p.SetState(2652)
				p.Match(Java8ParserBITOR)
			}
			{
				p.SetState(2653)
				p.exclusiveOrExpression(0)
			}

		}
		p.SetState(2658)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 301, p.GetParserRuleContext())
	}

	return localctx
}

// IExclusiveOrExpressionContext is an interface to support dynamic dispatch.
type IExclusiveOrExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExclusiveOrExpressionContext differentiates from other interfaces.
	IsExclusiveOrExpressionContext()
}

type ExclusiveOrExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExclusiveOrExpressionContext() *ExclusiveOrExpressionContext {
	var p = new(ExclusiveOrExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_exclusiveOrExpression
	return p
}

func (*ExclusiveOrExpressionContext) IsExclusiveOrExpressionContext() {}

func NewExclusiveOrExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExclusiveOrExpressionContext {
	var p = new(ExclusiveOrExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_exclusiveOrExpression

	return p
}

func (s *ExclusiveOrExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *ExclusiveOrExpressionContext) AndExpression() IAndExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAndExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAndExpressionContext)
}

func (s *ExclusiveOrExpressionContext) ExclusiveOrExpression() IExclusiveOrExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExclusiveOrExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExclusiveOrExpressionContext)
}

func (s *ExclusiveOrExpressionContext) CARET() antlr.TerminalNode {
	return s.GetToken(Java8ParserCARET, 0)
}

func (s *ExclusiveOrExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExclusiveOrExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExclusiveOrExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterExclusiveOrExpression(s)
	}
}

func (s *ExclusiveOrExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitExclusiveOrExpression(s)
	}
}

func (p *Java8Parser) ExclusiveOrExpression() (localctx IExclusiveOrExpressionContext) {
	return p.exclusiveOrExpression(0)
}

func (p *Java8Parser) exclusiveOrExpression(_p int) (localctx IExclusiveOrExpressionContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewExclusiveOrExpressionContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IExclusiveOrExpressionContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 438
	p.EnterRecursionRule(localctx, 438, Java8ParserRULE_exclusiveOrExpression, _p)

	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2660)
		p.andExpression(0)
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(2667)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 302, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			localctx = NewExclusiveOrExpressionContext(p, _parentctx, _parentState)
			p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_exclusiveOrExpression)
			p.SetState(2662)

			if !(p.Precpred(p.GetParserRuleContext(), 1)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
			}
			{
				p.SetState(2663)
				p.Match(Java8ParserCARET)
			}
			{
				p.SetState(2664)
				p.andExpression(0)
			}

		}
		p.SetState(2669)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 302, p.GetParserRuleContext())
	}

	return localctx
}

// IAndExpressionContext is an interface to support dynamic dispatch.
type IAndExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAndExpressionContext differentiates from other interfaces.
	IsAndExpressionContext()
}

type AndExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAndExpressionContext() *AndExpressionContext {
	var p = new(AndExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_andExpression
	return p
}

func (*AndExpressionContext) IsAndExpressionContext() {}

func NewAndExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AndExpressionContext {
	var p = new(AndExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_andExpression

	return p
}

func (s *AndExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *AndExpressionContext) EqualityExpression() IEqualityExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEqualityExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEqualityExpressionContext)
}

func (s *AndExpressionContext) AndExpression() IAndExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAndExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAndExpressionContext)
}

func (s *AndExpressionContext) BITAND() antlr.TerminalNode {
	return s.GetToken(Java8ParserBITAND, 0)
}

func (s *AndExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AndExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AndExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterAndExpression(s)
	}
}

func (s *AndExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitAndExpression(s)
	}
}

func (p *Java8Parser) AndExpression() (localctx IAndExpressionContext) {
	return p.andExpression(0)
}

func (p *Java8Parser) andExpression(_p int) (localctx IAndExpressionContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewAndExpressionContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IAndExpressionContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 440
	p.EnterRecursionRule(localctx, 440, Java8ParserRULE_andExpression, _p)

	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2671)
		p.equalityExpression(0)
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(2678)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 303, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			localctx = NewAndExpressionContext(p, _parentctx, _parentState)
			p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_andExpression)
			p.SetState(2673)

			if !(p.Precpred(p.GetParserRuleContext(), 1)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
			}
			{
				p.SetState(2674)
				p.Match(Java8ParserBITAND)
			}
			{
				p.SetState(2675)
				p.equalityExpression(0)
			}

		}
		p.SetState(2680)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 303, p.GetParserRuleContext())
	}

	return localctx
}

// IEqualityExpressionContext is an interface to support dynamic dispatch.
type IEqualityExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEqualityExpressionContext differentiates from other interfaces.
	IsEqualityExpressionContext()
}

type EqualityExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEqualityExpressionContext() *EqualityExpressionContext {
	var p = new(EqualityExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_equalityExpression
	return p
}

func (*EqualityExpressionContext) IsEqualityExpressionContext() {}

func NewEqualityExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EqualityExpressionContext {
	var p = new(EqualityExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_equalityExpression

	return p
}

func (s *EqualityExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *EqualityExpressionContext) RelationalExpression() IRelationalExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRelationalExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRelationalExpressionContext)
}

func (s *EqualityExpressionContext) EqualityExpression() IEqualityExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEqualityExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEqualityExpressionContext)
}

func (s *EqualityExpressionContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(Java8ParserEQUAL, 0)
}

func (s *EqualityExpressionContext) NOTEQUAL() antlr.TerminalNode {
	return s.GetToken(Java8ParserNOTEQUAL, 0)
}

func (s *EqualityExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EqualityExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EqualityExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterEqualityExpression(s)
	}
}

func (s *EqualityExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitEqualityExpression(s)
	}
}

func (p *Java8Parser) EqualityExpression() (localctx IEqualityExpressionContext) {
	return p.equalityExpression(0)
}

func (p *Java8Parser) equalityExpression(_p int) (localctx IEqualityExpressionContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewEqualityExpressionContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IEqualityExpressionContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 442
	p.EnterRecursionRule(localctx, 442, Java8ParserRULE_equalityExpression, _p)

	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2682)
		p.relationalExpression(0)
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(2692)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 305, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(2690)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 304, p.GetParserRuleContext()) {
			case 1:
				localctx = NewEqualityExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_equalityExpression)
				p.SetState(2684)

				if !(p.Precpred(p.GetParserRuleContext(), 2)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
				}
				{
					p.SetState(2685)
					p.Match(Java8ParserEQUAL)
				}
				{
					p.SetState(2686)
					p.relationalExpression(0)
				}

			case 2:
				localctx = NewEqualityExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_equalityExpression)
				p.SetState(2687)

				if !(p.Precpred(p.GetParserRuleContext(), 1)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
				}
				{
					p.SetState(2688)
					p.Match(Java8ParserNOTEQUAL)
				}
				{
					p.SetState(2689)
					p.relationalExpression(0)
				}

			}

		}
		p.SetState(2694)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 305, p.GetParserRuleContext())
	}

	return localctx
}

// IRelationalExpressionContext is an interface to support dynamic dispatch.
type IRelationalExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRelationalExpressionContext differentiates from other interfaces.
	IsRelationalExpressionContext()
}

type RelationalExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRelationalExpressionContext() *RelationalExpressionContext {
	var p = new(RelationalExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_relationalExpression
	return p
}

func (*RelationalExpressionContext) IsRelationalExpressionContext() {}

func NewRelationalExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationalExpressionContext {
	var p = new(RelationalExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_relationalExpression

	return p
}

func (s *RelationalExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *RelationalExpressionContext) ShiftExpression() IShiftExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IShiftExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IShiftExpressionContext)
}

func (s *RelationalExpressionContext) RelationalExpression() IRelationalExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRelationalExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRelationalExpressionContext)
}

func (s *RelationalExpressionContext) LT() antlr.TerminalNode {
	return s.GetToken(Java8ParserLT, 0)
}

func (s *RelationalExpressionContext) GT() antlr.TerminalNode {
	return s.GetToken(Java8ParserGT, 0)
}

func (s *RelationalExpressionContext) LE() antlr.TerminalNode {
	return s.GetToken(Java8ParserLE, 0)
}

func (s *RelationalExpressionContext) GE() antlr.TerminalNode {
	return s.GetToken(Java8ParserGE, 0)
}

func (s *RelationalExpressionContext) INSTANCEOF() antlr.TerminalNode {
	return s.GetToken(Java8ParserINSTANCEOF, 0)
}

func (s *RelationalExpressionContext) ReferenceType() IReferenceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReferenceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReferenceTypeContext)
}

func (s *RelationalExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RelationalExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RelationalExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterRelationalExpression(s)
	}
}

func (s *RelationalExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitRelationalExpression(s)
	}
}

func (p *Java8Parser) RelationalExpression() (localctx IRelationalExpressionContext) {
	return p.relationalExpression(0)
}

func (p *Java8Parser) relationalExpression(_p int) (localctx IRelationalExpressionContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewRelationalExpressionContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IRelationalExpressionContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 444
	p.EnterRecursionRule(localctx, 444, Java8ParserRULE_relationalExpression, _p)

	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2696)
		p.shiftExpression(0)
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(2715)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 307, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(2713)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 306, p.GetParserRuleContext()) {
			case 1:
				localctx = NewRelationalExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_relationalExpression)
				p.SetState(2698)

				if !(p.Precpred(p.GetParserRuleContext(), 5)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
				}
				{
					p.SetState(2699)
					p.Match(Java8ParserLT)
				}
				{
					p.SetState(2700)
					p.shiftExpression(0)
				}

			case 2:
				localctx = NewRelationalExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_relationalExpression)
				p.SetState(2701)

				if !(p.Precpred(p.GetParserRuleContext(), 4)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
				}
				{
					p.SetState(2702)
					p.Match(Java8ParserGT)
				}
				{
					p.SetState(2703)
					p.shiftExpression(0)
				}

			case 3:
				localctx = NewRelationalExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_relationalExpression)
				p.SetState(2704)

				if !(p.Precpred(p.GetParserRuleContext(), 3)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
				}
				{
					p.SetState(2705)
					p.Match(Java8ParserLE)
				}
				{
					p.SetState(2706)
					p.shiftExpression(0)
				}

			case 4:
				localctx = NewRelationalExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_relationalExpression)
				p.SetState(2707)

				if !(p.Precpred(p.GetParserRuleContext(), 2)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
				}
				{
					p.SetState(2708)
					p.Match(Java8ParserGE)
				}
				{
					p.SetState(2709)
					p.shiftExpression(0)
				}

			case 5:
				localctx = NewRelationalExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_relationalExpression)
				p.SetState(2710)

				if !(p.Precpred(p.GetParserRuleContext(), 1)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
				}
				{
					p.SetState(2711)
					p.Match(Java8ParserINSTANCEOF)
				}
				{
					p.SetState(2712)
					p.ReferenceType()
				}

			}

		}
		p.SetState(2717)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 307, p.GetParserRuleContext())
	}

	return localctx
}

// IShiftExpressionContext is an interface to support dynamic dispatch.
type IShiftExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsShiftExpressionContext differentiates from other interfaces.
	IsShiftExpressionContext()
}

type ShiftExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyShiftExpressionContext() *ShiftExpressionContext {
	var p = new(ShiftExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_shiftExpression
	return p
}

func (*ShiftExpressionContext) IsShiftExpressionContext() {}

func NewShiftExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShiftExpressionContext {
	var p = new(ShiftExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_shiftExpression

	return p
}

func (s *ShiftExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *ShiftExpressionContext) AdditiveExpression() IAdditiveExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAdditiveExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAdditiveExpressionContext)
}

func (s *ShiftExpressionContext) ShiftExpression() IShiftExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IShiftExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IShiftExpressionContext)
}

func (s *ShiftExpressionContext) AllLT() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserLT)
}

func (s *ShiftExpressionContext) LT(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserLT, i)
}

func (s *ShiftExpressionContext) AllGT() []antlr.TerminalNode {
	return s.GetTokens(Java8ParserGT)
}

func (s *ShiftExpressionContext) GT(i int) antlr.TerminalNode {
	return s.GetToken(Java8ParserGT, i)
}

func (s *ShiftExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ShiftExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ShiftExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterShiftExpression(s)
	}
}

func (s *ShiftExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitShiftExpression(s)
	}
}

func (p *Java8Parser) ShiftExpression() (localctx IShiftExpressionContext) {
	return p.shiftExpression(0)
}

func (p *Java8Parser) shiftExpression(_p int) (localctx IShiftExpressionContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewShiftExpressionContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IShiftExpressionContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 446
	p.EnterRecursionRule(localctx, 446, Java8ParserRULE_shiftExpression, _p)

	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2719)
		p.additiveExpression(0)
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(2736)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 309, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(2734)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 308, p.GetParserRuleContext()) {
			case 1:
				localctx = NewShiftExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_shiftExpression)
				p.SetState(2721)

				if !(p.Precpred(p.GetParserRuleContext(), 3)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
				}
				{
					p.SetState(2722)
					p.Match(Java8ParserLT)
				}
				{
					p.SetState(2723)
					p.Match(Java8ParserLT)
				}
				{
					p.SetState(2724)
					p.additiveExpression(0)
				}

			case 2:
				localctx = NewShiftExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_shiftExpression)
				p.SetState(2725)

				if !(p.Precpred(p.GetParserRuleContext(), 2)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
				}
				{
					p.SetState(2726)
					p.Match(Java8ParserGT)
				}
				{
					p.SetState(2727)
					p.Match(Java8ParserGT)
				}
				{
					p.SetState(2728)
					p.additiveExpression(0)
				}

			case 3:
				localctx = NewShiftExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_shiftExpression)
				p.SetState(2729)

				if !(p.Precpred(p.GetParserRuleContext(), 1)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
				}
				{
					p.SetState(2730)
					p.Match(Java8ParserGT)
				}
				{
					p.SetState(2731)
					p.Match(Java8ParserGT)
				}
				{
					p.SetState(2732)
					p.Match(Java8ParserGT)
				}
				{
					p.SetState(2733)
					p.additiveExpression(0)
				}

			}

		}
		p.SetState(2738)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 309, p.GetParserRuleContext())
	}

	return localctx
}

// IAdditiveExpressionContext is an interface to support dynamic dispatch.
type IAdditiveExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAdditiveExpressionContext differentiates from other interfaces.
	IsAdditiveExpressionContext()
}

type AdditiveExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAdditiveExpressionContext() *AdditiveExpressionContext {
	var p = new(AdditiveExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_additiveExpression
	return p
}

func (*AdditiveExpressionContext) IsAdditiveExpressionContext() {}

func NewAdditiveExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AdditiveExpressionContext {
	var p = new(AdditiveExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_additiveExpression

	return p
}

func (s *AdditiveExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *AdditiveExpressionContext) MultiplicativeExpression() IMultiplicativeExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMultiplicativeExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMultiplicativeExpressionContext)
}

func (s *AdditiveExpressionContext) AdditiveExpression() IAdditiveExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAdditiveExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAdditiveExpressionContext)
}

func (s *AdditiveExpressionContext) ADD() antlr.TerminalNode {
	return s.GetToken(Java8ParserADD, 0)
}

func (s *AdditiveExpressionContext) SUB() antlr.TerminalNode {
	return s.GetToken(Java8ParserSUB, 0)
}

func (s *AdditiveExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AdditiveExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AdditiveExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterAdditiveExpression(s)
	}
}

func (s *AdditiveExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitAdditiveExpression(s)
	}
}

func (p *Java8Parser) AdditiveExpression() (localctx IAdditiveExpressionContext) {
	return p.additiveExpression(0)
}

func (p *Java8Parser) additiveExpression(_p int) (localctx IAdditiveExpressionContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewAdditiveExpressionContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IAdditiveExpressionContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 448
	p.EnterRecursionRule(localctx, 448, Java8ParserRULE_additiveExpression, _p)

	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2740)
		p.multiplicativeExpression(0)
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(2750)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 311, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(2748)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 310, p.GetParserRuleContext()) {
			case 1:
				localctx = NewAdditiveExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_additiveExpression)
				p.SetState(2742)

				if !(p.Precpred(p.GetParserRuleContext(), 2)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
				}
				{
					p.SetState(2743)
					p.Match(Java8ParserADD)
				}
				{
					p.SetState(2744)
					p.multiplicativeExpression(0)
				}

			case 2:
				localctx = NewAdditiveExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_additiveExpression)
				p.SetState(2745)

				if !(p.Precpred(p.GetParserRuleContext(), 1)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
				}
				{
					p.SetState(2746)
					p.Match(Java8ParserSUB)
				}
				{
					p.SetState(2747)
					p.multiplicativeExpression(0)
				}

			}

		}
		p.SetState(2752)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 311, p.GetParserRuleContext())
	}

	return localctx
}

// IMultiplicativeExpressionContext is an interface to support dynamic dispatch.
type IMultiplicativeExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMultiplicativeExpressionContext differentiates from other interfaces.
	IsMultiplicativeExpressionContext()
}

type MultiplicativeExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMultiplicativeExpressionContext() *MultiplicativeExpressionContext {
	var p = new(MultiplicativeExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_multiplicativeExpression
	return p
}

func (*MultiplicativeExpressionContext) IsMultiplicativeExpressionContext() {}

func NewMultiplicativeExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultiplicativeExpressionContext {
	var p = new(MultiplicativeExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_multiplicativeExpression

	return p
}

func (s *MultiplicativeExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *MultiplicativeExpressionContext) UnaryExpression() IUnaryExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryExpressionContext)
}

func (s *MultiplicativeExpressionContext) MultiplicativeExpression() IMultiplicativeExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMultiplicativeExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMultiplicativeExpressionContext)
}

func (s *MultiplicativeExpressionContext) MUL() antlr.TerminalNode {
	return s.GetToken(Java8ParserMUL, 0)
}

func (s *MultiplicativeExpressionContext) DIV() antlr.TerminalNode {
	return s.GetToken(Java8ParserDIV, 0)
}

func (s *MultiplicativeExpressionContext) MOD() antlr.TerminalNode {
	return s.GetToken(Java8ParserMOD, 0)
}

func (s *MultiplicativeExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MultiplicativeExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MultiplicativeExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterMultiplicativeExpression(s)
	}
}

func (s *MultiplicativeExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitMultiplicativeExpression(s)
	}
}

func (p *Java8Parser) MultiplicativeExpression() (localctx IMultiplicativeExpressionContext) {
	return p.multiplicativeExpression(0)
}

func (p *Java8Parser) multiplicativeExpression(_p int) (localctx IMultiplicativeExpressionContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewMultiplicativeExpressionContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IMultiplicativeExpressionContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 450
	p.EnterRecursionRule(localctx, 450, Java8ParserRULE_multiplicativeExpression, _p)

	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2754)
		p.UnaryExpression()
	}

	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(2767)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 313, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(2765)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 312, p.GetParserRuleContext()) {
			case 1:
				localctx = NewMultiplicativeExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_multiplicativeExpression)
				p.SetState(2756)

				if !(p.Precpred(p.GetParserRuleContext(), 3)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
				}
				{
					p.SetState(2757)
					p.Match(Java8ParserMUL)
				}
				{
					p.SetState(2758)
					p.UnaryExpression()
				}

			case 2:
				localctx = NewMultiplicativeExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_multiplicativeExpression)
				p.SetState(2759)

				if !(p.Precpred(p.GetParserRuleContext(), 2)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
				}
				{
					p.SetState(2760)
					p.Match(Java8ParserDIV)
				}
				{
					p.SetState(2761)
					p.UnaryExpression()
				}

			case 3:
				localctx = NewMultiplicativeExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, Java8ParserRULE_multiplicativeExpression)
				p.SetState(2762)

				if !(p.Precpred(p.GetParserRuleContext(), 1)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
				}
				{
					p.SetState(2763)
					p.Match(Java8ParserMOD)
				}
				{
					p.SetState(2764)
					p.UnaryExpression()
				}

			}

		}
		p.SetState(2769)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 313, p.GetParserRuleContext())
	}

	return localctx
}

// IUnaryExpressionContext is an interface to support dynamic dispatch.
type IUnaryExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnaryExpressionContext differentiates from other interfaces.
	IsUnaryExpressionContext()
}

type UnaryExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnaryExpressionContext() *UnaryExpressionContext {
	var p = new(UnaryExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_unaryExpression
	return p
}

func (*UnaryExpressionContext) IsUnaryExpressionContext() {}

func NewUnaryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryExpressionContext {
	var p = new(UnaryExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_unaryExpression

	return p
}

func (s *UnaryExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *UnaryExpressionContext) PreIncrementExpression() IPreIncrementExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPreIncrementExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPreIncrementExpressionContext)
}

func (s *UnaryExpressionContext) PreDecrementExpression() IPreDecrementExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPreDecrementExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPreDecrementExpressionContext)
}

func (s *UnaryExpressionContext) ADD() antlr.TerminalNode {
	return s.GetToken(Java8ParserADD, 0)
}

func (s *UnaryExpressionContext) UnaryExpression() IUnaryExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryExpressionContext)
}

func (s *UnaryExpressionContext) SUB() antlr.TerminalNode {
	return s.GetToken(Java8ParserSUB, 0)
}

func (s *UnaryExpressionContext) UnaryExpressionNotPlusMinus() IUnaryExpressionNotPlusMinusContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryExpressionNotPlusMinusContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryExpressionNotPlusMinusContext)
}

func (s *UnaryExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnaryExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnaryExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterUnaryExpression(s)
	}
}

func (s *UnaryExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitUnaryExpression(s)
	}
}

func (p *Java8Parser) UnaryExpression() (localctx IUnaryExpressionContext) {
	this := p
	_ = this

	localctx = NewUnaryExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 452, Java8ParserRULE_unaryExpression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2777)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case Java8ParserINC:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2770)
			p.PreIncrementExpression()
		}

	case Java8ParserDEC:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2771)
			p.PreDecrementExpression()
		}

	case Java8ParserADD:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2772)
			p.Match(Java8ParserADD)
		}
		{
			p.SetState(2773)
			p.UnaryExpression()
		}

	case Java8ParserSUB:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2774)
			p.Match(Java8ParserSUB)
		}
		{
			p.SetState(2775)
			p.UnaryExpression()
		}

	case Java8ParserBOOLEAN, Java8ParserBYTE, Java8ParserCHAR, Java8ParserDOUBLE, Java8ParserFLOAT, Java8ParserINT, Java8ParserLONG, Java8ParserNEW, Java8ParserSHORT, Java8ParserSUPER, Java8ParserTHIS, Java8ParserVOID, Java8ParserIntegerLiteral, Java8ParserFloatingPointLiteral, Java8ParserBooleanLiteral, Java8ParserCharacterLiteral, Java8ParserStringLiteral, Java8ParserNullLiteral, Java8ParserLPAREN, Java8ParserBANG, Java8ParserTILDE, Java8ParserIdentifier, Java8ParserAT:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(2776)
			p.UnaryExpressionNotPlusMinus()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IPreIncrementExpressionContext is an interface to support dynamic dispatch.
type IPreIncrementExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPreIncrementExpressionContext differentiates from other interfaces.
	IsPreIncrementExpressionContext()
}

type PreIncrementExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPreIncrementExpressionContext() *PreIncrementExpressionContext {
	var p = new(PreIncrementExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_preIncrementExpression
	return p
}

func (*PreIncrementExpressionContext) IsPreIncrementExpressionContext() {}

func NewPreIncrementExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreIncrementExpressionContext {
	var p = new(PreIncrementExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_preIncrementExpression

	return p
}

func (s *PreIncrementExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *PreIncrementExpressionContext) INC() antlr.TerminalNode {
	return s.GetToken(Java8ParserINC, 0)
}

func (s *PreIncrementExpressionContext) UnaryExpression() IUnaryExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryExpressionContext)
}

func (s *PreIncrementExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PreIncrementExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PreIncrementExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPreIncrementExpression(s)
	}
}

func (s *PreIncrementExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPreIncrementExpression(s)
	}
}

func (p *Java8Parser) PreIncrementExpression() (localctx IPreIncrementExpressionContext) {
	this := p
	_ = this

	localctx = NewPreIncrementExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 454, Java8ParserRULE_preIncrementExpression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2779)
		p.Match(Java8ParserINC)
	}
	{
		p.SetState(2780)
		p.UnaryExpression()
	}

	return localctx
}

// IPreDecrementExpressionContext is an interface to support dynamic dispatch.
type IPreDecrementExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPreDecrementExpressionContext differentiates from other interfaces.
	IsPreDecrementExpressionContext()
}

type PreDecrementExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPreDecrementExpressionContext() *PreDecrementExpressionContext {
	var p = new(PreDecrementExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_preDecrementExpression
	return p
}

func (*PreDecrementExpressionContext) IsPreDecrementExpressionContext() {}

func NewPreDecrementExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreDecrementExpressionContext {
	var p = new(PreDecrementExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_preDecrementExpression

	return p
}

func (s *PreDecrementExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *PreDecrementExpressionContext) DEC() antlr.TerminalNode {
	return s.GetToken(Java8ParserDEC, 0)
}

func (s *PreDecrementExpressionContext) UnaryExpression() IUnaryExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryExpressionContext)
}

func (s *PreDecrementExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PreDecrementExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PreDecrementExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPreDecrementExpression(s)
	}
}

func (s *PreDecrementExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPreDecrementExpression(s)
	}
}

func (p *Java8Parser) PreDecrementExpression() (localctx IPreDecrementExpressionContext) {
	this := p
	_ = this

	localctx = NewPreDecrementExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 456, Java8ParserRULE_preDecrementExpression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2782)
		p.Match(Java8ParserDEC)
	}
	{
		p.SetState(2783)
		p.UnaryExpression()
	}

	return localctx
}

// IUnaryExpressionNotPlusMinusContext is an interface to support dynamic dispatch.
type IUnaryExpressionNotPlusMinusContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnaryExpressionNotPlusMinusContext differentiates from other interfaces.
	IsUnaryExpressionNotPlusMinusContext()
}

type UnaryExpressionNotPlusMinusContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnaryExpressionNotPlusMinusContext() *UnaryExpressionNotPlusMinusContext {
	var p = new(UnaryExpressionNotPlusMinusContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_unaryExpressionNotPlusMinus
	return p
}

func (*UnaryExpressionNotPlusMinusContext) IsUnaryExpressionNotPlusMinusContext() {}

func NewUnaryExpressionNotPlusMinusContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryExpressionNotPlusMinusContext {
	var p = new(UnaryExpressionNotPlusMinusContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_unaryExpressionNotPlusMinus

	return p
}

func (s *UnaryExpressionNotPlusMinusContext) GetParser() antlr.Parser { return s.parser }

func (s *UnaryExpressionNotPlusMinusContext) PostfixExpression() IPostfixExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPostfixExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPostfixExpressionContext)
}

func (s *UnaryExpressionNotPlusMinusContext) TILDE() antlr.TerminalNode {
	return s.GetToken(Java8ParserTILDE, 0)
}

func (s *UnaryExpressionNotPlusMinusContext) UnaryExpression() IUnaryExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryExpressionContext)
}

func (s *UnaryExpressionNotPlusMinusContext) BANG() antlr.TerminalNode {
	return s.GetToken(Java8ParserBANG, 0)
}

func (s *UnaryExpressionNotPlusMinusContext) CastExpression() ICastExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICastExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICastExpressionContext)
}

func (s *UnaryExpressionNotPlusMinusContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnaryExpressionNotPlusMinusContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UnaryExpressionNotPlusMinusContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterUnaryExpressionNotPlusMinus(s)
	}
}

func (s *UnaryExpressionNotPlusMinusContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitUnaryExpressionNotPlusMinus(s)
	}
}

func (p *Java8Parser) UnaryExpressionNotPlusMinus() (localctx IUnaryExpressionNotPlusMinusContext) {
	this := p
	_ = this

	localctx = NewUnaryExpressionNotPlusMinusContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 458, Java8ParserRULE_unaryExpressionNotPlusMinus)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2791)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 315, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2785)
			p.PostfixExpression()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2786)
			p.Match(Java8ParserTILDE)
		}
		{
			p.SetState(2787)
			p.UnaryExpression()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2788)
			p.Match(Java8ParserBANG)
		}
		{
			p.SetState(2789)
			p.UnaryExpression()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2790)
			p.CastExpression()
		}

	}

	return localctx
}

// IPostfixExpressionContext is an interface to support dynamic dispatch.
type IPostfixExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPostfixExpressionContext differentiates from other interfaces.
	IsPostfixExpressionContext()
}

type PostfixExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPostfixExpressionContext() *PostfixExpressionContext {
	var p = new(PostfixExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_postfixExpression
	return p
}

func (*PostfixExpressionContext) IsPostfixExpressionContext() {}

func NewPostfixExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PostfixExpressionContext {
	var p = new(PostfixExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_postfixExpression

	return p
}

func (s *PostfixExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *PostfixExpressionContext) Primary() IPrimaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryContext)
}

func (s *PostfixExpressionContext) ExpressionName() IExpressionNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionNameContext)
}

func (s *PostfixExpressionContext) AllPostIncrementExpression_lf_postfixExpression() []IPostIncrementExpression_lf_postfixExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IPostIncrementExpression_lf_postfixExpressionContext)(nil)).Elem())
	var tst = make([]IPostIncrementExpression_lf_postfixExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IPostIncrementExpression_lf_postfixExpressionContext)
		}
	}

	return tst
}

func (s *PostfixExpressionContext) PostIncrementExpression_lf_postfixExpression(i int) IPostIncrementExpression_lf_postfixExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPostIncrementExpression_lf_postfixExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IPostIncrementExpression_lf_postfixExpressionContext)
}

func (s *PostfixExpressionContext) AllPostDecrementExpression_lf_postfixExpression() []IPostDecrementExpression_lf_postfixExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IPostDecrementExpression_lf_postfixExpressionContext)(nil)).Elem())
	var tst = make([]IPostDecrementExpression_lf_postfixExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IPostDecrementExpression_lf_postfixExpressionContext)
		}
	}

	return tst
}

func (s *PostfixExpressionContext) PostDecrementExpression_lf_postfixExpression(i int) IPostDecrementExpression_lf_postfixExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPostDecrementExpression_lf_postfixExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IPostDecrementExpression_lf_postfixExpressionContext)
}

func (s *PostfixExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PostfixExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PostfixExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPostfixExpression(s)
	}
}

func (s *PostfixExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPostfixExpression(s)
	}
}

func (p *Java8Parser) PostfixExpression() (localctx IPostfixExpressionContext) {
	this := p
	_ = this

	localctx = NewPostfixExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 460, Java8ParserRULE_postfixExpression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2795)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 316, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(2793)
			p.Primary()
		}

	case 2:
		{
			p.SetState(2794)
			p.ExpressionName()
		}

	}
	p.SetState(2801)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 318, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(2799)
			p.GetErrorHandler().Sync(p)

			switch p.GetTokenStream().LA(1) {
			case Java8ParserINC:
				{
					p.SetState(2797)
					p.PostIncrementExpression_lf_postfixExpression()
				}

			case Java8ParserDEC:
				{
					p.SetState(2798)
					p.PostDecrementExpression_lf_postfixExpression()
				}

			default:
				panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
			}

		}
		p.SetState(2803)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 318, p.GetParserRuleContext())
	}

	return localctx
}

// IPostIncrementExpressionContext is an interface to support dynamic dispatch.
type IPostIncrementExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPostIncrementExpressionContext differentiates from other interfaces.
	IsPostIncrementExpressionContext()
}

type PostIncrementExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPostIncrementExpressionContext() *PostIncrementExpressionContext {
	var p = new(PostIncrementExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_postIncrementExpression
	return p
}

func (*PostIncrementExpressionContext) IsPostIncrementExpressionContext() {}

func NewPostIncrementExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PostIncrementExpressionContext {
	var p = new(PostIncrementExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_postIncrementExpression

	return p
}

func (s *PostIncrementExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *PostIncrementExpressionContext) PostfixExpression() IPostfixExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPostfixExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPostfixExpressionContext)
}

func (s *PostIncrementExpressionContext) INC() antlr.TerminalNode {
	return s.GetToken(Java8ParserINC, 0)
}

func (s *PostIncrementExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PostIncrementExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PostIncrementExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPostIncrementExpression(s)
	}
}

func (s *PostIncrementExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPostIncrementExpression(s)
	}
}

func (p *Java8Parser) PostIncrementExpression() (localctx IPostIncrementExpressionContext) {
	this := p
	_ = this

	localctx = NewPostIncrementExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 462, Java8ParserRULE_postIncrementExpression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2804)
		p.PostfixExpression()
	}
	{
		p.SetState(2805)
		p.Match(Java8ParserINC)
	}

	return localctx
}

// IPostIncrementExpression_lf_postfixExpressionContext is an interface to support dynamic dispatch.
type IPostIncrementExpression_lf_postfixExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPostIncrementExpression_lf_postfixExpressionContext differentiates from other interfaces.
	IsPostIncrementExpression_lf_postfixExpressionContext()
}

type PostIncrementExpression_lf_postfixExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPostIncrementExpression_lf_postfixExpressionContext() *PostIncrementExpression_lf_postfixExpressionContext {
	var p = new(PostIncrementExpression_lf_postfixExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_postIncrementExpression_lf_postfixExpression
	return p
}

func (*PostIncrementExpression_lf_postfixExpressionContext) IsPostIncrementExpression_lf_postfixExpressionContext() {
}

func NewPostIncrementExpression_lf_postfixExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PostIncrementExpression_lf_postfixExpressionContext {
	var p = new(PostIncrementExpression_lf_postfixExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_postIncrementExpression_lf_postfixExpression

	return p
}

func (s *PostIncrementExpression_lf_postfixExpressionContext) GetParser() antlr.Parser {
	return s.parser
}

func (s *PostIncrementExpression_lf_postfixExpressionContext) INC() antlr.TerminalNode {
	return s.GetToken(Java8ParserINC, 0)
}

func (s *PostIncrementExpression_lf_postfixExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PostIncrementExpression_lf_postfixExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PostIncrementExpression_lf_postfixExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPostIncrementExpression_lf_postfixExpression(s)
	}
}

func (s *PostIncrementExpression_lf_postfixExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPostIncrementExpression_lf_postfixExpression(s)
	}
}

func (p *Java8Parser) PostIncrementExpression_lf_postfixExpression() (localctx IPostIncrementExpression_lf_postfixExpressionContext) {
	this := p
	_ = this

	localctx = NewPostIncrementExpression_lf_postfixExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 464, Java8ParserRULE_postIncrementExpression_lf_postfixExpression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2807)
		p.Match(Java8ParserINC)
	}

	return localctx
}

// IPostDecrementExpressionContext is an interface to support dynamic dispatch.
type IPostDecrementExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPostDecrementExpressionContext differentiates from other interfaces.
	IsPostDecrementExpressionContext()
}

type PostDecrementExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPostDecrementExpressionContext() *PostDecrementExpressionContext {
	var p = new(PostDecrementExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_postDecrementExpression
	return p
}

func (*PostDecrementExpressionContext) IsPostDecrementExpressionContext() {}

func NewPostDecrementExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PostDecrementExpressionContext {
	var p = new(PostDecrementExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_postDecrementExpression

	return p
}

func (s *PostDecrementExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *PostDecrementExpressionContext) PostfixExpression() IPostfixExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPostfixExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPostfixExpressionContext)
}

func (s *PostDecrementExpressionContext) DEC() antlr.TerminalNode {
	return s.GetToken(Java8ParserDEC, 0)
}

func (s *PostDecrementExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PostDecrementExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PostDecrementExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPostDecrementExpression(s)
	}
}

func (s *PostDecrementExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPostDecrementExpression(s)
	}
}

func (p *Java8Parser) PostDecrementExpression() (localctx IPostDecrementExpressionContext) {
	this := p
	_ = this

	localctx = NewPostDecrementExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 466, Java8ParserRULE_postDecrementExpression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2809)
		p.PostfixExpression()
	}
	{
		p.SetState(2810)
		p.Match(Java8ParserDEC)
	}

	return localctx
}

// IPostDecrementExpression_lf_postfixExpressionContext is an interface to support dynamic dispatch.
type IPostDecrementExpression_lf_postfixExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPostDecrementExpression_lf_postfixExpressionContext differentiates from other interfaces.
	IsPostDecrementExpression_lf_postfixExpressionContext()
}

type PostDecrementExpression_lf_postfixExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPostDecrementExpression_lf_postfixExpressionContext() *PostDecrementExpression_lf_postfixExpressionContext {
	var p = new(PostDecrementExpression_lf_postfixExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_postDecrementExpression_lf_postfixExpression
	return p
}

func (*PostDecrementExpression_lf_postfixExpressionContext) IsPostDecrementExpression_lf_postfixExpressionContext() {
}

func NewPostDecrementExpression_lf_postfixExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PostDecrementExpression_lf_postfixExpressionContext {
	var p = new(PostDecrementExpression_lf_postfixExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_postDecrementExpression_lf_postfixExpression

	return p
}

func (s *PostDecrementExpression_lf_postfixExpressionContext) GetParser() antlr.Parser {
	return s.parser
}

func (s *PostDecrementExpression_lf_postfixExpressionContext) DEC() antlr.TerminalNode {
	return s.GetToken(Java8ParserDEC, 0)
}

func (s *PostDecrementExpression_lf_postfixExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PostDecrementExpression_lf_postfixExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PostDecrementExpression_lf_postfixExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterPostDecrementExpression_lf_postfixExpression(s)
	}
}

func (s *PostDecrementExpression_lf_postfixExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitPostDecrementExpression_lf_postfixExpression(s)
	}
}

func (p *Java8Parser) PostDecrementExpression_lf_postfixExpression() (localctx IPostDecrementExpression_lf_postfixExpressionContext) {
	this := p
	_ = this

	localctx = NewPostDecrementExpression_lf_postfixExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 468, Java8ParserRULE_postDecrementExpression_lf_postfixExpression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2812)
		p.Match(Java8ParserDEC)
	}

	return localctx
}

// ICastExpressionContext is an interface to support dynamic dispatch.
type ICastExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCastExpressionContext differentiates from other interfaces.
	IsCastExpressionContext()
}

type CastExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCastExpressionContext() *CastExpressionContext {
	var p = new(CastExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = Java8ParserRULE_castExpression
	return p
}

func (*CastExpressionContext) IsCastExpressionContext() {}

func NewCastExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CastExpressionContext {
	var p = new(CastExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = Java8ParserRULE_castExpression

	return p
}

func (s *CastExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *CastExpressionContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserLPAREN, 0)
}

func (s *CastExpressionContext) PrimitiveType() IPrimitiveTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimitiveTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimitiveTypeContext)
}

func (s *CastExpressionContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(Java8ParserRPAREN, 0)
}

func (s *CastExpressionContext) UnaryExpression() IUnaryExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryExpressionContext)
}

func (s *CastExpressionContext) ReferenceType() IReferenceTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReferenceTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReferenceTypeContext)
}

func (s *CastExpressionContext) UnaryExpressionNotPlusMinus() IUnaryExpressionNotPlusMinusContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryExpressionNotPlusMinusContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryExpressionNotPlusMinusContext)
}

func (s *CastExpressionContext) AllAdditionalBound() []IAdditionalBoundContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAdditionalBoundContext)(nil)).Elem())
	var tst = make([]IAdditionalBoundContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAdditionalBoundContext)
		}
	}

	return tst
}

func (s *CastExpressionContext) AdditionalBound(i int) IAdditionalBoundContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAdditionalBoundContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAdditionalBoundContext)
}

func (s *CastExpressionContext) LambdaExpression() ILambdaExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILambdaExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILambdaExpressionContext)
}

func (s *CastExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CastExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CastExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.EnterCastExpression(s)
	}
}

func (s *CastExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(Java8ParserListener); ok {
		listenerT.ExitCastExpression(s)
	}
}

func (p *Java8Parser) CastExpression() (localctx ICastExpressionContext) {
	this := p
	_ = this

	localctx = NewCastExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 470, Java8ParserRULE_castExpression)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(2841)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 321, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2814)
			p.Match(Java8ParserLPAREN)
		}
		{
			p.SetState(2815)
			p.PrimitiveType()
		}
		{
			p.SetState(2816)
			p.Match(Java8ParserRPAREN)
		}
		{
			p.SetState(2817)
			p.UnaryExpression()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2819)
			p.Match(Java8ParserLPAREN)
		}
		{
			p.SetState(2820)
			p.ReferenceType()
		}
		p.SetState(2824)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserBITAND {
			{
				p.SetState(2821)
				p.AdditionalBound()
			}

			p.SetState(2826)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(2827)
			p.Match(Java8ParserRPAREN)
		}
		{
			p.SetState(2828)
			p.UnaryExpressionNotPlusMinus()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2830)
			p.Match(Java8ParserLPAREN)
		}
		{
			p.SetState(2831)
			p.ReferenceType()
		}
		p.SetState(2835)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == Java8ParserBITAND {
			{
				p.SetState(2832)
				p.AdditionalBound()
			}

			p.SetState(2837)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(2838)
			p.Match(Java8ParserRPAREN)
		}
		{
			p.SetState(2839)
			p.LambdaExpression()
		}

	}

	return localctx
}

func (p *Java8Parser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
	switch ruleIndex {
	case 25:
		var t *PackageNameContext = nil
		if localctx != nil {
			t = localctx.(*PackageNameContext)
		}
		return p.PackageName_Sempred(t, predIndex)

	case 27:
		var t *PackageOrTypeNameContext = nil
		if localctx != nil {
			t = localctx.(*PackageOrTypeNameContext)
		}
		return p.PackageOrTypeName_Sempred(t, predIndex)

	case 30:
		var t *AmbiguousNameContext = nil
		if localctx != nil {
			t = localctx.(*AmbiguousNameContext)
		}
		return p.AmbiguousName_Sempred(t, predIndex)

	case 216:
		var t *ConditionalOrExpressionContext = nil
		if localctx != nil {
			t = localctx.(*ConditionalOrExpressionContext)
		}
		return p.ConditionalOrExpression_Sempred(t, predIndex)

	case 217:
		var t *ConditionalAndExpressionContext = nil
		if localctx != nil {
			t = localctx.(*ConditionalAndExpressionContext)
		}
		return p.ConditionalAndExpression_Sempred(t, predIndex)

	case 218:
		var t *InclusiveOrExpressionContext = nil
		if localctx != nil {
			t = localctx.(*InclusiveOrExpressionContext)
		}
		return p.InclusiveOrExpression_Sempred(t, predIndex)

	case 219:
		var t *ExclusiveOrExpressionContext = nil
		if localctx != nil {
			t = localctx.(*ExclusiveOrExpressionContext)
		}
		return p.ExclusiveOrExpression_Sempred(t, predIndex)

	case 220:
		var t *AndExpressionContext = nil
		if localctx != nil {
			t = localctx.(*AndExpressionContext)
		}
		return p.AndExpression_Sempred(t, predIndex)

	case 221:
		var t *EqualityExpressionContext = nil
		if localctx != nil {
			t = localctx.(*EqualityExpressionContext)
		}
		return p.EqualityExpression_Sempred(t, predIndex)

	case 222:
		var t *RelationalExpressionContext = nil
		if localctx != nil {
			t = localctx.(*RelationalExpressionContext)
		}
		return p.RelationalExpression_Sempred(t, predIndex)

	case 223:
		var t *ShiftExpressionContext = nil
		if localctx != nil {
			t = localctx.(*ShiftExpressionContext)
		}
		return p.ShiftExpression_Sempred(t, predIndex)

	case 224:
		var t *AdditiveExpressionContext = nil
		if localctx != nil {
			t = localctx.(*AdditiveExpressionContext)
		}
		return p.AdditiveExpression_Sempred(t, predIndex)

	case 225:
		var t *MultiplicativeExpressionContext = nil
		if localctx != nil {
			t = localctx.(*MultiplicativeExpressionContext)
		}
		return p.MultiplicativeExpression_Sempred(t, predIndex)

	default:
		panic("No predicate with index: " + fmt.Sprint(ruleIndex))
	}
}

func (p *Java8Parser) PackageName_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 0:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *Java8Parser) PackageOrTypeName_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 1:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *Java8Parser) AmbiguousName_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 2:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *Java8Parser) ConditionalOrExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 3:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *Java8Parser) ConditionalAndExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 4:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *Java8Parser) InclusiveOrExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 5:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *Java8Parser) ExclusiveOrExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 6:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *Java8Parser) AndExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 7:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *Java8Parser) EqualityExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 8:
		return p.Precpred(p.GetParserRuleContext(), 2)

	case 9:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *Java8Parser) RelationalExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 10:
		return p.Precpred(p.GetParserRuleContext(), 5)

	case 11:
		return p.Precpred(p.GetParserRuleContext(), 4)

	case 12:
		return p.Precpred(p.GetParserRuleContext(), 3)

	case 13:
		return p.Precpred(p.GetParserRuleContext(), 2)

	case 14:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *Java8Parser) ShiftExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 15:
		return p.Precpred(p.GetParserRuleContext(), 3)

	case 16:
		return p.Precpred(p.GetParserRuleContext(), 2)

	case 17:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *Java8Parser) AdditiveExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 18:
		return p.Precpred(p.GetParserRuleContext(), 2)

	case 19:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *Java8Parser) MultiplicativeExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 20:
		return p.Precpred(p.GetParserRuleContext(), 3)

	case 21:
		return p.Precpred(p.GetParserRuleContext(), 2)

	case 22:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}
