// Code generated from JavaParser.g4 by ANTLR 4.7.2. DO NOT EDIT.

package parser // JavaParser

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, 113, 1384,
	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, 3, 2, 5, 2, 212,
	10, 2, 3, 2, 7, 2, 215, 10, 2, 12, 2, 14, 2, 218, 11, 2, 3, 2, 7, 2, 221,
	10, 2, 12, 2, 14, 2, 224, 11, 2, 3, 2, 3, 2, 3, 3, 7, 3, 229, 10, 3, 12,
	3, 14, 3, 232, 11, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 5, 4, 240, 10,
	4, 3, 4, 3, 4, 3, 4, 5, 4, 245, 10, 4, 3, 4, 3, 4, 3, 5, 7, 5, 250, 10,
	5, 12, 5, 14, 5, 253, 11, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 259, 10, 5,
	3, 5, 5, 5, 262, 10, 5, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 5, 6, 269, 10, 6,
	3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 279, 10, 7, 3, 8,
	3, 8, 5, 8, 283, 10, 8, 3, 9, 3, 9, 3, 9, 5, 9, 288, 10, 9, 3, 9, 3, 9,
	5, 9, 292, 10, 9, 3, 9, 3, 9, 5, 9, 296, 10, 9, 3, 9, 3, 9, 3, 10, 3, 10,
	3, 10, 3, 10, 7, 10, 304, 10, 10, 12, 10, 14, 10, 307, 11, 10, 3, 10, 3,
	10, 3, 11, 7, 11, 312, 10, 11, 12, 11, 14, 11, 315, 11, 11, 3, 11, 3, 11,
	3, 11, 5, 11, 320, 10, 11, 3, 12, 3, 12, 3, 12, 7, 12, 325, 10, 12, 12,
	12, 14, 12, 328, 11, 12, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 334, 10, 13,
	3, 13, 3, 13, 5, 13, 338, 10, 13, 3, 13, 5, 13, 341, 10, 13, 3, 13, 5,
	13, 344, 10, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 7, 14, 351, 10, 14,
	12, 14, 14, 14, 354, 11, 14, 3, 15, 7, 15, 357, 10, 15, 12, 15, 14, 15,
	360, 11, 15, 3, 15, 3, 15, 5, 15, 364, 10, 15, 3, 15, 5, 15, 367, 10, 15,
	3, 16, 3, 16, 7, 16, 371, 10, 16, 12, 16, 14, 16, 374, 11, 16, 3, 17, 3,
	17, 3, 17, 5, 17, 379, 10, 17, 3, 17, 3, 17, 5, 17, 383, 10, 17, 3, 17,
	3, 17, 3, 18, 3, 18, 7, 18, 389, 10, 18, 12, 18, 14, 18, 392, 11, 18, 3,
	18, 3, 18, 3, 19, 3, 19, 7, 19, 398, 10, 19, 12, 19, 14, 19, 401, 11, 19,
	3, 19, 3, 19, 3, 20, 3, 20, 5, 20, 407, 10, 20, 3, 20, 3, 20, 7, 20, 411,
	10, 20, 12, 20, 14, 20, 414, 11, 20, 3, 20, 5, 20, 417, 10, 20, 3, 21,
	3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 428, 10,
	21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 7, 22, 435, 10, 22, 12, 22, 14,
	22, 438, 11, 22, 3, 22, 3, 22, 5, 22, 442, 10, 22, 3, 22, 3, 22, 3, 23,
	3, 23, 5, 23, 448, 10, 23, 3, 24, 3, 24, 5, 24, 452, 10, 24, 3, 25, 3,
	25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 27, 5, 27, 464,
	10, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3, 29, 7, 29, 473, 10,
	29, 12, 29, 14, 29, 476, 11, 29, 3, 29, 3, 29, 5, 29, 480, 10, 29, 3, 30,
	3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 5, 30, 489, 10, 30, 3, 31, 3,
	31, 3, 31, 3, 31, 7, 31, 495, 10, 31, 12, 31, 14, 31, 498, 11, 31, 3, 31,
	3, 31, 3, 32, 3, 32, 3, 32, 7, 32, 505, 10, 32, 12, 32, 14, 32, 508, 11,
	32, 3, 32, 3, 32, 3, 32, 3, 33, 7, 33, 514, 10, 33, 12, 33, 14, 33, 517,
	11, 33, 3, 33, 3, 33, 3, 33, 7, 33, 522, 10, 33, 12, 33, 14, 33, 525, 11,
	33, 3, 33, 3, 33, 5, 33, 529, 10, 33, 3, 33, 3, 33, 3, 33, 3, 33, 7, 33,
	535, 10, 33, 12, 33, 14, 33, 538, 11, 33, 3, 33, 3, 33, 5, 33, 542, 10,
	33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 5, 34, 552,
	10, 34, 3, 35, 3, 35, 3, 35, 3, 36, 3, 36, 3, 36, 7, 36, 560, 10, 36, 12,
	36, 14, 36, 563, 11, 36, 3, 37, 3, 37, 3, 37, 5, 37, 568, 10, 37, 3, 38,
	3, 38, 3, 38, 7, 38, 573, 10, 38, 12, 38, 14, 38, 576, 11, 38, 3, 39, 3,
	39, 5, 39, 580, 10, 39, 3, 40, 3, 40, 3, 40, 3, 40, 7, 40, 586, 10, 40,
	12, 40, 14, 40, 589, 11, 40, 3, 40, 5, 40, 592, 10, 40, 5, 40, 594, 10,
	40, 3, 40, 3, 40, 3, 41, 3, 41, 5, 41, 600, 10, 41, 3, 41, 3, 41, 3, 41,
	5, 41, 605, 10, 41, 7, 41, 607, 10, 41, 12, 41, 14, 41, 610, 11, 41, 3,
	42, 3, 42, 3, 42, 3, 42, 5, 42, 616, 10, 42, 5, 42, 618, 10, 42, 3, 43,
	3, 43, 3, 43, 7, 43, 623, 10, 43, 12, 43, 14, 43, 626, 11, 43, 3, 44, 3,
	44, 5, 44, 630, 10, 44, 3, 44, 3, 44, 3, 45, 3, 45, 3, 45, 7, 45, 637,
	10, 45, 12, 45, 14, 45, 640, 11, 45, 3, 45, 3, 45, 5, 45, 644, 10, 45,
	3, 45, 5, 45, 647, 10, 45, 3, 46, 7, 46, 650, 10, 46, 12, 46, 14, 46, 653,
	11, 46, 3, 46, 3, 46, 3, 46, 3, 47, 7, 47, 659, 10, 47, 12, 47, 14, 47,
	662, 11, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 7, 48, 671,
	10, 48, 12, 48, 14, 48, 674, 11, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49,
	3, 49, 5, 49, 682, 10, 49, 3, 50, 3, 50, 3, 51, 3, 51, 3, 52, 3, 52, 3,
	52, 3, 52, 3, 52, 5, 52, 693, 10, 52, 3, 52, 5, 52, 696, 10, 52, 3, 53,
	3, 53, 3, 53, 7, 53, 701, 10, 53, 12, 53, 14, 53, 704, 11, 53, 3, 54, 3,
	54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 55, 5, 55, 713, 10, 55, 3, 56, 3, 56,
	3, 56, 3, 56, 7, 56, 719, 10, 56, 12, 56, 14, 56, 722, 11, 56, 5, 56, 724,
	10, 56, 3, 56, 5, 56, 727, 10, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3,
	57, 3, 57, 3, 58, 3, 58, 7, 58, 738, 10, 58, 12, 58, 14, 58, 741, 11, 58,
	3, 58, 3, 58, 3, 59, 7, 59, 746, 10, 59, 12, 59, 14, 59, 749, 11, 59, 3,
	59, 3, 59, 5, 59, 753, 10, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60,
	5, 60, 761, 10, 60, 3, 60, 3, 60, 5, 60, 765, 10, 60, 3, 60, 3, 60, 5,
	60, 769, 10, 60, 3, 60, 3, 60, 5, 60, 773, 10, 60, 5, 60, 775, 10, 60,
	3, 61, 3, 61, 5, 61, 779, 10, 61, 3, 62, 3, 62, 3, 62, 3, 62, 5, 62, 785,
	10, 62, 3, 63, 3, 63, 3, 64, 3, 64, 3, 64, 3, 65, 3, 65, 7, 65, 794, 10,
	65, 12, 65, 14, 65, 797, 11, 65, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3,
	66, 3, 66, 5, 66, 806, 10, 66, 3, 67, 7, 67, 809, 10, 67, 12, 67, 14, 67,
	812, 11, 67, 3, 67, 3, 67, 3, 67, 3, 68, 7, 68, 818, 10, 68, 12, 68, 14,
	68, 821, 11, 68, 3, 68, 3, 68, 5, 68, 825, 10, 68, 3, 68, 5, 68, 828, 10,
	68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 5, 69, 835, 10, 69, 3, 69, 3, 69,
	3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 5, 69, 844, 10, 69, 3, 69, 3, 69, 3,
	69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69,
	3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 6, 69, 865, 10, 69, 13, 69, 14,
	69, 866, 3, 69, 5, 69, 870, 10, 69, 3, 69, 5, 69, 873, 10, 69, 3, 69, 3,
	69, 3, 69, 3, 69, 7, 69, 879, 10, 69, 12, 69, 14, 69, 882, 11, 69, 3, 69,
	5, 69, 885, 10, 69, 3, 69, 3, 69, 3, 69, 3, 69, 7, 69, 891, 10, 69, 12,
	69, 14, 69, 894, 11, 69, 3, 69, 7, 69, 897, 10, 69, 12, 69, 14, 69, 900,
	11, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 5, 69,
	910, 10, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 5, 69, 919,
	10, 69, 3, 69, 3, 69, 3, 69, 5, 69, 924, 10, 69, 3, 69, 3, 69, 3, 69, 3,
	69, 3, 69, 3, 69, 3, 69, 3, 69, 5, 69, 934, 10, 69, 3, 70, 3, 70, 3, 70,
	7, 70, 939, 10, 70, 12, 70, 14, 70, 942, 11, 70, 3, 70, 3, 70, 3, 70, 3,
	70, 3, 70, 3, 71, 3, 71, 3, 71, 7, 71, 952, 10, 71, 12, 71, 14, 71, 955,
	11, 71, 3, 72, 3, 72, 3, 72, 3, 73, 3, 73, 3, 73, 5, 73, 963, 10, 73, 3,
	73, 3, 73, 3, 74, 3, 74, 3, 74, 7, 74, 970, 10, 74, 12, 74, 14, 74, 973,
	11, 74, 3, 75, 7, 75, 976, 10, 75, 12, 75, 14, 75, 979, 11, 75, 3, 75,
	3, 75, 3, 75, 3, 75, 3, 75, 3, 76, 6, 76, 987, 10, 76, 13, 76, 14, 76,
	988, 3, 76, 6, 76, 992, 10, 76, 13, 76, 14, 76, 993, 3, 77, 3, 77, 3, 77,
	5, 77, 999, 10, 77, 3, 77, 3, 77, 3, 77, 5, 77, 1004, 10, 77, 3, 78, 3,
	78, 5, 78, 1008, 10, 78, 3, 78, 3, 78, 5, 78, 1012, 10, 78, 3, 78, 3, 78,
	5, 78, 1016, 10, 78, 5, 78, 1018, 10, 78, 3, 79, 3, 79, 5, 79, 1022, 10,
	79, 3, 80, 7, 80, 1025, 10, 80, 12, 80, 14, 80, 1028, 11, 80, 3, 80, 3,
	80, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 82, 3, 82, 3, 82,
	7, 82, 1042, 10, 82, 12, 82, 14, 82, 1045, 11, 82, 3, 83, 3, 83, 3, 83,
	5, 83, 1050, 10, 83, 3, 83, 3, 83, 3, 83, 3, 83, 5, 83, 1056, 10, 83, 3,
	83, 3, 83, 3, 83, 3, 83, 5, 83, 1062, 10, 83, 3, 83, 5, 83, 1065, 10, 83,
	3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3,
	84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 5, 84, 1085, 10, 84,
	3, 84, 3, 84, 5, 84, 1089, 10, 84, 3, 84, 3, 84, 3, 84, 5, 84, 1094, 10,
	84, 3, 84, 3, 84, 5, 84, 1098, 10, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84,
	3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 5, 84, 1114,
	10, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84,
	3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3,
	84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84,
	3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 5, 84, 1154, 10,
	84, 3, 84, 3, 84, 3, 84, 3, 84, 5, 84, 1160, 10, 84, 3, 84, 3, 84, 3, 84,
	3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 5,
	84, 1175, 10, 84, 3, 84, 7, 84, 1178, 10, 84, 12, 84, 14, 84, 1181, 11,
	84, 3, 85, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 5, 86, 1190, 10, 86,
	3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 7, 86, 1197, 10, 86, 12, 86, 14, 86,
	1200, 11, 86, 3, 86, 5, 86, 1203, 10, 86, 3, 87, 3, 87, 5, 87, 1207, 10,
	87, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88,
	3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 5, 88, 1225, 10, 88, 5, 88, 1227,
	10, 88, 3, 89, 3, 89, 3, 89, 5, 89, 1232, 10, 89, 3, 89, 7, 89, 1235, 10,
	89, 12, 89, 14, 89, 1238, 11, 89, 3, 89, 3, 89, 5, 89, 1242, 10, 89, 3,
	90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 5, 90, 1251, 10, 90, 5, 90,
	1253, 10, 90, 3, 91, 3, 91, 5, 91, 1257, 10, 91, 3, 91, 3, 91, 3, 91, 5,
	91, 1262, 10, 91, 7, 91, 1264, 10, 91, 12, 91, 14, 91, 1267, 11, 91, 3,
	91, 5, 91, 1270, 10, 91, 3, 92, 3, 92, 5, 92, 1274, 10, 92, 3, 92, 3, 92,
	3, 93, 3, 93, 3, 93, 3, 93, 7, 93, 1282, 10, 93, 12, 93, 14, 93, 1285,
	11, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 7, 93, 1294, 10,
	93, 12, 93, 14, 93, 1297, 11, 93, 3, 93, 3, 93, 7, 93, 1301, 10, 93, 12,
	93, 14, 93, 1304, 11, 93, 5, 93, 1306, 10, 93, 3, 94, 3, 94, 5, 94, 1310,
	10, 94, 3, 95, 3, 95, 3, 95, 3, 96, 3, 96, 3, 96, 5, 96, 1318, 10, 96,
	3, 97, 3, 97, 3, 97, 5, 97, 1323, 10, 97, 3, 98, 3, 98, 3, 98, 3, 98, 3,
	99, 3, 99, 3, 99, 7, 99, 1332, 10, 99, 12, 99, 14, 99, 1335, 11, 99, 3,
	100, 5, 100, 1338, 10, 100, 3, 100, 3, 100, 5, 100, 1342, 10, 100, 3, 100,
	3, 100, 7, 100, 1346, 10, 100, 12, 100, 14, 100, 1349, 11, 100, 3, 101,
	3, 101, 3, 102, 3, 102, 3, 102, 3, 102, 7, 102, 1357, 10, 102, 12, 102,
	14, 102, 1360, 11, 102, 3, 102, 3, 102, 3, 103, 3, 103, 3, 103, 3, 103,
	5, 103, 1368, 10, 103, 5, 103, 1370, 10, 103, 3, 104, 3, 104, 3, 104, 3,
	104, 5, 104, 1376, 10, 104, 3, 105, 3, 105, 5, 105, 1380, 10, 105, 3, 105,
	3, 105, 3, 105, 2, 3, 166, 106, 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, 2, 14, 4, 2,
	19, 19, 42, 42, 3, 2, 53, 56, 3, 2, 57, 58, 3, 2, 85, 88, 3, 2, 75, 76,
	4, 2, 89, 90, 94, 94, 3, 2, 87, 88, 4, 2, 73, 74, 80, 81, 4, 2, 79, 79,
	82, 82, 4, 2, 72, 72, 95, 105, 3, 2, 85, 86, 10, 2, 5, 5, 7, 7, 10, 10,
	16, 16, 22, 22, 29, 29, 31, 31, 39, 39, 2, 1537, 2, 211, 3, 2, 2, 2, 4,
	230, 3, 2, 2, 2, 6, 237, 3, 2, 2, 2, 8, 261, 3, 2, 2, 2, 10, 268, 3, 2,
	2, 2, 12, 278, 3, 2, 2, 2, 14, 282, 3, 2, 2, 2, 16, 284, 3, 2, 2, 2, 18,
	299, 3, 2, 2, 2, 20, 313, 3, 2, 2, 2, 22, 321, 3, 2, 2, 2, 24, 329, 3,
	2, 2, 2, 26, 347, 3, 2, 2, 2, 28, 358, 3, 2, 2, 2, 30, 368, 3, 2, 2, 2,
	32, 375, 3, 2, 2, 2, 34, 386, 3, 2, 2, 2, 36, 395, 3, 2, 2, 2, 38, 416,
	3, 2, 2, 2, 40, 427, 3, 2, 2, 2, 42, 429, 3, 2, 2, 2, 44, 447, 3, 2, 2,
	2, 46, 451, 3, 2, 2, 2, 48, 453, 3, 2, 2, 2, 50, 456, 3, 2, 2, 2, 52, 459,
	3, 2, 2, 2, 54, 467, 3, 2, 2, 2, 56, 479, 3, 2, 2, 2, 58, 488, 3, 2, 2,
	2, 60, 490, 3, 2, 2, 2, 62, 501, 3, 2, 2, 2, 64, 515, 3, 2, 2, 2, 66, 551,
	3, 2, 2, 2, 68, 553, 3, 2, 2, 2, 70, 556, 3, 2, 2, 2, 72, 564, 3, 2, 2,
	2, 74, 569, 3, 2, 2, 2, 76, 579, 3, 2, 2, 2, 78, 581, 3, 2, 2, 2, 80, 597,
	3, 2, 2, 2, 82, 617, 3, 2, 2, 2, 84, 619, 3, 2, 2, 2, 86, 627, 3, 2, 2,
	2, 88, 646, 3, 2, 2, 2, 90, 651, 3, 2, 2, 2, 92, 660, 3, 2, 2, 2, 94, 667,
	3, 2, 2, 2, 96, 681, 3, 2, 2, 2, 98, 683, 3, 2, 2, 2, 100, 685, 3, 2, 2,
	2, 102, 687, 3, 2, 2, 2, 104, 697, 3, 2, 2, 2, 106, 705, 3, 2, 2, 2, 108,
	712, 3, 2, 2, 2, 110, 714, 3, 2, 2, 2, 112, 730, 3, 2, 2, 2, 114, 735,
	3, 2, 2, 2, 116, 752, 3, 2, 2, 2, 118, 774, 3, 2, 2, 2, 120, 778, 3, 2,
	2, 2, 122, 780, 3, 2, 2, 2, 124, 786, 3, 2, 2, 2, 126, 788, 3, 2, 2, 2,
	128, 791, 3, 2, 2, 2, 130, 805, 3, 2, 2, 2, 132, 810, 3, 2, 2, 2, 134,
	827, 3, 2, 2, 2, 136, 933, 3, 2, 2, 2, 138, 935, 3, 2, 2, 2, 140, 948,
	3, 2, 2, 2, 142, 956, 3, 2, 2, 2, 144, 959, 3, 2, 2, 2, 146, 966, 3, 2,
	2, 2, 148, 977, 3, 2, 2, 2, 150, 986, 3, 2, 2, 2, 152, 1003, 3, 2, 2, 2,
	154, 1017, 3, 2, 2, 2, 156, 1021, 3, 2, 2, 2, 158, 1026, 3, 2, 2, 2, 160,
	1034, 3, 2, 2, 2, 162, 1038, 3, 2, 2, 2, 164, 1064, 3, 2, 2, 2, 166, 1097,
	3, 2, 2, 2, 168, 1182, 3, 2, 2, 2, 170, 1202, 3, 2, 2, 2, 172, 1206, 3,
	2, 2, 2, 174, 1226, 3, 2, 2, 2, 176, 1231, 3, 2, 2, 2, 178, 1252, 3, 2,
	2, 2, 180, 1269, 3, 2, 2, 2, 182, 1271, 3, 2, 2, 2, 184, 1277, 3, 2, 2,
	2, 186, 1307, 3, 2, 2, 2, 188, 1311, 3, 2, 2, 2, 190, 1317, 3, 2, 2, 2,
	192, 1322, 3, 2, 2, 2, 194, 1324, 3, 2, 2, 2, 196, 1328, 3, 2, 2, 2, 198,
	1337, 3, 2, 2, 2, 200, 1350, 3, 2, 2, 2, 202, 1352, 3, 2, 2, 2, 204, 1369,
	3, 2, 2, 2, 206, 1375, 3, 2, 2, 2, 208, 1377, 3, 2, 2, 2, 210, 212, 5,
	4, 3, 2, 211, 210, 3, 2, 2, 2, 211, 212, 3, 2, 2, 2, 212, 216, 3, 2, 2,
	2, 213, 215, 5, 6, 4, 2, 214, 213, 3, 2, 2, 2, 215, 218, 3, 2, 2, 2, 216,
	214, 3, 2, 2, 2, 216, 217, 3, 2, 2, 2, 217, 222, 3, 2, 2, 2, 218, 216,
	3, 2, 2, 2, 219, 221, 5, 8, 5, 2, 220, 219, 3, 2, 2, 2, 221, 224, 3, 2,
	2, 2, 222, 220, 3, 2, 2, 2, 222, 223, 3, 2, 2, 2, 223, 225, 3, 2, 2, 2,
	224, 222, 3, 2, 2, 2, 225, 226, 7, 2, 2, 3, 226, 3, 3, 2, 2, 2, 227, 229,
	5, 102, 52, 2, 228, 227, 3, 2, 2, 2, 229, 232, 3, 2, 2, 2, 230, 228, 3,
	2, 2, 2, 230, 231, 3, 2, 2, 2, 231, 233, 3, 2, 2, 2, 232, 230, 3, 2, 2,
	2, 233, 234, 7, 34, 2, 2, 234, 235, 5, 94, 48, 2, 235, 236, 7, 69, 2, 2,
	236, 5, 3, 2, 2, 2, 237, 239, 7, 27, 2, 2, 238, 240, 7, 40, 2, 2, 239,
	238, 3, 2, 2, 2, 239, 240, 3, 2, 2, 2, 240, 241, 3, 2, 2, 2, 241, 244,
	5, 94, 48, 2, 242, 243, 7, 71, 2, 2, 243, 245, 7, 89, 2, 2, 244, 242, 3,
	2, 2, 2, 244, 245, 3, 2, 2, 2, 245, 246, 3, 2, 2, 2, 246, 247, 7, 69, 2,
	2, 247, 7, 3, 2, 2, 2, 248, 250, 5, 12, 7, 2, 249, 248, 3, 2, 2, 2, 250,
	253, 3, 2, 2, 2, 251, 249, 3, 2, 2, 2, 251, 252, 3, 2, 2, 2, 252, 258,
	3, 2, 2, 2, 253, 251, 3, 2, 2, 2, 254, 259, 5, 16, 9, 2, 255, 259, 5, 24,
	13, 2, 256, 259, 5, 32, 17, 2, 257, 259, 5, 112, 57, 2, 258, 254, 3, 2,
	2, 2, 258, 255, 3, 2, 2, 2, 258, 256, 3, 2, 2, 2, 258, 257, 3, 2, 2, 2,
	259, 262, 3, 2, 2, 2, 260, 262, 7, 69, 2, 2, 261, 251, 3, 2, 2, 2, 261,
	260, 3, 2, 2, 2, 262, 9, 3, 2, 2, 2, 263, 269, 5, 12, 7, 2, 264, 269, 7,
	32, 2, 2, 265, 269, 7, 44, 2, 2, 266, 269, 7, 48, 2, 2, 267, 269, 7, 51,
	2, 2, 268, 263, 3, 2, 2, 2, 268, 264, 3, 2, 2, 2, 268, 265, 3, 2, 2, 2,
	268, 266, 3, 2, 2, 2, 268, 267, 3, 2, 2, 2, 269, 11, 3, 2, 2, 2, 270, 279,
	5, 102, 52, 2, 271, 279, 7, 37, 2, 2, 272, 279, 7, 36, 2, 2, 273, 279,
	7, 35, 2, 2, 274, 279, 7, 40, 2, 2, 275, 279, 7, 3, 2, 2, 276, 279, 7,
	20, 2, 2, 277, 279, 7, 41, 2, 2, 278, 270, 3, 2, 2, 2, 278, 271, 3, 2,
	2, 2, 278, 272, 3, 2, 2, 2, 278, 273, 3, 2, 2, 2, 278, 274, 3, 2, 2, 2,
	278, 275, 3, 2, 2, 2, 278, 276, 3, 2, 2, 2, 278, 277, 3, 2, 2, 2, 279,
	13, 3, 2, 2, 2, 280, 283, 7, 20, 2, 2, 281, 283, 5, 102, 52, 2, 282, 280,
	3, 2, 2, 2, 282, 281, 3, 2, 2, 2, 283, 15, 3, 2, 2, 2, 284, 285, 7, 11,
	2, 2, 285, 287, 7, 113, 2, 2, 286, 288, 5, 18, 10, 2, 287, 286, 3, 2, 2,
	2, 287, 288, 3, 2, 2, 2, 288, 291, 3, 2, 2, 2, 289, 290, 7, 19, 2, 2, 290,
	292, 5, 198, 100, 2, 291, 289, 3, 2, 2, 2, 291, 292, 3, 2, 2, 2, 292, 295,
	3, 2, 2, 2, 293, 294, 7, 26, 2, 2, 294, 296, 5, 196, 99, 2, 295, 293, 3,
	2, 2, 2, 295, 296, 3, 2, 2, 2, 296, 297, 3, 2, 2, 2, 297, 298, 5, 34, 18,
	2, 298, 17, 3, 2, 2, 2, 299, 300, 7, 74, 2, 2, 300, 305, 5, 20, 11, 2,
	301, 302, 7, 70, 2, 2, 302, 304, 5, 20, 11, 2, 303, 301, 3, 2, 2, 2, 304,
	307, 3, 2, 2, 2, 305, 303, 3, 2, 2, 2, 305, 306, 3, 2, 2, 2, 306, 308,
	3, 2, 2, 2, 307, 305, 3, 2, 2, 2, 308, 309, 7, 73, 2, 2, 309, 19, 3, 2,
	2, 2, 310, 312, 5, 102, 52, 2, 311, 310, 3, 2, 2, 2, 312, 315, 3, 2, 2,
	2, 313, 311, 3, 2, 2, 2, 313, 314, 3, 2, 2, 2, 314, 316, 3, 2, 2, 2, 315,
	313, 3, 2, 2, 2, 316, 319, 7, 113, 2, 2, 317, 318, 7, 19, 2, 2, 318, 320,
	5, 22, 12, 2, 319, 317, 3, 2, 2, 2, 319, 320, 3, 2, 2, 2, 320, 21, 3, 2,
	2, 2, 321, 326, 5, 198, 100, 2, 322, 323, 7, 91, 2, 2, 323, 325, 5, 198,
	100, 2, 324, 322, 3, 2, 2, 2, 325, 328, 3, 2, 2, 2, 326, 324, 3, 2, 2,
	2, 326, 327, 3, 2, 2, 2, 327, 23, 3, 2, 2, 2, 328, 326, 3, 2, 2, 2, 329,
	330, 7, 18, 2, 2, 330, 333, 7, 113, 2, 2, 331, 332, 7, 26, 2, 2, 332, 334,
	5, 196, 99, 2, 333, 331, 3, 2, 2, 2, 333, 334, 3, 2, 2, 2, 334, 335, 3,
	2, 2, 2, 335, 337, 7, 65, 2, 2, 336, 338, 5, 26, 14, 2, 337, 336, 3, 2,
	2, 2, 337, 338, 3, 2, 2, 2, 338, 340, 3, 2, 2, 2, 339, 341, 7, 70, 2, 2,
	340, 339, 3, 2, 2, 2, 340, 341, 3, 2, 2, 2, 341, 343, 3, 2, 2, 2, 342,
	344, 5, 30, 16, 2, 343, 342, 3, 2, 2, 2, 343, 344, 3, 2, 2, 2, 344, 345,
	3, 2, 2, 2, 345, 346, 7, 66, 2, 2, 346, 25, 3, 2, 2, 2, 347, 352, 5, 28,
	15, 2, 348, 349, 7, 70, 2, 2, 349, 351, 5, 28, 15, 2, 350, 348, 3, 2, 2,
	2, 351, 354, 3, 2, 2, 2, 352, 350, 3, 2, 2, 2, 352, 353, 3, 2, 2, 2, 353,
	27, 3, 2, 2, 2, 354, 352, 3, 2, 2, 2, 355, 357, 5, 102, 52, 2, 356, 355,
	3, 2, 2, 2, 357, 360, 3, 2, 2, 2, 358, 356, 3, 2, 2, 2, 358, 359, 3, 2,
	2, 2, 359, 361, 3, 2, 2, 2, 360, 358, 3, 2, 2, 2, 361, 363, 7, 113, 2,
	2, 362, 364, 5, 208, 105, 2, 363, 362, 3, 2, 2, 2, 363, 364, 3, 2, 2, 2,
	364, 366, 3, 2, 2, 2, 365, 367, 5, 34, 18, 2, 366, 365, 3, 2, 2, 2, 366,
	367, 3, 2, 2, 2, 367, 29, 3, 2, 2, 2, 368, 372, 7, 69, 2, 2, 369, 371,
	5, 38, 20, 2, 370, 369, 3, 2, 2, 2, 371, 374, 3, 2, 2, 2, 372, 370, 3,
	2, 2, 2, 372, 373, 3, 2, 2, 2, 373, 31, 3, 2, 2, 2, 374, 372, 3, 2, 2,
	2, 375, 376, 7, 30, 2, 2, 376, 378, 7, 113, 2, 2, 377, 379, 5, 18, 10,
	2, 378, 377, 3, 2, 2, 2, 378, 379, 3, 2, 2, 2, 379, 382, 3, 2, 2, 2, 380,
	381, 7, 19, 2, 2, 381, 383, 5, 196, 99, 2, 382, 380, 3, 2, 2, 2, 382, 383,
	3, 2, 2, 2, 383, 384, 3, 2, 2, 2, 384, 385, 5, 36, 19, 2, 385, 33, 3, 2,
	2, 2, 386, 390, 7, 65, 2, 2, 387, 389, 5, 38, 20, 2, 388, 387, 3, 2, 2,
	2, 389, 392, 3, 2, 2, 2, 390, 388, 3, 2, 2, 2, 390, 391, 3, 2, 2, 2, 391,
	393, 3, 2, 2, 2, 392, 390, 3, 2, 2, 2, 393, 394, 7, 66, 2, 2, 394, 35,
	3, 2, 2, 2, 395, 399, 7, 65, 2, 2, 396, 398, 5, 56, 29, 2, 397, 396, 3,
	2, 2, 2, 398, 401, 3, 2, 2, 2, 399, 397, 3, 2, 2, 2, 399, 400, 3, 2, 2,
	2, 400, 402, 3, 2, 2, 2, 401, 399, 3, 2, 2, 2, 402, 403, 7, 66, 2, 2, 403,
	37, 3, 2, 2, 2, 404, 417, 7, 69, 2, 2, 405, 407, 7, 40, 2, 2, 406, 405,
	3, 2, 2, 2, 406, 407, 3, 2, 2, 2, 407, 408, 3, 2, 2, 2, 408, 417, 5, 128,
	65, 2, 409, 411, 5, 10, 6, 2, 410, 409, 3, 2, 2, 2, 411, 414, 3, 2, 2,
	2, 412, 410, 3, 2, 2, 2, 412, 413, 3, 2, 2, 2, 413, 415, 3, 2, 2, 2, 414,
	412, 3, 2, 2, 2, 415, 417, 5, 40, 21, 2, 416, 404, 3, 2, 2, 2, 416, 406,
	3, 2, 2, 2, 416, 412, 3, 2, 2, 2, 417, 39, 3, 2, 2, 2, 418, 428, 5, 42,
	22, 2, 419, 428, 5, 48, 25, 2, 420, 428, 5, 54, 28, 2, 421, 428, 5, 52,
	27, 2, 422, 428, 5, 50, 26, 2, 423, 428, 5, 32, 17, 2, 424, 428, 5, 112,
	57, 2, 425, 428, 5, 16, 9, 2, 426, 428, 5, 24, 13, 2, 427, 418, 3, 2, 2,
	2, 427, 419, 3, 2, 2, 2, 427, 420, 3, 2, 2, 2, 427, 421, 3, 2, 2, 2, 427,
	422, 3, 2, 2, 2, 427, 423, 3, 2, 2, 2, 427, 424, 3, 2, 2, 2, 427, 425,
	3, 2, 2, 2, 427, 426, 3, 2, 2, 2, 428, 41, 3, 2, 2, 2, 429, 430, 5, 46,
	24, 2, 430, 431, 7, 113, 2, 2, 431, 436, 5, 86, 44, 2, 432, 433, 7, 67,
	2, 2, 433, 435, 7, 68, 2, 2, 434, 432, 3, 2, 2, 2, 435, 438, 3, 2, 2, 2,
	436, 434, 3, 2, 2, 2, 436, 437, 3, 2, 2, 2, 437, 441, 3, 2, 2, 2, 438,
	436, 3, 2, 2, 2, 439, 440, 7, 47, 2, 2, 440, 442, 5, 84, 43, 2, 441, 439,
	3, 2, 2, 2, 441, 442, 3, 2, 2, 2, 442, 443, 3, 2, 2, 2, 443, 444, 5, 44,
	23, 2, 444, 43, 3, 2, 2, 2, 445, 448, 5, 128, 65, 2, 446, 448, 7, 69, 2,
	2, 447, 445, 3, 2, 2, 2, 447, 446, 3, 2, 2, 2, 448, 45, 3, 2, 2, 2, 449,
	452, 5, 198, 100, 2, 450, 452, 7, 50, 2, 2, 451, 449, 3, 2, 2, 2, 451,
	450, 3, 2, 2, 2, 452, 47, 3, 2, 2, 2, 453, 454, 5, 18, 10, 2, 454, 455,
	5, 42, 22, 2, 455, 49, 3, 2, 2, 2, 456, 457, 5, 18, 10, 2, 457, 458, 5,
	52, 27, 2, 458, 51, 3, 2, 2, 2, 459, 460, 7, 113, 2, 2, 460, 463, 5, 86,
	44, 2, 461, 462, 7, 47, 2, 2, 462, 464, 5, 84, 43, 2, 463, 461, 3, 2, 2,
	2, 463, 464, 3, 2, 2, 2, 464, 465, 3, 2, 2, 2, 465, 466, 5, 128, 65, 2,
	466, 53, 3, 2, 2, 2, 467, 468, 5, 198, 100, 2, 468, 469, 5, 70, 36, 2,
	469, 470, 7, 69, 2, 2, 470, 55, 3, 2, 2, 2, 471, 473, 5, 10, 6, 2, 472,
	471, 3, 2, 2, 2, 473, 476, 3, 2, 2, 2, 474, 472, 3, 2, 2, 2, 474, 475,
	3, 2, 2, 2, 475, 477, 3, 2, 2, 2, 476, 474, 3, 2, 2, 2, 477, 480, 5, 58,
	30, 2, 478, 480, 7, 69, 2, 2, 479, 474, 3, 2, 2, 2, 479, 478, 3, 2, 2,
	2, 480, 57, 3, 2, 2, 2, 481, 489, 5, 60, 31, 2, 482, 489, 5, 64, 33, 2,
	483, 489, 5, 68, 35, 2, 484, 489, 5, 32, 17, 2, 485, 489, 5, 112, 57, 2,
	486, 489, 5, 16, 9, 2, 487, 489, 5, 24, 13, 2, 488, 481, 3, 2, 2, 2, 488,
	482, 3, 2, 2, 2, 488, 483, 3, 2, 2, 2, 488, 484, 3, 2, 2, 2, 488, 485,
	3, 2, 2, 2, 488, 486, 3, 2, 2, 2, 488, 487, 3, 2, 2, 2, 489, 59, 3, 2,
	2, 2, 490, 491, 5, 198, 100, 2, 491, 496, 5, 62, 32, 2, 492, 493, 7, 70,
	2, 2, 493, 495, 5, 62, 32, 2, 494, 492, 3, 2, 2, 2, 495, 498, 3, 2, 2,
	2, 496, 494, 3, 2, 2, 2, 496, 497, 3, 2, 2, 2, 497, 499, 3, 2, 2, 2, 498,
	496, 3, 2, 2, 2, 499, 500, 7, 69, 2, 2, 500, 61, 3, 2, 2, 2, 501, 506,
	7, 113, 2, 2, 502, 503, 7, 67, 2, 2, 503, 505, 7, 68, 2, 2, 504, 502, 3,
	2, 2, 2, 505, 508, 3, 2, 2, 2, 506, 504, 3, 2, 2, 2, 506, 507, 3, 2, 2,
	2, 507, 509, 3, 2, 2, 2, 508, 506, 3, 2, 2, 2, 509, 510, 7, 72, 2, 2, 510,
	511, 5, 76, 39, 2, 511, 63, 3, 2, 2, 2, 512, 514, 5, 66, 34, 2, 513, 512,
	3, 2, 2, 2, 514, 517, 3, 2, 2, 2, 515, 513, 3, 2, 2, 2, 515, 516, 3, 2,
	2, 2, 516, 528, 3, 2, 2, 2, 517, 515, 3, 2, 2, 2, 518, 529, 5, 46, 24,
	2, 519, 523, 5, 18, 10, 2, 520, 522, 5, 102, 52, 2, 521, 520, 3, 2, 2,
	2, 522, 525, 3, 2, 2, 2, 523, 521, 3, 2, 2, 2, 523, 524, 3, 2, 2, 2, 524,
	526, 3, 2, 2, 2, 525, 523, 3, 2, 2, 2, 526, 527, 5, 46, 24, 2, 527, 529,
	3, 2, 2, 2, 528, 518, 3, 2, 2, 2, 528, 519, 3, 2, 2, 2, 529, 530, 3, 2,
	2, 2, 530, 531, 7, 113, 2, 2, 531, 536, 5, 86, 44, 2, 532, 533, 7, 67,
	2, 2, 533, 535, 7, 68, 2, 2, 534, 532, 3, 2, 2, 2, 535, 538, 3, 2, 2, 2,
	536, 534, 3, 2, 2, 2, 536, 537, 3, 2, 2, 2, 537, 541, 3, 2, 2, 2, 538,
	536, 3, 2, 2, 2, 539, 540, 7, 47, 2, 2, 540, 542, 5, 84, 43, 2, 541, 539,
	3, 2, 2, 2, 541, 542, 3, 2, 2, 2, 542, 543, 3, 2, 2, 2, 543, 544, 5, 44,
	23, 2, 544, 65, 3, 2, 2, 2, 545, 552, 5, 102, 52, 2, 546, 552, 7, 37, 2,
	2, 547, 552, 7, 3, 2, 2, 548, 552, 7, 14, 2, 2, 549, 552, 7, 40, 2, 2,
	550, 552, 7, 41, 2, 2, 551, 545, 3, 2, 2, 2, 551, 546, 3, 2, 2, 2, 551,
	547, 3, 2, 2, 2, 551, 548, 3, 2, 2, 2, 551, 549, 3, 2, 2, 2, 551, 550,
	3, 2, 2, 2, 552, 67, 3, 2, 2, 2, 553, 554, 5, 18, 10, 2, 554, 555, 5, 64,
	33, 2, 555, 69, 3, 2, 2, 2, 556, 561, 5, 72, 37, 2, 557, 558, 7, 70, 2,
	2, 558, 560, 5, 72, 37, 2, 559, 557, 3, 2, 2, 2, 560, 563, 3, 2, 2, 2,
	561, 559, 3, 2, 2, 2, 561, 562, 3, 2, 2, 2, 562, 71, 3, 2, 2, 2, 563, 561,
	3, 2, 2, 2, 564, 567, 5, 74, 38, 2, 565, 566, 7, 72, 2, 2, 566, 568, 5,
	76, 39, 2, 567, 565, 3, 2, 2, 2, 567, 568, 3, 2, 2, 2, 568, 73, 3, 2, 2,
	2, 569, 574, 7, 113, 2, 2, 570, 571, 7, 67, 2, 2, 571, 573, 7, 68, 2, 2,
	572, 570, 3, 2, 2, 2, 573, 576, 3, 2, 2, 2, 574, 572, 3, 2, 2, 2, 574,
	575, 3, 2, 2, 2, 575, 75, 3, 2, 2, 2, 576, 574, 3, 2, 2, 2, 577, 580, 5,
	78, 40, 2, 578, 580, 5, 166, 84, 2, 579, 577, 3, 2, 2, 2, 579, 578, 3,
	2, 2, 2, 580, 77, 3, 2, 2, 2, 581, 593, 7, 65, 2, 2, 582, 587, 5, 76, 39,
	2, 583, 584, 7, 70, 2, 2, 584, 586, 5, 76, 39, 2, 585, 583, 3, 2, 2, 2,
	586, 589, 3, 2, 2, 2, 587, 585, 3, 2, 2, 2, 587, 588, 3, 2, 2, 2, 588,
	591, 3, 2, 2, 2, 589, 587, 3, 2, 2, 2, 590, 592, 7, 70, 2, 2, 591, 590,
	3, 2, 2, 2, 591, 592, 3, 2, 2, 2, 592, 594, 3, 2, 2, 2, 593, 582, 3, 2,
	2, 2, 593, 594, 3, 2, 2, 2, 594, 595, 3, 2, 2, 2, 595, 596, 7, 66, 2, 2,
	596, 79, 3, 2, 2, 2, 597, 599, 7, 113, 2, 2, 598, 600, 5, 202, 102, 2,
	599, 598, 3, 2, 2, 2, 599, 600, 3, 2, 2, 2, 600, 608, 3, 2, 2, 2, 601,
	602, 7, 71, 2, 2, 602, 604, 7, 113, 2, 2, 603, 605, 5, 202, 102, 2, 604,
	603, 3, 2, 2, 2, 604, 605, 3, 2, 2, 2, 605, 607, 3, 2, 2, 2, 606, 601,
	3, 2, 2, 2, 607, 610, 3, 2, 2, 2, 608, 606, 3, 2, 2, 2, 608, 609, 3, 2,
	2, 2, 609, 81, 3, 2, 2, 2, 610, 608, 3, 2, 2, 2, 611, 618, 5, 198, 100,
	2, 612, 615, 7, 77, 2, 2, 613, 614, 9, 2, 2, 2, 614, 616, 5, 198, 100,
	2, 615, 613, 3, 2, 2, 2, 615, 616, 3, 2, 2, 2, 616, 618, 3, 2, 2, 2, 617,
	611, 3, 2, 2, 2, 617, 612, 3, 2, 2, 2, 618, 83, 3, 2, 2, 2, 619, 624, 5,
	94, 48, 2, 620, 621, 7, 70, 2, 2, 621, 623, 5, 94, 48, 2, 622, 620, 3,
	2, 2, 2, 623, 626, 3, 2, 2, 2, 624, 622, 3, 2, 2, 2, 624, 625, 3, 2, 2,
	2, 625, 85, 3, 2, 2, 2, 626, 624, 3, 2, 2, 2, 627, 629, 7, 63, 2, 2, 628,
	630, 5, 88, 45, 2, 629, 628, 3, 2, 2, 2, 629, 630, 3, 2, 2, 2, 630, 631,
	3, 2, 2, 2, 631, 632, 7, 64, 2, 2, 632, 87, 3, 2, 2, 2, 633, 638, 5, 90,
	46, 2, 634, 635, 7, 70, 2, 2, 635, 637, 5, 90, 46, 2, 636, 634, 3, 2, 2,
	2, 637, 640, 3, 2, 2, 2, 638, 636, 3, 2, 2, 2, 638, 639, 3, 2, 2, 2, 639,
	643, 3, 2, 2, 2, 640, 638, 3, 2, 2, 2, 641, 642, 7, 70, 2, 2, 642, 644,
	5, 92, 47, 2, 643, 641, 3, 2, 2, 2, 643, 644, 3, 2, 2, 2, 644, 647, 3,
	2, 2, 2, 645, 647, 5, 92, 47, 2, 646, 633, 3, 2, 2, 2, 646, 645, 3, 2,
	2, 2, 647, 89, 3, 2, 2, 2, 648, 650, 5, 14, 8, 2, 649, 648, 3, 2, 2, 2,
	650, 653, 3, 2, 2, 2, 651, 649, 3, 2, 2, 2, 651, 652, 3, 2, 2, 2, 652,
	654, 3, 2, 2, 2, 653, 651, 3, 2, 2, 2, 654, 655, 5, 198, 100, 2, 655, 656,
	5, 74, 38, 2, 656, 91, 3, 2, 2, 2, 657, 659, 5, 14, 8, 2, 658, 657, 3,
	2, 2, 2, 659, 662, 3, 2, 2, 2, 660, 658, 3, 2, 2, 2, 660, 661, 3, 2, 2,
	2, 661, 663, 3, 2, 2, 2, 662, 660, 3, 2, 2, 2, 663, 664, 5, 198, 100, 2,
	664, 665, 7, 109, 2, 2, 665, 666, 5, 74, 38, 2, 666, 93, 3, 2, 2, 2, 667,
	672, 7, 113, 2, 2, 668, 669, 7, 71, 2, 2, 669, 671, 7, 113, 2, 2, 670,
	668, 3, 2, 2, 2, 671, 674, 3, 2, 2, 2, 672, 670, 3, 2, 2, 2, 672, 673,
	3, 2, 2, 2, 673, 95, 3, 2, 2, 2, 674, 672, 3, 2, 2, 2, 675, 682, 5, 98,
	50, 2, 676, 682, 5, 100, 51, 2, 677, 682, 7, 60, 2, 2, 678, 682, 7, 61,
	2, 2, 679, 682, 7, 59, 2, 2, 680, 682, 7, 62, 2, 2, 681, 675, 3, 2, 2,
	2, 681, 676, 3, 2, 2, 2, 681, 677, 3, 2, 2, 2, 681, 678, 3, 2, 2, 2, 681,
	679, 3, 2, 2, 2, 681, 680, 3, 2, 2, 2, 682, 97, 3, 2, 2, 2, 683, 684, 9,
	3, 2, 2, 684, 99, 3, 2, 2, 2, 685, 686, 9, 4, 2, 2, 686, 101, 3, 2, 2,
	2, 687, 688, 7, 108, 2, 2, 688, 695, 5, 94, 48, 2, 689, 692, 7, 63, 2,
	2, 690, 693, 5, 104, 53, 2, 691, 693, 5, 108, 55, 2, 692, 690, 3, 2, 2,
	2, 692, 691, 3, 2, 2, 2, 692, 693, 3, 2, 2, 2, 693, 694, 3, 2, 2, 2, 694,
	696, 7, 64, 2, 2, 695, 689, 3, 2, 2, 2, 695, 696, 3, 2, 2, 2, 696, 103,
	3, 2, 2, 2, 697, 702, 5, 106, 54, 2, 698, 699, 7, 70, 2, 2, 699, 701, 5,
	106, 54, 2, 700, 698, 3, 2, 2, 2, 701, 704, 3, 2, 2, 2, 702, 700, 3, 2,
	2, 2, 702, 703, 3, 2, 2, 2, 703, 105, 3, 2, 2, 2, 704, 702, 3, 2, 2, 2,
	705, 706, 7, 113, 2, 2, 706, 707, 7, 72, 2, 2, 707, 708, 5, 108, 55, 2,
	708, 107, 3, 2, 2, 2, 709, 713, 5, 166, 84, 2, 710, 713, 5, 102, 52, 2,
	711, 713, 5, 110, 56, 2, 712, 709, 3, 2, 2, 2, 712, 710, 3, 2, 2, 2, 712,
	711, 3, 2, 2, 2, 713, 109, 3, 2, 2, 2, 714, 723, 7, 65, 2, 2, 715, 720,
	5, 108, 55, 2, 716, 717, 7, 70, 2, 2, 717, 719, 5, 108, 55, 2, 718, 716,
	3, 2, 2, 2, 719, 722, 3, 2, 2, 2, 720, 718, 3, 2, 2, 2, 720, 721, 3, 2,
	2, 2, 721, 724, 3, 2, 2, 2, 722, 720, 3, 2, 2, 2, 723, 715, 3, 2, 2, 2,
	723, 724, 3, 2, 2, 2, 724, 726, 3, 2, 2, 2, 725, 727, 7, 70, 2, 2, 726,
	725, 3, 2, 2, 2, 726, 727, 3, 2, 2, 2, 727, 728, 3, 2, 2, 2, 728, 729,
	7, 66, 2, 2, 729, 111, 3, 2, 2, 2, 730, 731, 7, 108, 2, 2, 731, 732, 7,
	30, 2, 2, 732, 733, 7, 113, 2, 2, 733, 734, 5, 114, 58, 2, 734, 113, 3,
	2, 2, 2, 735, 739, 7, 65, 2, 2, 736, 738, 5, 116, 59, 2, 737, 736, 3, 2,
	2, 2, 738, 741, 3, 2, 2, 2, 739, 737, 3, 2, 2, 2, 739, 740, 3, 2, 2, 2,
	740, 742, 3, 2, 2, 2, 741, 739, 3, 2, 2, 2, 742, 743, 7, 66, 2, 2, 743,
	115, 3, 2, 2, 2, 744, 746, 5, 10, 6, 2, 745, 744, 3, 2, 2, 2, 746, 749,
	3, 2, 2, 2, 747, 745, 3, 2, 2, 2, 747, 748, 3, 2, 2, 2, 748, 750, 3, 2,
	2, 2, 749, 747, 3, 2, 2, 2, 750, 753, 5, 118, 60, 2, 751, 753, 7, 69, 2,
	2, 752, 747, 3, 2, 2, 2, 752, 751, 3, 2, 2, 2, 753, 117, 3, 2, 2, 2, 754,
	755, 5, 198, 100, 2, 755, 756, 5, 120, 61, 2, 756, 757, 7, 69, 2, 2, 757,
	775, 3, 2, 2, 2, 758, 760, 5, 16, 9, 2, 759, 761, 7, 69, 2, 2, 760, 759,
	3, 2, 2, 2, 760, 761, 3, 2, 2, 2, 761, 775, 3, 2, 2, 2, 762, 764, 5, 32,
	17, 2, 763, 765, 7, 69, 2, 2, 764, 763, 3, 2, 2, 2, 764, 765, 3, 2, 2,
	2, 765, 775, 3, 2, 2, 2, 766, 768, 5, 24, 13, 2, 767, 769, 7, 69, 2, 2,
	768, 767, 3, 2, 2, 2, 768, 769, 3, 2, 2, 2, 769, 775, 3, 2, 2, 2, 770,
	772, 5, 112, 57, 2, 771, 773, 7, 69, 2, 2, 772, 771, 3, 2, 2, 2, 772, 773,
	3, 2, 2, 2, 773, 775, 3, 2, 2, 2, 774, 754, 3, 2, 2, 2, 774, 758, 3, 2,
	2, 2, 774, 762, 3, 2, 2, 2, 774, 766, 3, 2, 2, 2, 774, 770, 3, 2, 2, 2,
	775, 119, 3, 2, 2, 2, 776, 779, 5, 122, 62, 2, 777, 779, 5, 124, 63, 2,
	778, 776, 3, 2, 2, 2, 778, 777, 3, 2, 2, 2, 779, 121, 3, 2, 2, 2, 780,
	781, 7, 113, 2, 2, 781, 782, 7, 63, 2, 2, 782, 784, 7, 64, 2, 2, 783, 785,
	5, 126, 64, 2, 784, 783, 3, 2, 2, 2, 784, 785, 3, 2, 2, 2, 785, 123, 3,
	2, 2, 2, 786, 787, 5, 70, 36, 2, 787, 125, 3, 2, 2, 2, 788, 789, 7, 14,
	2, 2, 789, 790, 5, 108, 55, 2, 790, 127, 3, 2, 2, 2, 791, 795, 7, 65, 2,
	2, 792, 794, 5, 130, 66, 2, 793, 792, 3, 2, 2, 2, 794, 797, 3, 2, 2, 2,
	795, 793, 3, 2, 2, 2, 795, 796, 3, 2, 2, 2, 796, 798, 3, 2, 2, 2, 797,
	795, 3, 2, 2, 2, 798, 799, 7, 66, 2, 2, 799, 129, 3, 2, 2, 2, 800, 801,
	5, 132, 67, 2, 801, 802, 7, 69, 2, 2, 802, 806, 3, 2, 2, 2, 803, 806, 5,
	136, 69, 2, 804, 806, 5, 134, 68, 2, 805, 800, 3, 2, 2, 2, 805, 803, 3,
	2, 2, 2, 805, 804, 3, 2, 2, 2, 806, 131, 3, 2, 2, 2, 807, 809, 5, 14, 8,
	2, 808, 807, 3, 2, 2, 2, 809, 812, 3, 2, 2, 2, 810, 808, 3, 2, 2, 2, 810,
	811, 3, 2, 2, 2, 811, 813, 3, 2, 2, 2, 812, 810, 3, 2, 2, 2, 813, 814,
	5, 198, 100, 2, 814, 815, 5, 70, 36, 2, 815, 133, 3, 2, 2, 2, 816, 818,
	5, 12, 7, 2, 817, 816, 3, 2, 2, 2, 818, 821, 3, 2, 2, 2, 819, 817, 3, 2,
	2, 2, 819, 820, 3, 2, 2, 2, 820, 824, 3, 2, 2, 2, 821, 819, 3, 2, 2, 2,
	822, 825, 5, 16, 9, 2, 823, 825, 5, 32, 17, 2, 824, 822, 3, 2, 2, 2, 824,
	823, 3, 2, 2, 2, 825, 828, 3, 2, 2, 2, 826, 828, 7, 69, 2, 2, 827, 819,
	3, 2, 2, 2, 827, 826, 3, 2, 2, 2, 828, 135, 3, 2, 2, 2, 829, 934, 5, 128,
	65, 2, 830, 831, 7, 4, 2, 2, 831, 834, 5, 166, 84, 2, 832, 833, 7, 78,
	2, 2, 833, 835, 5, 166, 84, 2, 834, 832, 3, 2, 2, 2, 834, 835, 3, 2, 2,
	2, 835, 836, 3, 2, 2, 2, 836, 837, 7, 69, 2, 2, 837, 934, 3, 2, 2, 2, 838,
	839, 7, 24, 2, 2, 839, 840, 5, 160, 81, 2, 840, 843, 5, 136, 69, 2, 841,
	842, 7, 17, 2, 2, 842, 844, 5, 136, 69, 2, 843, 841, 3, 2, 2, 2, 843, 844,
	3, 2, 2, 2, 844, 934, 3, 2, 2, 2, 845, 846, 7, 23, 2, 2, 846, 847, 7, 63,
	2, 2, 847, 848, 5, 154, 78, 2, 848, 849, 7, 64, 2, 2, 849, 850, 5, 136,
	69, 2, 850, 934, 3, 2, 2, 2, 851, 852, 7, 52, 2, 2, 852, 853, 5, 160, 81,
	2, 853, 854, 5, 136, 69, 2, 854, 934, 3, 2, 2, 2, 855, 856, 7, 15, 2, 2,
	856, 857, 5, 136, 69, 2, 857, 858, 7, 52, 2, 2, 858, 859, 5, 160, 81, 2,
	859, 860, 7, 69, 2, 2, 860, 934, 3, 2, 2, 2, 861, 862, 7, 49, 2, 2, 862,
	872, 5, 128, 65, 2, 863, 865, 5, 138, 70, 2, 864, 863, 3, 2, 2, 2, 865,
	866, 3, 2, 2, 2, 866, 864, 3, 2, 2, 2, 866, 867, 3, 2, 2, 2, 867, 869,
	3, 2, 2, 2, 868, 870, 5, 142, 72, 2, 869, 868, 3, 2, 2, 2, 869, 870, 3,
	2, 2, 2, 870, 873, 3, 2, 2, 2, 871, 873, 5, 142, 72, 2, 872, 864, 3, 2,
	2, 2, 872, 871, 3, 2, 2, 2, 873, 934, 3, 2, 2, 2, 874, 875, 7, 49, 2, 2,
	875, 876, 5, 144, 73, 2, 876, 880, 5, 128, 65, 2, 877, 879, 5, 138, 70,
	2, 878, 877, 3, 2, 2, 2, 879, 882, 3, 2, 2, 2, 880, 878, 3, 2, 2, 2, 880,
	881, 3, 2, 2, 2, 881, 884, 3, 2, 2, 2, 882, 880, 3, 2, 2, 2, 883, 885,
	5, 142, 72, 2, 884, 883, 3, 2, 2, 2, 884, 885, 3, 2, 2, 2, 885, 934, 3,
	2, 2, 2, 886, 887, 7, 43, 2, 2, 887, 888, 5, 160, 81, 2, 888, 892, 7, 65,
	2, 2, 889, 891, 5, 150, 76, 2, 890, 889, 3, 2, 2, 2, 891, 894, 3, 2, 2,
	2, 892, 890, 3, 2, 2, 2, 892, 893, 3, 2, 2, 2, 893, 898, 3, 2, 2, 2, 894,
	892, 3, 2, 2, 2, 895, 897, 5, 152, 77, 2, 896, 895, 3, 2, 2, 2, 897, 900,
	3, 2, 2, 2, 898, 896, 3, 2, 2, 2, 898, 899, 3, 2, 2, 2, 899, 901, 3, 2,
	2, 2, 900, 898, 3, 2, 2, 2, 901, 902, 7, 66, 2, 2, 902, 934, 3, 2, 2, 2,
	903, 904, 7, 44, 2, 2, 904, 905, 5, 160, 81, 2, 905, 906, 5, 128, 65, 2,
	906, 934, 3, 2, 2, 2, 907, 909, 7, 38, 2, 2, 908, 910, 5, 166, 84, 2, 909,
	908, 3, 2, 2, 2, 909, 910, 3, 2, 2, 2, 910, 911, 3, 2, 2, 2, 911, 934,
	7, 69, 2, 2, 912, 913, 7, 46, 2, 2, 913, 914, 5, 166, 84, 2, 914, 915,
	7, 69, 2, 2, 915, 934, 3, 2, 2, 2, 916, 918, 7, 6, 2, 2, 917, 919, 7, 113,
	2, 2, 918, 917, 3, 2, 2, 2, 918, 919, 3, 2, 2, 2, 919, 920, 3, 2, 2, 2,
	920, 934, 7, 69, 2, 2, 921, 923, 7, 13, 2, 2, 922, 924, 7, 113, 2, 2, 923,
	922, 3, 2, 2, 2, 923, 924, 3, 2, 2, 2, 924, 925, 3, 2, 2, 2, 925, 934,
	7, 69, 2, 2, 926, 934, 7, 69, 2, 2, 927, 928, 5, 166, 84, 2, 928, 929,
	7, 69, 2, 2, 929, 934, 3, 2, 2, 2, 930, 931, 7, 113, 2, 2, 931, 932, 7,
	78, 2, 2, 932, 934, 5, 136, 69, 2, 933, 829, 3, 2, 2, 2, 933, 830, 3, 2,
	2, 2, 933, 838, 3, 2, 2, 2, 933, 845, 3, 2, 2, 2, 933, 851, 3, 2, 2, 2,
	933, 855, 3, 2, 2, 2, 933, 861, 3, 2, 2, 2, 933, 874, 3, 2, 2, 2, 933,
	886, 3, 2, 2, 2, 933, 903, 3, 2, 2, 2, 933, 907, 3, 2, 2, 2, 933, 912,
	3, 2, 2, 2, 933, 916, 3, 2, 2, 2, 933, 921, 3, 2, 2, 2, 933, 926, 3, 2,
	2, 2, 933, 927, 3, 2, 2, 2, 933, 930, 3, 2, 2, 2, 934, 137, 3, 2, 2, 2,
	935, 936, 7, 9, 2, 2, 936, 940, 7, 63, 2, 2, 937, 939, 5, 14, 8, 2, 938,
	937, 3, 2, 2, 2, 939, 942, 3, 2, 2, 2, 940, 938, 3, 2, 2, 2, 940, 941,
	3, 2, 2, 2, 941, 943, 3, 2, 2, 2, 942, 940, 3, 2, 2, 2, 943, 944, 5, 140,
	71, 2, 944, 945, 7, 113, 2, 2, 945, 946, 7, 64, 2, 2, 946, 947, 5, 128,
	65, 2, 947, 139, 3, 2, 2, 2, 948, 953, 5, 94, 48, 2, 949, 950, 7, 92, 2,
	2, 950, 952, 5, 94, 48, 2, 951, 949, 3, 2, 2, 2, 952, 955, 3, 2, 2, 2,
	953, 951, 3, 2, 2, 2, 953, 954, 3, 2, 2, 2, 954, 141, 3, 2, 2, 2, 955,
	953, 3, 2, 2, 2, 956, 957, 7, 21, 2, 2, 957, 958, 5, 128, 65, 2, 958, 143,
	3, 2, 2, 2, 959, 960, 7, 63, 2, 2, 960, 962, 5, 146, 74, 2, 961, 963, 7,
	69, 2, 2, 962, 961, 3, 2, 2, 2, 962, 963, 3, 2, 2, 2, 963, 964, 3, 2, 2,
	2, 964, 965, 7, 64, 2, 2, 965, 145, 3, 2, 2, 2, 966, 971, 5, 148, 75, 2,
	967, 968, 7, 69, 2, 2, 968, 970, 5, 148, 75, 2, 969, 967, 3, 2, 2, 2, 970,
	973, 3, 2, 2, 2, 971, 969, 3, 2, 2, 2, 971, 972, 3, 2, 2, 2, 972, 147,
	3, 2, 2, 2, 973, 971, 3, 2, 2, 2, 974, 976, 5, 14, 8, 2, 975, 974, 3, 2,
	2, 2, 976, 979, 3, 2, 2, 2, 977, 975, 3, 2, 2, 2, 977, 978, 3, 2, 2, 2,
	978, 980, 3, 2, 2, 2, 979, 977, 3, 2, 2, 2, 980, 981, 5, 80, 41, 2, 981,
	982, 5, 74, 38, 2, 982, 983, 7, 72, 2, 2, 983, 984, 5, 166, 84, 2, 984,
	149, 3, 2, 2, 2, 985, 987, 5, 152, 77, 2, 986, 985, 3, 2, 2, 2, 987, 988,
	3, 2, 2, 2, 988, 986, 3, 2, 2, 2, 988, 989, 3, 2, 2, 2, 989, 991, 3, 2,
	2, 2, 990, 992, 5, 130, 66, 2, 991, 990, 3, 2, 2, 2, 992, 993, 3, 2, 2,
	2, 993, 991, 3, 2, 2, 2, 993, 994, 3, 2, 2, 2, 994, 151, 3, 2, 2, 2, 995,
	998, 7, 8, 2, 2, 996, 999, 5, 166, 84, 2, 997, 999, 7, 113, 2, 2, 998,
	996, 3, 2, 2, 2, 998, 997, 3, 2, 2, 2, 999, 1000, 3, 2, 2, 2, 1000, 1004,
	7, 78, 2, 2, 1001, 1002, 7, 14, 2, 2, 1002, 1004, 7, 78, 2, 2, 1003, 995,
	3, 2, 2, 2, 1003, 1001, 3, 2, 2, 2, 1004, 153, 3, 2, 2, 2, 1005, 1018,
	5, 158, 80, 2, 1006, 1008, 5, 156, 79, 2, 1007, 1006, 3, 2, 2, 2, 1007,
	1008, 3, 2, 2, 2, 1008, 1009, 3, 2, 2, 2, 1009, 1011, 7, 69, 2, 2, 1010,
	1012, 5, 166, 84, 2, 1011, 1010, 3, 2, 2, 2, 1011, 1012, 3, 2, 2, 2, 1012,
	1013, 3, 2, 2, 2, 1013, 1015, 7, 69, 2, 2, 1014, 1016, 5, 162, 82, 2, 1015,
	1014, 3, 2, 2, 2, 1015, 1016, 3, 2, 2, 2, 1016, 1018, 3, 2, 2, 2, 1017,
	1005, 3, 2, 2, 2, 1017, 1007, 3, 2, 2, 2, 1018, 155, 3, 2, 2, 2, 1019,
	1022, 5, 132, 67, 2, 1020, 1022, 5, 162, 82, 2, 1021, 1019, 3, 2, 2, 2,
	1021, 1020, 3, 2, 2, 2, 1022, 157, 3, 2, 2, 2, 1023, 1025, 5, 14, 8, 2,
	1024, 1023, 3, 2, 2, 2, 1025, 1028, 3, 2, 2, 2, 1026, 1024, 3, 2, 2, 2,
	1026, 1027, 3, 2, 2, 2, 1027, 1029, 3, 2, 2, 2, 1028, 1026, 3, 2, 2, 2,
	1029, 1030, 5, 198, 100, 2, 1030, 1031, 5, 74, 38, 2, 1031, 1032, 7, 78,
	2, 2, 1032, 1033, 5, 166, 84, 2, 1033, 159, 3, 2, 2, 2, 1034, 1035, 7,
	63, 2, 2, 1035, 1036, 5, 166, 84, 2, 1036, 1037, 7, 64, 2, 2, 1037, 161,
	3, 2, 2, 2, 1038, 1043, 5, 166, 84, 2, 1039, 1040, 7, 70, 2, 2, 1040, 1042,
	5, 166, 84, 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, 163, 3, 2, 2, 2, 1045, 1043,
	3, 2, 2, 2, 1046, 1047, 7, 113, 2, 2, 1047, 1049, 7, 63, 2, 2, 1048, 1050,
	5, 162, 82, 2, 1049, 1048, 3, 2, 2, 2, 1049, 1050, 3, 2, 2, 2, 1050, 1051,
	3, 2, 2, 2, 1051, 1065, 7, 64, 2, 2, 1052, 1053, 7, 45, 2, 2, 1053, 1055,
	7, 63, 2, 2, 1054, 1056, 5, 162, 82, 2, 1055, 1054, 3, 2, 2, 2, 1055, 1056,
	3, 2, 2, 2, 1056, 1057, 3, 2, 2, 2, 1057, 1065, 7, 64, 2, 2, 1058, 1059,
	7, 42, 2, 2, 1059, 1061, 7, 63, 2, 2, 1060, 1062, 5, 162, 82, 2, 1061,
	1060, 3, 2, 2, 2, 1061, 1062, 3, 2, 2, 2, 1062, 1063, 3, 2, 2, 2, 1063,
	1065, 7, 64, 2, 2, 1064, 1046, 3, 2, 2, 2, 1064, 1052, 3, 2, 2, 2, 1064,
	1058, 3, 2, 2, 2, 1065, 165, 3, 2, 2, 2, 1066, 1067, 8, 84, 1, 2, 1067,
	1098, 5, 174, 88, 2, 1068, 1098, 5, 164, 83, 2, 1069, 1070, 7, 33, 2, 2,
	1070, 1098, 5, 178, 90, 2, 1071, 1072, 7, 63, 2, 2, 1072, 1073, 5, 198,
	100, 2, 1073, 1074, 7, 64, 2, 2, 1074, 1075, 5, 166, 84, 23, 1075, 1098,
	3, 2, 2, 2, 1076, 1077, 9, 5, 2, 2, 1077, 1098, 5, 166, 84, 21, 1078, 1079,
	9, 6, 2, 2, 1079, 1098, 5, 166, 84, 20, 1080, 1098, 5, 168, 85, 2, 1081,
	1082, 5, 198, 100, 2, 1082, 1088, 7, 107, 2, 2, 1083, 1085, 5, 202, 102,
	2, 1084, 1083, 3, 2, 2, 2, 1084, 1085, 3, 2, 2, 2, 1085, 1086, 3, 2, 2,
	2, 1086, 1089, 7, 113, 2, 2, 1087, 1089, 7, 33, 2, 2, 1088, 1084, 3, 2,
	2, 2, 1088, 1087, 3, 2, 2, 2, 1089, 1098, 3, 2, 2, 2, 1090, 1091, 5, 176,
	89, 2, 1091, 1093, 7, 107, 2, 2, 1092, 1094, 5, 202, 102, 2, 1093, 1092,
	3, 2, 2, 2, 1093, 1094, 3, 2, 2, 2, 1094, 1095, 3, 2, 2, 2, 1095, 1096,
	7, 33, 2, 2, 1096, 1098, 3, 2, 2, 2, 1097, 1066, 3, 2, 2, 2, 1097, 1068,
	3, 2, 2, 2, 1097, 1069, 3, 2, 2, 2, 1097, 1071, 3, 2, 2, 2, 1097, 1076,
	3, 2, 2, 2, 1097, 1078, 3, 2, 2, 2, 1097, 1080, 3, 2, 2, 2, 1097, 1081,
	3, 2, 2, 2, 1097, 1090, 3, 2, 2, 2, 1098, 1179, 3, 2, 2, 2, 1099, 1100,
	12, 19, 2, 2, 1100, 1101, 9, 7, 2, 2, 1101, 1178, 5, 166, 84, 20, 1102,
	1103, 12, 18, 2, 2, 1103, 1104, 9, 8, 2, 2, 1104, 1178, 5, 166, 84, 19,
	1105, 1113, 12, 17, 2, 2, 1106, 1107, 7, 74, 2, 2, 1107, 1114, 7, 74, 2,
	2, 1108, 1109, 7, 73, 2, 2, 1109, 1110, 7, 73, 2, 2, 1110, 1114, 7, 73,
	2, 2, 1111, 1112, 7, 73, 2, 2, 1112, 1114, 7, 73, 2, 2, 1113, 1106, 3,
	2, 2, 2, 1113, 1108, 3, 2, 2, 2, 1113, 1111, 3, 2, 2, 2, 1114, 1115, 3,
	2, 2, 2, 1115, 1178, 5, 166, 84, 18, 1116, 1117, 12, 16, 2, 2, 1117, 1118,
	9, 9, 2, 2, 1118, 1178, 5, 166, 84, 17, 1119, 1120, 12, 14, 2, 2, 1120,
	1121, 9, 10, 2, 2, 1121, 1178, 5, 166, 84, 15, 1122, 1123, 12, 13, 2, 2,
	1123, 1124, 7, 91, 2, 2, 1124, 1178, 5, 166, 84, 14, 1125, 1126, 12, 12,
	2, 2, 1126, 1127, 7, 93, 2, 2, 1127, 1178, 5, 166, 84, 13, 1128, 1129,
	12, 11, 2, 2, 1129, 1130, 7, 92, 2, 2, 1130, 1178, 5, 166, 84, 12, 1131,
	1132, 12, 10, 2, 2, 1132, 1133, 7, 83, 2, 2, 1133, 1178, 5, 166, 84, 11,
	1134, 1135, 12, 9, 2, 2, 1135, 1136, 7, 84, 2, 2, 1136, 1178, 5, 166, 84,
	10, 1137, 1138, 12, 8, 2, 2, 1138, 1139, 7, 77, 2, 2, 1139, 1140, 5, 166,
	84, 2, 1140, 1141, 7, 78, 2, 2, 1141, 1142, 5, 166, 84, 8, 1142, 1178,
	3, 2, 2, 2, 1143, 1144, 12, 7, 2, 2, 1144, 1145, 9, 11, 2, 2, 1145, 1178,
	5, 166, 84, 7, 1146, 1147, 12, 27, 2, 2, 1147, 1159, 7, 71, 2, 2, 1148,
	1160, 7, 113, 2, 2, 1149, 1160, 5, 164, 83, 2, 1150, 1160, 7, 45, 2, 2,
	1151, 1153, 7, 33, 2, 2, 1152, 1154, 5, 194, 98, 2, 1153, 1152, 3, 2, 2,
	2, 1153, 1154, 3, 2, 2, 2, 1154, 1155, 3, 2, 2, 2, 1155, 1160, 5, 182,
	92, 2, 1156, 1157, 7, 42, 2, 2, 1157, 1160, 5, 204, 103, 2, 1158, 1160,
	5, 188, 95, 2, 1159, 1148, 3, 2, 2, 2, 1159, 1149, 3, 2, 2, 2, 1159, 1150,
	3, 2, 2, 2, 1159, 1151, 3, 2, 2, 2, 1159, 1156, 3, 2, 2, 2, 1159, 1158,
	3, 2, 2, 2, 1160, 1178, 3, 2, 2, 2, 1161, 1162, 12, 26, 2, 2, 1162, 1163,
	7, 67, 2, 2, 1163, 1164, 5, 166, 84, 2, 1164, 1165, 7, 68, 2, 2, 1165,
	1178, 3, 2, 2, 2, 1166, 1167, 12, 22, 2, 2, 1167, 1178, 9, 12, 2, 2, 1168,
	1169, 12, 15, 2, 2, 1169, 1170, 7, 28, 2, 2, 1170, 1178, 5, 198, 100, 2,
	1171, 1172, 12, 5, 2, 2, 1172, 1174, 7, 107, 2, 2, 1173, 1175, 5, 202,
	102, 2, 1174, 1173, 3, 2, 2, 2, 1174, 1175, 3, 2, 2, 2, 1175, 1176, 3,
	2, 2, 2, 1176, 1178, 7, 113, 2, 2, 1177, 1099, 3, 2, 2, 2, 1177, 1102,
	3, 2, 2, 2, 1177, 1105, 3, 2, 2, 2, 1177, 1116, 3, 2, 2, 2, 1177, 1119,
	3, 2, 2, 2, 1177, 1122, 3, 2, 2, 2, 1177, 1125, 3, 2, 2, 2, 1177, 1128,
	3, 2, 2, 2, 1177, 1131, 3, 2, 2, 2, 1177, 1134, 3, 2, 2, 2, 1177, 1137,
	3, 2, 2, 2, 1177, 1143, 3, 2, 2, 2, 1177, 1146, 3, 2, 2, 2, 1177, 1161,
	3, 2, 2, 2, 1177, 1166, 3, 2, 2, 2, 1177, 1168, 3, 2, 2, 2, 1177, 1171,
	3, 2, 2, 2, 1178, 1181, 3, 2, 2, 2, 1179, 1177, 3, 2, 2, 2, 1179, 1180,
	3, 2, 2, 2, 1180, 167, 3, 2, 2, 2, 1181, 1179, 3, 2, 2, 2, 1182, 1183,
	5, 170, 86, 2, 1183, 1184, 7, 106, 2, 2, 1184, 1185, 5, 172, 87, 2, 1185,
	169, 3, 2, 2, 2, 1186, 1203, 7, 113, 2, 2, 1187, 1189, 7, 63, 2, 2, 1188,
	1190, 5, 88, 45, 2, 1189, 1188, 3, 2, 2, 2, 1189, 1190, 3, 2, 2, 2, 1190,
	1191, 3, 2, 2, 2, 1191, 1203, 7, 64, 2, 2, 1192, 1193, 7, 63, 2, 2, 1193,
	1198, 7, 113, 2, 2, 1194, 1195, 7, 70, 2, 2, 1195, 1197, 7, 113, 2, 2,
	1196, 1194, 3, 2, 2, 2, 1197, 1200, 3, 2, 2, 2, 1198, 1196, 3, 2, 2, 2,
	1198, 1199, 3, 2, 2, 2, 1199, 1201, 3, 2, 2, 2, 1200, 1198, 3, 2, 2, 2,
	1201, 1203, 7, 64, 2, 2, 1202, 1186, 3, 2, 2, 2, 1202, 1187, 3, 2, 2, 2,
	1202, 1192, 3, 2, 2, 2, 1203, 171, 3, 2, 2, 2, 1204, 1207, 5, 166, 84,
	2, 1205, 1207, 5, 128, 65, 2, 1206, 1204, 3, 2, 2, 2, 1206, 1205, 3, 2,
	2, 2, 1207, 173, 3, 2, 2, 2, 1208, 1209, 7, 63, 2, 2, 1209, 1210, 5, 166,
	84, 2, 1210, 1211, 7, 64, 2, 2, 1211, 1227, 3, 2, 2, 2, 1212, 1227, 7,
	45, 2, 2, 1213, 1227, 7, 42, 2, 2, 1214, 1227, 5, 96, 49, 2, 1215, 1227,
	7, 113, 2, 2, 1216, 1217, 5, 46, 24, 2, 1217, 1218, 7, 71, 2, 2, 1218,
	1219, 7, 11, 2, 2, 1219, 1227, 3, 2, 2, 2, 1220, 1224, 5, 194, 98, 2, 1221,
	1225, 5, 206, 104, 2, 1222, 1223, 7, 45, 2, 2, 1223, 1225, 5, 208, 105,
	2, 1224, 1221, 3, 2, 2, 2, 1224, 1222, 3, 2, 2, 2, 1225, 1227, 3, 2, 2,
	2, 1226, 1208, 3, 2, 2, 2, 1226, 1212, 3, 2, 2, 2, 1226, 1213, 3, 2, 2,
	2, 1226, 1214, 3, 2, 2, 2, 1226, 1215, 3, 2, 2, 2, 1226, 1216, 3, 2, 2,
	2, 1226, 1220, 3, 2, 2, 2, 1227, 175, 3, 2, 2, 2, 1228, 1229, 5, 80, 41,
	2, 1229, 1230, 7, 71, 2, 2, 1230, 1232, 3, 2, 2, 2, 1231, 1228, 3, 2, 2,
	2, 1231, 1232, 3, 2, 2, 2, 1232, 1236, 3, 2, 2, 2, 1233, 1235, 5, 102,
	52, 2, 1234, 1233, 3, 2, 2, 2, 1235, 1238, 3, 2, 2, 2, 1236, 1234, 3, 2,
	2, 2, 1236, 1237, 3, 2, 2, 2, 1237, 1239, 3, 2, 2, 2, 1238, 1236, 3, 2,
	2, 2, 1239, 1241, 7, 113, 2, 2, 1240, 1242, 5, 202, 102, 2, 1241, 1240,
	3, 2, 2, 2, 1241, 1242, 3, 2, 2, 2, 1242, 177, 3, 2, 2, 2, 1243, 1244,
	5, 194, 98, 2, 1244, 1245, 5, 180, 91, 2, 1245, 1246, 5, 186, 94, 2, 1246,
	1253, 3, 2, 2, 2, 1247, 1250, 5, 180, 91, 2, 1248, 1251, 5, 184, 93, 2,
	1249, 1251, 5, 186, 94, 2, 1250, 1248, 3, 2, 2, 2, 1250, 1249, 3, 2, 2,
	2, 1251, 1253, 3, 2, 2, 2, 1252, 1243, 3, 2, 2, 2, 1252, 1247, 3, 2, 2,
	2, 1253, 179, 3, 2, 2, 2, 1254, 1256, 7, 113, 2, 2, 1255, 1257, 5, 190,
	96, 2, 1256, 1255, 3, 2, 2, 2, 1256, 1257, 3, 2, 2, 2, 1257, 1265, 3, 2,
	2, 2, 1258, 1259, 7, 71, 2, 2, 1259, 1261, 7, 113, 2, 2, 1260, 1262, 5,
	190, 96, 2, 1261, 1260, 3, 2, 2, 2, 1261, 1262, 3, 2, 2, 2, 1262, 1264,
	3, 2, 2, 2, 1263, 1258, 3, 2, 2, 2, 1264, 1267, 3, 2, 2, 2, 1265, 1263,
	3, 2, 2, 2, 1265, 1266, 3, 2, 2, 2, 1266, 1270, 3, 2, 2, 2, 1267, 1265,
	3, 2, 2, 2, 1268, 1270, 5, 200, 101, 2, 1269, 1254, 3, 2, 2, 2, 1269, 1268,
	3, 2, 2, 2, 1270, 181, 3, 2, 2, 2, 1271, 1273, 7, 113, 2, 2, 1272, 1274,
	5, 192, 97, 2, 1273, 1272, 3, 2, 2, 2, 1273, 1274, 3, 2, 2, 2, 1274, 1275,
	3, 2, 2, 2, 1275, 1276, 5, 186, 94, 2, 1276, 183, 3, 2, 2, 2, 1277, 1305,
	7, 67, 2, 2, 1278, 1283, 7, 68, 2, 2, 1279, 1280, 7, 67, 2, 2, 1280, 1282,
	7, 68, 2, 2, 1281, 1279, 3, 2, 2, 2, 1282, 1285, 3, 2, 2, 2, 1283, 1281,
	3, 2, 2, 2, 1283, 1284, 3, 2, 2, 2, 1284, 1286, 3, 2, 2, 2, 1285, 1283,
	3, 2, 2, 2, 1286, 1306, 5, 78, 40, 2, 1287, 1288, 5, 166, 84, 2, 1288,
	1295, 7, 68, 2, 2, 1289, 1290, 7, 67, 2, 2, 1290, 1291, 5, 166, 84, 2,
	1291, 1292, 7, 68, 2, 2, 1292, 1294, 3, 2, 2, 2, 1293, 1289, 3, 2, 2, 2,
	1294, 1297, 3, 2, 2, 2, 1295, 1293, 3, 2, 2, 2, 1295, 1296, 3, 2, 2, 2,
	1296, 1302, 3, 2, 2, 2, 1297, 1295, 3, 2, 2, 2, 1298, 1299, 7, 67, 2, 2,
	1299, 1301, 7, 68, 2, 2, 1300, 1298, 3, 2, 2, 2, 1301, 1304, 3, 2, 2, 2,
	1302, 1300, 3, 2, 2, 2, 1302, 1303, 3, 2, 2, 2, 1303, 1306, 3, 2, 2, 2,
	1304, 1302, 3, 2, 2, 2, 1305, 1278, 3, 2, 2, 2, 1305, 1287, 3, 2, 2, 2,
	1306, 185, 3, 2, 2, 2, 1307, 1309, 5, 208, 105, 2, 1308, 1310, 5, 34, 18,
	2, 1309, 1308, 3, 2, 2, 2, 1309, 1310, 3, 2, 2, 2, 1310, 187, 3, 2, 2,
	2, 1311, 1312, 5, 194, 98, 2, 1312, 1313, 5, 206, 104, 2, 1313, 189, 3,
	2, 2, 2, 1314, 1315, 7, 74, 2, 2, 1315, 1318, 7, 73, 2, 2, 1316, 1318,
	5, 202, 102, 2, 1317, 1314, 3, 2, 2, 2, 1317, 1316, 3, 2, 2, 2, 1318, 191,
	3, 2, 2, 2, 1319, 1320, 7, 74, 2, 2, 1320, 1323, 7, 73, 2, 2, 1321, 1323,
	5, 194, 98, 2, 1322, 1319, 3, 2, 2, 2, 1322, 1321, 3, 2, 2, 2, 1323, 193,
	3, 2, 2, 2, 1324, 1325, 7, 74, 2, 2, 1325, 1326, 5, 196, 99, 2, 1326, 1327,
	7, 73, 2, 2, 1327, 195, 3, 2, 2, 2, 1328, 1333, 5, 198, 100, 2, 1329, 1330,
	7, 70, 2, 2, 1330, 1332, 5, 198, 100, 2, 1331, 1329, 3, 2, 2, 2, 1332,
	1335, 3, 2, 2, 2, 1333, 1331, 3, 2, 2, 2, 1333, 1334, 3, 2, 2, 2, 1334,
	197, 3, 2, 2, 2, 1335, 1333, 3, 2, 2, 2, 1336, 1338, 5, 102, 52, 2, 1337,
	1336, 3, 2, 2, 2, 1337, 1338, 3, 2, 2, 2, 1338, 1341, 3, 2, 2, 2, 1339,
	1342, 5, 80, 41, 2, 1340, 1342, 5, 200, 101, 2, 1341, 1339, 3, 2, 2, 2,
	1341, 1340, 3, 2, 2, 2, 1342, 1347, 3, 2, 2, 2, 1343, 1344, 7, 67, 2, 2,
	1344, 1346, 7, 68, 2, 2, 1345, 1343, 3, 2, 2, 2, 1346, 1349, 3, 2, 2, 2,
	1347, 1345, 3, 2, 2, 2, 1347, 1348, 3, 2, 2, 2, 1348, 199, 3, 2, 2, 2,
	1349, 1347, 3, 2, 2, 2, 1350, 1351, 9, 13, 2, 2, 1351, 201, 3, 2, 2, 2,
	1352, 1353, 7, 74, 2, 2, 1353, 1358, 5, 82, 42, 2, 1354, 1355, 7, 70, 2,
	2, 1355, 1357, 5, 82, 42, 2, 1356, 1354, 3, 2, 2, 2, 1357, 1360, 3, 2,
	2, 2, 1358, 1356, 3, 2, 2, 2, 1358, 1359, 3, 2, 2, 2, 1359, 1361, 3, 2,
	2, 2, 1360, 1358, 3, 2, 2, 2, 1361, 1362, 7, 73, 2, 2, 1362, 203, 3, 2,
	2, 2, 1363, 1370, 5, 208, 105, 2, 1364, 1365, 7, 71, 2, 2, 1365, 1367,
	7, 113, 2, 2, 1366, 1368, 5, 208, 105, 2, 1367, 1366, 3, 2, 2, 2, 1367,
	1368, 3, 2, 2, 2, 1368, 1370, 3, 2, 2, 2, 1369, 1363, 3, 2, 2, 2, 1369,
	1364, 3, 2, 2, 2, 1370, 205, 3, 2, 2, 2, 1371, 1372, 7, 42, 2, 2, 1372,
	1376, 5, 204, 103, 2, 1373, 1374, 7, 113, 2, 2, 1374, 1376, 5, 208, 105,
	2, 1375, 1371, 3, 2, 2, 2, 1375, 1373, 3, 2, 2, 2, 1376, 207, 3, 2, 2,
	2, 1377, 1379, 7, 63, 2, 2, 1378, 1380, 5, 162, 82, 2, 1379, 1378, 3, 2,
	2, 2, 1379, 1380, 3, 2, 2, 2, 1380, 1381, 3, 2, 2, 2, 1381, 1382, 7, 64,
	2, 2, 1382, 209, 3, 2, 2, 2, 173, 211, 216, 222, 230, 239, 244, 251, 258,
	261, 268, 278, 282, 287, 291, 295, 305, 313, 319, 326, 333, 337, 340, 343,
	352, 358, 363, 366, 372, 378, 382, 390, 399, 406, 412, 416, 427, 436, 441,
	447, 451, 463, 474, 479, 488, 496, 506, 515, 523, 528, 536, 541, 551, 561,
	567, 574, 579, 587, 591, 593, 599, 604, 608, 615, 617, 624, 629, 638, 643,
	646, 651, 660, 672, 681, 692, 695, 702, 712, 720, 723, 726, 739, 747, 752,
	760, 764, 768, 772, 774, 778, 784, 795, 805, 810, 819, 824, 827, 834, 843,
	866, 869, 872, 880, 884, 892, 898, 909, 918, 923, 933, 940, 953, 962, 971,
	977, 988, 993, 998, 1003, 1007, 1011, 1015, 1017, 1021, 1026, 1043, 1049,
	1055, 1061, 1064, 1084, 1088, 1093, 1097, 1113, 1153, 1159, 1174, 1177,
	1179, 1189, 1198, 1202, 1206, 1224, 1226, 1231, 1236, 1241, 1250, 1252,
	1256, 1261, 1265, 1269, 1273, 1283, 1295, 1302, 1305, 1309, 1317, 1322,
	1333, 1337, 1341, 1347, 1358, 1367, 1369, 1375, 1379,
}
var deserializer = antlr.NewATNDeserializer(nil)
var deserializedATN = deserializer.DeserializeFromUInt16(parserATN)

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", "DECIMAL_LITERAL", "HEX_LITERAL", "OCT_LITERAL",
	"BINARY_LITERAL", "FLOAT_LITERAL", "HEX_FLOAT_LITERAL", "BOOL_LITERAL",
	"CHAR_LITERAL", "STRING_LITERAL", "NULL_LITERAL", "LPAREN", "RPAREN", "LBRACE",
	"RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT",
	"BANG", "TILDE", "QUESTION", "COLON", "EQUAL", "LE", "GE", "NOTEQUAL",
	"AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR",
	"CARET", "MOD", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN",
	"AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN",
	"RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "ARROW", "COLONCOLON", "AT", "ELLIPSIS",
	"WS", "COMMENT", "LINE_COMMENT", "IDENTIFIER",
}

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

func init() {
	for index, ds := range deserializedATN.DecisionToState {
		decisionToDFA[index] = antlr.NewDFA(ds, index)
	}
}

type JavaParser struct {
	*antlr.BaseParser
}

func NewJavaParser(input antlr.TokenStream) *JavaParser {
	this := new(JavaParser)

	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 = "JavaParser.g4"

	return this
}

// JavaParser tokens.
const (
	JavaParserEOF               = antlr.TokenEOF
	JavaParserABSTRACT          = 1
	JavaParserASSERT            = 2
	JavaParserBOOLEAN           = 3
	JavaParserBREAK             = 4
	JavaParserBYTE              = 5
	JavaParserCASE              = 6
	JavaParserCATCH             = 7
	JavaParserCHAR              = 8
	JavaParserCLASS             = 9
	JavaParserCONST             = 10
	JavaParserCONTINUE          = 11
	JavaParserDEFAULT           = 12
	JavaParserDO                = 13
	JavaParserDOUBLE            = 14
	JavaParserELSE              = 15
	JavaParserENUM              = 16
	JavaParserEXTENDS           = 17
	JavaParserFINAL             = 18
	JavaParserFINALLY           = 19
	JavaParserFLOAT             = 20
	JavaParserFOR               = 21
	JavaParserIF                = 22
	JavaParserGOTO              = 23
	JavaParserIMPLEMENTS        = 24
	JavaParserIMPORT            = 25
	JavaParserINSTANCEOF        = 26
	JavaParserINT               = 27
	JavaParserINTERFACE         = 28
	JavaParserLONG              = 29
	JavaParserNATIVE            = 30
	JavaParserNEW               = 31
	JavaParserPACKAGE           = 32
	JavaParserPRIVATE           = 33
	JavaParserPROTECTED         = 34
	JavaParserPUBLIC            = 35
	JavaParserRETURN            = 36
	JavaParserSHORT             = 37
	JavaParserSTATIC            = 38
	JavaParserSTRICTFP          = 39
	JavaParserSUPER             = 40
	JavaParserSWITCH            = 41
	JavaParserSYNCHRONIZED      = 42
	JavaParserTHIS              = 43
	JavaParserTHROW             = 44
	JavaParserTHROWS            = 45
	JavaParserTRANSIENT         = 46
	JavaParserTRY               = 47
	JavaParserVOID              = 48
	JavaParserVOLATILE          = 49
	JavaParserWHILE             = 50
	JavaParserDECIMAL_LITERAL   = 51
	JavaParserHEX_LITERAL       = 52
	JavaParserOCT_LITERAL       = 53
	JavaParserBINARY_LITERAL    = 54
	JavaParserFLOAT_LITERAL     = 55
	JavaParserHEX_FLOAT_LITERAL = 56
	JavaParserBOOL_LITERAL      = 57
	JavaParserCHAR_LITERAL      = 58
	JavaParserSTRING_LITERAL    = 59
	JavaParserNULL_LITERAL      = 60
	JavaParserLPAREN            = 61
	JavaParserRPAREN            = 62
	JavaParserLBRACE            = 63
	JavaParserRBRACE            = 64
	JavaParserLBRACK            = 65
	JavaParserRBRACK            = 66
	JavaParserSEMI              = 67
	JavaParserCOMMA             = 68
	JavaParserDOT               = 69
	JavaParserASSIGN            = 70
	JavaParserGT                = 71
	JavaParserLT                = 72
	JavaParserBANG              = 73
	JavaParserTILDE             = 74
	JavaParserQUESTION          = 75
	JavaParserCOLON             = 76
	JavaParserEQUAL             = 77
	JavaParserLE                = 78
	JavaParserGE                = 79
	JavaParserNOTEQUAL          = 80
	JavaParserAND               = 81
	JavaParserOR                = 82
	JavaParserINC               = 83
	JavaParserDEC               = 84
	JavaParserADD               = 85
	JavaParserSUB               = 86
	JavaParserMUL               = 87
	JavaParserDIV               = 88
	JavaParserBITAND            = 89
	JavaParserBITOR             = 90
	JavaParserCARET             = 91
	JavaParserMOD               = 92
	JavaParserADD_ASSIGN        = 93
	JavaParserSUB_ASSIGN        = 94
	JavaParserMUL_ASSIGN        = 95
	JavaParserDIV_ASSIGN        = 96
	JavaParserAND_ASSIGN        = 97
	JavaParserOR_ASSIGN         = 98
	JavaParserXOR_ASSIGN        = 99
	JavaParserMOD_ASSIGN        = 100
	JavaParserLSHIFT_ASSIGN     = 101
	JavaParserRSHIFT_ASSIGN     = 102
	JavaParserURSHIFT_ASSIGN    = 103
	JavaParserARROW             = 104
	JavaParserCOLONCOLON        = 105
	JavaParserAT                = 106
	JavaParserELLIPSIS          = 107
	JavaParserWS                = 108
	JavaParserCOMMENT           = 109
	JavaParserLINE_COMMENT      = 110
	JavaParserIDENTIFIER        = 111
)

// JavaParser rules.
const (
	JavaParserRULE_compilationUnit                   = 0
	JavaParserRULE_packageDeclaration                = 1
	JavaParserRULE_importDeclaration                 = 2
	JavaParserRULE_typeDeclaration                   = 3
	JavaParserRULE_modifier                          = 4
	JavaParserRULE_classOrInterfaceModifier          = 5
	JavaParserRULE_variableModifier                  = 6
	JavaParserRULE_classDeclaration                  = 7
	JavaParserRULE_typeParameters                    = 8
	JavaParserRULE_typeParameter                     = 9
	JavaParserRULE_typeBound                         = 10
	JavaParserRULE_enumDeclaration                   = 11
	JavaParserRULE_enumConstants                     = 12
	JavaParserRULE_enumConstant                      = 13
	JavaParserRULE_enumBodyDeclarations              = 14
	JavaParserRULE_interfaceDeclaration              = 15
	JavaParserRULE_classBody                         = 16
	JavaParserRULE_interfaceBody                     = 17
	JavaParserRULE_classBodyDeclaration              = 18
	JavaParserRULE_memberDeclaration                 = 19
	JavaParserRULE_methodDeclaration                 = 20
	JavaParserRULE_methodBody                        = 21
	JavaParserRULE_typeTypeOrVoid                    = 22
	JavaParserRULE_genericMethodDeclaration          = 23
	JavaParserRULE_genericConstructorDeclaration     = 24
	JavaParserRULE_constructorDeclaration            = 25
	JavaParserRULE_fieldDeclaration                  = 26
	JavaParserRULE_interfaceBodyDeclaration          = 27
	JavaParserRULE_interfaceMemberDeclaration        = 28
	JavaParserRULE_constDeclaration                  = 29
	JavaParserRULE_constantDeclarator                = 30
	JavaParserRULE_interfaceMethodDeclaration        = 31
	JavaParserRULE_interfaceMethodModifier           = 32
	JavaParserRULE_genericInterfaceMethodDeclaration = 33
	JavaParserRULE_variableDeclarators               = 34
	JavaParserRULE_variableDeclarator                = 35
	JavaParserRULE_variableDeclaratorId              = 36
	JavaParserRULE_variableInitializer               = 37
	JavaParserRULE_arrayInitializer                  = 38
	JavaParserRULE_classOrInterfaceType              = 39
	JavaParserRULE_typeArgument                      = 40
	JavaParserRULE_qualifiedNameList                 = 41
	JavaParserRULE_formalParameters                  = 42
	JavaParserRULE_formalParameterList               = 43
	JavaParserRULE_formalParameter                   = 44
	JavaParserRULE_lastFormalParameter               = 45
	JavaParserRULE_qualifiedName                     = 46
	JavaParserRULE_literal                           = 47
	JavaParserRULE_integerLiteral                    = 48
	JavaParserRULE_floatLiteral                      = 49
	JavaParserRULE_annotation                        = 50
	JavaParserRULE_elementValuePairs                 = 51
	JavaParserRULE_elementValuePair                  = 52
	JavaParserRULE_elementValue                      = 53
	JavaParserRULE_elementValueArrayInitializer      = 54
	JavaParserRULE_annotationTypeDeclaration         = 55
	JavaParserRULE_annotationTypeBody                = 56
	JavaParserRULE_annotationTypeElementDeclaration  = 57
	JavaParserRULE_annotationTypeElementRest         = 58
	JavaParserRULE_annotationMethodOrConstantRest    = 59
	JavaParserRULE_annotationMethodRest              = 60
	JavaParserRULE_annotationConstantRest            = 61
	JavaParserRULE_defaultValue                      = 62
	JavaParserRULE_block                             = 63
	JavaParserRULE_blockStatement                    = 64
	JavaParserRULE_localVariableDeclaration          = 65
	JavaParserRULE_localTypeDeclaration              = 66
	JavaParserRULE_statement                         = 67
	JavaParserRULE_catchClause                       = 68
	JavaParserRULE_catchType                         = 69
	JavaParserRULE_finallyBlock                      = 70
	JavaParserRULE_resourceSpecification             = 71
	JavaParserRULE_resources                         = 72
	JavaParserRULE_resource                          = 73
	JavaParserRULE_switchBlockStatementGroup         = 74
	JavaParserRULE_switchLabel                       = 75
	JavaParserRULE_forControl                        = 76
	JavaParserRULE_forInit                           = 77
	JavaParserRULE_enhancedForControl                = 78
	JavaParserRULE_parExpression                     = 79
	JavaParserRULE_expressionList                    = 80
	JavaParserRULE_methodCall                        = 81
	JavaParserRULE_expression                        = 82
	JavaParserRULE_lambdaExpression                  = 83
	JavaParserRULE_lambdaParameters                  = 84
	JavaParserRULE_lambdaBody                        = 85
	JavaParserRULE_primary                           = 86
	JavaParserRULE_classType                         = 87
	JavaParserRULE_creator                           = 88
	JavaParserRULE_createdName                       = 89
	JavaParserRULE_innerCreator                      = 90
	JavaParserRULE_arrayCreatorRest                  = 91
	JavaParserRULE_classCreatorRest                  = 92
	JavaParserRULE_explicitGenericInvocation         = 93
	JavaParserRULE_typeArgumentsOrDiamond            = 94
	JavaParserRULE_nonWildcardTypeArgumentsOrDiamond = 95
	JavaParserRULE_nonWildcardTypeArguments          = 96
	JavaParserRULE_typeList                          = 97
	JavaParserRULE_typeType                          = 98
	JavaParserRULE_primitiveType                     = 99
	JavaParserRULE_typeArguments                     = 100
	JavaParserRULE_superSuffix                       = 101
	JavaParserRULE_explicitGenericInvocationSuffix   = 102
	JavaParserRULE_arguments                         = 103
)

// 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 = JavaParserRULE_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 = JavaParserRULE_compilationUnit

	return p
}

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

func (s *CompilationUnitContext) EOF() antlr.TerminalNode {
	return s.GetToken(JavaParserEOF, 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.(JavaParserListener); ok {
		listenerT.EnterCompilationUnit(s)
	}
}

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

func (p *JavaParser) CompilationUnit() (localctx ICompilationUnitContext) {
	localctx = NewCompilationUnitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 0, JavaParserRULE_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(209)
	p.GetErrorHandler().Sync(p)

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

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

	for _la == JavaParserIMPORT {
		{
			p.SetState(211)
			p.ImportDeclaration()
		}

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

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserABSTRACT)|(1<<JavaParserCLASS)|(1<<JavaParserENUM)|(1<<JavaParserFINAL)|(1<<JavaParserINTERFACE))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(JavaParserPRIVATE-33))|(1<<(JavaParserPROTECTED-33))|(1<<(JavaParserPUBLIC-33))|(1<<(JavaParserSTATIC-33))|(1<<(JavaParserSTRICTFP-33)))) != 0) || _la == JavaParserSEMI || _la == JavaParserAT {
		{
			p.SetState(217)
			p.TypeDeclaration()
		}

		p.SetState(222)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(223)
		p.Match(JavaParserEOF)
	}

	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 = JavaParserRULE_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 = JavaParserRULE_packageDeclaration

	return p
}

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

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

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

	if t == nil {
		return nil
	}

	return t.(IQualifiedNameContext)
}

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

func (s *PackageDeclarationContext) 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 *PackageDeclarationContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterPackageDeclaration(s)
	}
}

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

func (p *JavaParser) PackageDeclaration() (localctx IPackageDeclarationContext) {
	localctx = NewPackageDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 2, JavaParserRULE_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(228)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserAT {
		{
			p.SetState(225)
			p.Annotation()
		}

		p.SetState(230)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(231)
		p.Match(JavaParserPACKAGE)
	}
	{
		p.SetState(232)
		p.QualifiedName()
	}
	{
		p.SetState(233)
		p.Match(JavaParserSEMI)
	}

	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 = JavaParserRULE_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 = JavaParserRULE_importDeclaration

	return p
}

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

func (s *ImportDeclarationContext) IMPORT() antlr.TerminalNode {
	return s.GetToken(JavaParserIMPORT, 0)
}

func (s *ImportDeclarationContext) QualifiedName() IQualifiedNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IQualifiedNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IQualifiedNameContext)
}

func (s *ImportDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, 0)
}

func (s *ImportDeclarationContext) STATIC() antlr.TerminalNode {
	return s.GetToken(JavaParserSTATIC, 0)
}

func (s *ImportDeclarationContext) DOT() antlr.TerminalNode {
	return s.GetToken(JavaParserDOT, 0)
}

func (s *ImportDeclarationContext) MUL() antlr.TerminalNode {
	return s.GetToken(JavaParserMUL, 0)
}

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.(JavaParserListener); ok {
		listenerT.EnterImportDeclaration(s)
	}
}

func (s *ImportDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitImportDeclaration(s)
	}
}

func (p *JavaParser) ImportDeclaration() (localctx IImportDeclarationContext) {
	localctx = NewImportDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, JavaParserRULE_importDeclaration)
	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(235)
		p.Match(JavaParserIMPORT)
	}
	p.SetState(237)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserSTATIC {
		{
			p.SetState(236)
			p.Match(JavaParserSTATIC)
		}

	}
	{
		p.SetState(239)
		p.QualifiedName()
	}
	p.SetState(242)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserDOT {
		{
			p.SetState(240)
			p.Match(JavaParserDOT)
		}
		{
			p.SetState(241)
			p.Match(JavaParserMUL)
		}

	}
	{
		p.SetState(244)
		p.Match(JavaParserSEMI)
	}

	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 = JavaParserRULE_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 = JavaParserRULE_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) EnumDeclaration() IEnumDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumDeclarationContext)
}

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) AnnotationTypeDeclaration() IAnnotationTypeDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationTypeDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationTypeDeclarationContext)
}

func (s *TypeDeclarationContext) AllClassOrInterfaceModifier() []IClassOrInterfaceModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IClassOrInterfaceModifierContext)(nil)).Elem())
	var tst = make([]IClassOrInterfaceModifierContext, len(ts))

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

	return tst
}

func (s *TypeDeclarationContext) ClassOrInterfaceModifier(i int) IClassOrInterfaceModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassOrInterfaceModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IClassOrInterfaceModifierContext)
}

func (s *TypeDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, 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.(JavaParserListener); ok {
		listenerT.EnterTypeDeclaration(s)
	}
}

func (s *TypeDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitTypeDeclaration(s)
	}
}

func (p *JavaParser) TypeDeclaration() (localctx ITypeDeclarationContext) {
	localctx = NewTypeDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 6, JavaParserRULE_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)
			}
		}
	}()

	var _alt int

	p.SetState(259)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserABSTRACT, JavaParserCLASS, JavaParserENUM, JavaParserFINAL, JavaParserINTERFACE, JavaParserPRIVATE, JavaParserPROTECTED, JavaParserPUBLIC, JavaParserSTATIC, JavaParserSTRICTFP, JavaParserAT:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(249)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 6, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(246)
					p.ClassOrInterfaceModifier()
				}

			}
			p.SetState(251)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 6, p.GetParserRuleContext())
		}
		p.SetState(256)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case JavaParserCLASS:
			{
				p.SetState(252)
				p.ClassDeclaration()
			}

		case JavaParserENUM:
			{
				p.SetState(253)
				p.EnumDeclaration()
			}

		case JavaParserINTERFACE:
			{
				p.SetState(254)
				p.InterfaceDeclaration()
			}

		case JavaParserAT:
			{
				p.SetState(255)
				p.AnnotationTypeDeclaration()
			}

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

	case JavaParserSEMI:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(258)
			p.Match(JavaParserSEMI)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyModifierContext() *ModifierContext {
	var p = new(ModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_modifier
	return p
}

func (*ModifierContext) IsModifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_modifier

	return p
}

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

func (s *ModifierContext) ClassOrInterfaceModifier() IClassOrInterfaceModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassOrInterfaceModifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassOrInterfaceModifierContext)
}

func (s *ModifierContext) NATIVE() antlr.TerminalNode {
	return s.GetToken(JavaParserNATIVE, 0)
}

func (s *ModifierContext) SYNCHRONIZED() antlr.TerminalNode {
	return s.GetToken(JavaParserSYNCHRONIZED, 0)
}

func (s *ModifierContext) TRANSIENT() antlr.TerminalNode {
	return s.GetToken(JavaParserTRANSIENT, 0)
}

func (s *ModifierContext) VOLATILE() antlr.TerminalNode {
	return s.GetToken(JavaParserVOLATILE, 0)
}

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

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

func (s *ModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterModifier(s)
	}
}

func (s *ModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitModifier(s)
	}
}

func (p *JavaParser) Modifier() (localctx IModifierContext) {
	localctx = NewModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 8, JavaParserRULE_modifier)

	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(266)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserABSTRACT, JavaParserFINAL, JavaParserPRIVATE, JavaParserPROTECTED, JavaParserPUBLIC, JavaParserSTATIC, JavaParserSTRICTFP, JavaParserAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(261)
			p.ClassOrInterfaceModifier()
		}

	case JavaParserNATIVE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(262)
			p.Match(JavaParserNATIVE)
		}

	case JavaParserSYNCHRONIZED:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(263)
			p.Match(JavaParserSYNCHRONIZED)
		}

	case JavaParserTRANSIENT:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(264)
			p.Match(JavaParserTRANSIENT)
		}

	case JavaParserVOLATILE:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(265)
			p.Match(JavaParserVOLATILE)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyClassOrInterfaceModifierContext() *ClassOrInterfaceModifierContext {
	var p = new(ClassOrInterfaceModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_classOrInterfaceModifier
	return p
}

func (*ClassOrInterfaceModifierContext) IsClassOrInterfaceModifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_classOrInterfaceModifier

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *ClassOrInterfaceModifierContext) PUBLIC() antlr.TerminalNode {
	return s.GetToken(JavaParserPUBLIC, 0)
}

func (s *ClassOrInterfaceModifierContext) PROTECTED() antlr.TerminalNode {
	return s.GetToken(JavaParserPROTECTED, 0)
}

func (s *ClassOrInterfaceModifierContext) PRIVATE() antlr.TerminalNode {
	return s.GetToken(JavaParserPRIVATE, 0)
}

func (s *ClassOrInterfaceModifierContext) STATIC() antlr.TerminalNode {
	return s.GetToken(JavaParserSTATIC, 0)
}

func (s *ClassOrInterfaceModifierContext) ABSTRACT() antlr.TerminalNode {
	return s.GetToken(JavaParserABSTRACT, 0)
}

func (s *ClassOrInterfaceModifierContext) FINAL() antlr.TerminalNode {
	return s.GetToken(JavaParserFINAL, 0)
}

func (s *ClassOrInterfaceModifierContext) STRICTFP() antlr.TerminalNode {
	return s.GetToken(JavaParserSTRICTFP, 0)
}

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

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

func (s *ClassOrInterfaceModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterClassOrInterfaceModifier(s)
	}
}

func (s *ClassOrInterfaceModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitClassOrInterfaceModifier(s)
	}
}

func (p *JavaParser) ClassOrInterfaceModifier() (localctx IClassOrInterfaceModifierContext) {
	localctx = NewClassOrInterfaceModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 10, JavaParserRULE_classOrInterfaceModifier)

	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(276)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(268)
			p.Annotation()
		}

	case JavaParserPUBLIC:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(269)
			p.Match(JavaParserPUBLIC)
		}

	case JavaParserPROTECTED:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(270)
			p.Match(JavaParserPROTECTED)
		}

	case JavaParserPRIVATE:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(271)
			p.Match(JavaParserPRIVATE)
		}

	case JavaParserSTATIC:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(272)
			p.Match(JavaParserSTATIC)
		}

	case JavaParserABSTRACT:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(273)
			p.Match(JavaParserABSTRACT)
		}

	case JavaParserFINAL:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(274)
			p.Match(JavaParserFINAL)
		}

	case JavaParserSTRICTFP:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(275)
			p.Match(JavaParserSTRICTFP)
		}

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

	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 = JavaParserRULE_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 = JavaParserRULE_variableModifier

	return p
}

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

func (s *VariableModifierContext) FINAL() antlr.TerminalNode {
	return s.GetToken(JavaParserFINAL, 0)
}

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) 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.(JavaParserListener); ok {
		listenerT.EnterVariableModifier(s)
	}
}

func (s *VariableModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitVariableModifier(s)
	}
}

func (p *JavaParser) VariableModifier() (localctx IVariableModifierContext) {
	localctx = NewVariableModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 12, JavaParserRULE_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(280)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserFINAL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(278)
			p.Match(JavaParserFINAL)
		}

	case JavaParserAT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(279)
			p.Annotation()
		}

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

	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 = JavaParserRULE_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 = JavaParserRULE_classDeclaration

	return p
}

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

func (s *ClassDeclarationContext) CLASS() antlr.TerminalNode {
	return s.GetToken(JavaParserCLASS, 0)
}

func (s *ClassDeclarationContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *ClassDeclarationContext) ClassBody() IClassBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassBodyContext)
}

func (s *ClassDeclarationContext) TypeParameters() ITypeParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

func (s *ClassDeclarationContext) EXTENDS() antlr.TerminalNode {
	return s.GetToken(JavaParserEXTENDS, 0)
}

func (s *ClassDeclarationContext) TypeType() ITypeTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *ClassDeclarationContext) IMPLEMENTS() antlr.TerminalNode {
	return s.GetToken(JavaParserIMPLEMENTS, 0)
}

func (s *ClassDeclarationContext) TypeList() ITypeListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeListContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterClassDeclaration(s)
	}
}

func (s *ClassDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitClassDeclaration(s)
	}
}

func (p *JavaParser) ClassDeclaration() (localctx IClassDeclarationContext) {
	localctx = NewClassDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 14, JavaParserRULE_classDeclaration)
	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(282)
		p.Match(JavaParserCLASS)
	}
	{
		p.SetState(283)
		p.Match(JavaParserIDENTIFIER)
	}
	p.SetState(285)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserLT {
		{
			p.SetState(284)
			p.TypeParameters()
		}

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

	if _la == JavaParserEXTENDS {
		{
			p.SetState(287)
			p.Match(JavaParserEXTENDS)
		}
		{
			p.SetState(288)
			p.TypeType()
		}

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

	if _la == JavaParserIMPLEMENTS {
		{
			p.SetState(291)
			p.Match(JavaParserIMPLEMENTS)
		}
		{
			p.SetState(292)
			p.TypeList()
		}

	}
	{
		p.SetState(295)
		p.ClassBody()
	}

	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 = JavaParserRULE_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 = JavaParserRULE_typeParameters

	return p
}

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

func (s *TypeParametersContext) LT() antlr.TerminalNode {
	return s.GetToken(JavaParserLT, 0)
}

func (s *TypeParametersContext) 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 *TypeParametersContext) TypeParameter(i int) ITypeParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParameterContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeParameterContext)
}

func (s *TypeParametersContext) GT() antlr.TerminalNode {
	return s.GetToken(JavaParserGT, 0)
}

func (s *TypeParametersContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(JavaParserCOMMA)
}

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

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.(JavaParserListener); ok {
		listenerT.EnterTypeParameters(s)
	}
}

func (s *TypeParametersContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitTypeParameters(s)
	}
}

func (p *JavaParser) TypeParameters() (localctx ITypeParametersContext) {
	localctx = NewTypeParametersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, JavaParserRULE_typeParameters)
	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(297)
		p.Match(JavaParserLT)
	}
	{
		p.SetState(298)
		p.TypeParameter()
	}
	p.SetState(303)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(299)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(300)
			p.TypeParameter()
		}

		p.SetState(305)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(306)
		p.Match(JavaParserGT)
	}

	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 = JavaParserRULE_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 = JavaParserRULE_typeParameter

	return p
}

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

func (s *TypeParameterContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *TypeParameterContext) 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 *TypeParameterContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *TypeParameterContext) EXTENDS() antlr.TerminalNode {
	return s.GetToken(JavaParserEXTENDS, 0)
}

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.(JavaParserListener); ok {
		listenerT.EnterTypeParameter(s)
	}
}

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

func (p *JavaParser) TypeParameter() (localctx ITypeParameterContext) {
	localctx = NewTypeParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, JavaParserRULE_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(311)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserAT {
		{
			p.SetState(308)
			p.Annotation()
		}

		p.SetState(313)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(314)
		p.Match(JavaParserIDENTIFIER)
	}
	p.SetState(317)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserEXTENDS {
		{
			p.SetState(315)
			p.Match(JavaParserEXTENDS)
		}
		{
			p.SetState(316)
			p.TypeBound()
		}

	}

	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 = JavaParserRULE_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 = JavaParserRULE_typeBound

	return p
}

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

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *TypeBoundContext) AllBITAND() []antlr.TerminalNode {
	return s.GetTokens(JavaParserBITAND)
}

func (s *TypeBoundContext) BITAND(i int) antlr.TerminalNode {
	return s.GetToken(JavaParserBITAND, i)
}

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.(JavaParserListener); ok {
		listenerT.EnterTypeBound(s)
	}
}

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

func (p *JavaParser) TypeBound() (localctx ITypeBoundContext) {
	localctx = NewTypeBoundContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 20, JavaParserRULE_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.EnterOuterAlt(localctx, 1)
	{
		p.SetState(319)
		p.TypeType()
	}
	p.SetState(324)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserBITAND {
		{
			p.SetState(320)
			p.Match(JavaParserBITAND)
		}
		{
			p.SetState(321)
			p.TypeType()
		}

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

	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 = JavaParserRULE_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 = JavaParserRULE_enumDeclaration

	return p
}

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

func (s *EnumDeclarationContext) ENUM() antlr.TerminalNode {
	return s.GetToken(JavaParserENUM, 0)
}

func (s *EnumDeclarationContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *EnumDeclarationContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserLBRACE, 0)
}

func (s *EnumDeclarationContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserRBRACE, 0)
}

func (s *EnumDeclarationContext) IMPLEMENTS() antlr.TerminalNode {
	return s.GetToken(JavaParserIMPLEMENTS, 0)
}

func (s *EnumDeclarationContext) TypeList() ITypeListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeListContext)
}

func (s *EnumDeclarationContext) EnumConstants() IEnumConstantsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumConstantsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumConstantsContext)
}

func (s *EnumDeclarationContext) COMMA() antlr.TerminalNode {
	return s.GetToken(JavaParserCOMMA, 0)
}

func (s *EnumDeclarationContext) EnumBodyDeclarations() IEnumBodyDeclarationsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumBodyDeclarationsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumBodyDeclarationsContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterEnumDeclaration(s)
	}
}

func (s *EnumDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitEnumDeclaration(s)
	}
}

func (p *JavaParser) EnumDeclaration() (localctx IEnumDeclarationContext) {
	localctx = NewEnumDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 22, JavaParserRULE_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(327)
		p.Match(JavaParserENUM)
	}
	{
		p.SetState(328)
		p.Match(JavaParserIDENTIFIER)
	}
	p.SetState(331)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserIMPLEMENTS {
		{
			p.SetState(329)
			p.Match(JavaParserIMPLEMENTS)
		}
		{
			p.SetState(330)
			p.TypeList()
		}

	}
	{
		p.SetState(333)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(335)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(334)
			p.EnumConstants()
		}

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

	if _la == JavaParserCOMMA {
		{
			p.SetState(337)
			p.Match(JavaParserCOMMA)
		}

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

	if _la == JavaParserSEMI {
		{
			p.SetState(340)
			p.EnumBodyDeclarations()
		}

	}
	{
		p.SetState(343)
		p.Match(JavaParserRBRACE)
	}

	return localctx
}

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

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

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

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

func NewEmptyEnumConstantsContext() *EnumConstantsContext {
	var p = new(EnumConstantsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_enumConstants
	return p
}

func (*EnumConstantsContext) IsEnumConstantsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_enumConstants

	return p
}

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

func (s *EnumConstantsContext) 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 *EnumConstantsContext) EnumConstant(i int) IEnumConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumConstantContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEnumConstantContext)
}

func (s *EnumConstantsContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(JavaParserCOMMA)
}

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

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

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

func (s *EnumConstantsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterEnumConstants(s)
	}
}

func (s *EnumConstantsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitEnumConstants(s)
	}
}

func (p *JavaParser) EnumConstants() (localctx IEnumConstantsContext) {
	localctx = NewEnumConstantsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, JavaParserRULE_enumConstants)

	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(345)
		p.EnumConstant()
	}
	p.SetState(350)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 23, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(346)
				p.Match(JavaParserCOMMA)
			}
			{
				p.SetState(347)
				p.EnumConstant()
			}

		}
		p.SetState(352)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 23, 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 = JavaParserRULE_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 = JavaParserRULE_enumConstant

	return p
}

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

func (s *EnumConstantContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *EnumConstantContext) 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 *EnumConstantContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *EnumConstantContext) Arguments() IArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentsContext)
}

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) 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.(JavaParserListener); ok {
		listenerT.EnterEnumConstant(s)
	}
}

func (s *EnumConstantContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitEnumConstant(s)
	}
}

func (p *JavaParser) EnumConstant() (localctx IEnumConstantContext) {
	localctx = NewEnumConstantContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 26, JavaParserRULE_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(356)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserAT {
		{
			p.SetState(353)
			p.Annotation()
		}

		p.SetState(358)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(359)
		p.Match(JavaParserIDENTIFIER)
	}
	p.SetState(361)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserLPAREN {
		{
			p.SetState(360)
			p.Arguments()
		}

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

	if _la == JavaParserLBRACE {
		{
			p.SetState(363)
			p.ClassBody()
		}

	}

	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 = JavaParserRULE_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 = JavaParserRULE_enumBodyDeclarations

	return p
}

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

func (s *EnumBodyDeclarationsContext) SEMI() antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, 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.(JavaParserListener); ok {
		listenerT.EnterEnumBodyDeclarations(s)
	}
}

func (s *EnumBodyDeclarationsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitEnumBodyDeclarations(s)
	}
}

func (p *JavaParser) EnumBodyDeclarations() (localctx IEnumBodyDeclarationsContext) {
	localctx = NewEnumBodyDeclarationsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, JavaParserRULE_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(366)
		p.Match(JavaParserSEMI)
	}
	p.SetState(370)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserABSTRACT)|(1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserCLASS)|(1<<JavaParserDOUBLE)|(1<<JavaParserENUM)|(1<<JavaParserFINAL)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserINTERFACE)|(1<<JavaParserLONG)|(1<<JavaParserNATIVE))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(JavaParserPRIVATE-33))|(1<<(JavaParserPROTECTED-33))|(1<<(JavaParserPUBLIC-33))|(1<<(JavaParserSHORT-33))|(1<<(JavaParserSTATIC-33))|(1<<(JavaParserSTRICTFP-33))|(1<<(JavaParserSYNCHRONIZED-33))|(1<<(JavaParserTRANSIENT-33))|(1<<(JavaParserVOID-33))|(1<<(JavaParserVOLATILE-33))|(1<<(JavaParserLBRACE-33)))) != 0) || _la == JavaParserSEMI || _la == JavaParserLT || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(367)
			p.ClassBodyDeclaration()
		}

		p.SetState(372)
		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 = JavaParserRULE_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 = JavaParserRULE_interfaceDeclaration

	return p
}

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

func (s *InterfaceDeclarationContext) INTERFACE() antlr.TerminalNode {
	return s.GetToken(JavaParserINTERFACE, 0)
}

func (s *InterfaceDeclarationContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *InterfaceDeclarationContext) InterfaceBody() IInterfaceBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceBodyContext)
}

func (s *InterfaceDeclarationContext) TypeParameters() ITypeParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

func (s *InterfaceDeclarationContext) EXTENDS() antlr.TerminalNode {
	return s.GetToken(JavaParserEXTENDS, 0)
}

func (s *InterfaceDeclarationContext) TypeList() ITypeListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeListContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterInterfaceDeclaration(s)
	}
}

func (s *InterfaceDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitInterfaceDeclaration(s)
	}
}

func (p *JavaParser) InterfaceDeclaration() (localctx IInterfaceDeclarationContext) {
	localctx = NewInterfaceDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, JavaParserRULE_interfaceDeclaration)
	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(373)
		p.Match(JavaParserINTERFACE)
	}
	{
		p.SetState(374)
		p.Match(JavaParserIDENTIFIER)
	}
	p.SetState(376)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserLT {
		{
			p.SetState(375)
			p.TypeParameters()
		}

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

	if _la == JavaParserEXTENDS {
		{
			p.SetState(378)
			p.Match(JavaParserEXTENDS)
		}
		{
			p.SetState(379)
			p.TypeList()
		}

	}
	{
		p.SetState(382)
		p.InterfaceBody()
	}

	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 = JavaParserRULE_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 = JavaParserRULE_classBody

	return p
}

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

func (s *ClassBodyContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserLBRACE, 0)
}

func (s *ClassBodyContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserRBRACE, 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.(JavaParserListener); ok {
		listenerT.EnterClassBody(s)
	}
}

func (s *ClassBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitClassBody(s)
	}
}

func (p *JavaParser) ClassBody() (localctx IClassBodyContext) {
	localctx = NewClassBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, JavaParserRULE_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(384)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(388)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserABSTRACT)|(1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserCLASS)|(1<<JavaParserDOUBLE)|(1<<JavaParserENUM)|(1<<JavaParserFINAL)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserINTERFACE)|(1<<JavaParserLONG)|(1<<JavaParserNATIVE))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(JavaParserPRIVATE-33))|(1<<(JavaParserPROTECTED-33))|(1<<(JavaParserPUBLIC-33))|(1<<(JavaParserSHORT-33))|(1<<(JavaParserSTATIC-33))|(1<<(JavaParserSTRICTFP-33))|(1<<(JavaParserSYNCHRONIZED-33))|(1<<(JavaParserTRANSIENT-33))|(1<<(JavaParserVOID-33))|(1<<(JavaParserVOLATILE-33))|(1<<(JavaParserLBRACE-33)))) != 0) || _la == JavaParserSEMI || _la == JavaParserLT || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(385)
			p.ClassBodyDeclaration()
		}

		p.SetState(390)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(391)
		p.Match(JavaParserRBRACE)
	}

	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 = JavaParserRULE_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 = JavaParserRULE_interfaceBody

	return p
}

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

func (s *InterfaceBodyContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserLBRACE, 0)
}

func (s *InterfaceBodyContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserRBRACE, 0)
}

func (s *InterfaceBodyContext) AllInterfaceBodyDeclaration() []IInterfaceBodyDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInterfaceBodyDeclarationContext)(nil)).Elem())
	var tst = make([]IInterfaceBodyDeclarationContext, len(ts))

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

	return tst
}

func (s *InterfaceBodyContext) InterfaceBodyDeclaration(i int) IInterfaceBodyDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceBodyDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInterfaceBodyDeclarationContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterInterfaceBody(s)
	}
}

func (s *InterfaceBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitInterfaceBody(s)
	}
}

func (p *JavaParser) InterfaceBody() (localctx IInterfaceBodyContext) {
	localctx = NewInterfaceBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 34, JavaParserRULE_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(393)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(397)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserABSTRACT)|(1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserCLASS)|(1<<JavaParserDEFAULT)|(1<<JavaParserDOUBLE)|(1<<JavaParserENUM)|(1<<JavaParserFINAL)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserINTERFACE)|(1<<JavaParserLONG)|(1<<JavaParserNATIVE))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(JavaParserPRIVATE-33))|(1<<(JavaParserPROTECTED-33))|(1<<(JavaParserPUBLIC-33))|(1<<(JavaParserSHORT-33))|(1<<(JavaParserSTATIC-33))|(1<<(JavaParserSTRICTFP-33))|(1<<(JavaParserSYNCHRONIZED-33))|(1<<(JavaParserTRANSIENT-33))|(1<<(JavaParserVOID-33))|(1<<(JavaParserVOLATILE-33)))) != 0) || _la == JavaParserSEMI || _la == JavaParserLT || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(394)
			p.InterfaceBodyDeclaration()
		}

		p.SetState(399)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(400)
		p.Match(JavaParserRBRACE)
	}

	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 = JavaParserRULE_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 = JavaParserRULE_classBodyDeclaration

	return p
}

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

func (s *ClassBodyDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, 0)
}

func (s *ClassBodyDeclarationContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *ClassBodyDeclarationContext) STATIC() antlr.TerminalNode {
	return s.GetToken(JavaParserSTATIC, 0)
}

func (s *ClassBodyDeclarationContext) MemberDeclaration() IMemberDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMemberDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMemberDeclarationContext)
}

func (s *ClassBodyDeclarationContext) AllModifier() []IModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IModifierContext)(nil)).Elem())
	var tst = make([]IModifierContext, len(ts))

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

	return tst
}

func (s *ClassBodyDeclarationContext) Modifier(i int) IModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IModifierContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterClassBodyDeclaration(s)
	}
}

func (s *ClassBodyDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitClassBodyDeclaration(s)
	}
}

func (p *JavaParser) ClassBodyDeclaration() (localctx IClassBodyDeclarationContext) {
	localctx = NewClassBodyDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, JavaParserRULE_classBodyDeclaration)
	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.SetState(414)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 34, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(402)
			p.Match(JavaParserSEMI)
		}

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

		if _la == JavaParserSTATIC {
			{
				p.SetState(403)
				p.Match(JavaParserSTATIC)
			}

		}
		{
			p.SetState(406)
			p.Block()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		p.SetState(410)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 33, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(407)
					p.Modifier()
				}

			}
			p.SetState(412)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 33, p.GetParserRuleContext())
		}
		{
			p.SetState(413)
			p.MemberDeclaration()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyMemberDeclarationContext() *MemberDeclarationContext {
	var p = new(MemberDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_memberDeclaration
	return p
}

func (*MemberDeclarationContext) IsMemberDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_memberDeclaration

	return p
}

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

func (s *MemberDeclarationContext) MethodDeclaration() IMethodDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodDeclarationContext)
}

func (s *MemberDeclarationContext) GenericMethodDeclaration() IGenericMethodDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGenericMethodDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGenericMethodDeclarationContext)
}

func (s *MemberDeclarationContext) FieldDeclaration() IFieldDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFieldDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFieldDeclarationContext)
}

func (s *MemberDeclarationContext) ConstructorDeclaration() IConstructorDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstructorDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstructorDeclarationContext)
}

func (s *MemberDeclarationContext) GenericConstructorDeclaration() IGenericConstructorDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGenericConstructorDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGenericConstructorDeclarationContext)
}

func (s *MemberDeclarationContext) InterfaceDeclaration() IInterfaceDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceDeclarationContext)
}

func (s *MemberDeclarationContext) AnnotationTypeDeclaration() IAnnotationTypeDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationTypeDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationTypeDeclarationContext)
}

func (s *MemberDeclarationContext) ClassDeclaration() IClassDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassDeclarationContext)
}

func (s *MemberDeclarationContext) EnumDeclaration() IEnumDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumDeclarationContext)
}

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

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

func (s *MemberDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterMemberDeclaration(s)
	}
}

func (s *MemberDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitMemberDeclaration(s)
	}
}

func (p *JavaParser) MemberDeclaration() (localctx IMemberDeclarationContext) {
	localctx = NewMemberDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, JavaParserRULE_memberDeclaration)

	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(425)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 35, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(416)
			p.MethodDeclaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(417)
			p.GenericMethodDeclaration()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(418)
			p.FieldDeclaration()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(419)
			p.ConstructorDeclaration()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(420)
			p.GenericConstructorDeclaration()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(421)
			p.InterfaceDeclaration()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(422)
			p.AnnotationTypeDeclaration()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(423)
			p.ClassDeclaration()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(424)
			p.EnumDeclaration()
		}

	}

	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 = JavaParserRULE_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 = JavaParserRULE_methodDeclaration

	return p
}

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

func (s *MethodDeclarationContext) TypeTypeOrVoid() ITypeTypeOrVoidContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeOrVoidContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeOrVoidContext)
}

func (s *MethodDeclarationContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *MethodDeclarationContext) FormalParameters() IFormalParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParametersContext)
}

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) AllLBRACK() []antlr.TerminalNode {
	return s.GetTokens(JavaParserLBRACK)
}

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

func (s *MethodDeclarationContext) AllRBRACK() []antlr.TerminalNode {
	return s.GetTokens(JavaParserRBRACK)
}

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

func (s *MethodDeclarationContext) THROWS() antlr.TerminalNode {
	return s.GetToken(JavaParserTHROWS, 0)
}

func (s *MethodDeclarationContext) QualifiedNameList() IQualifiedNameListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IQualifiedNameListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IQualifiedNameListContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterMethodDeclaration(s)
	}
}

func (s *MethodDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitMethodDeclaration(s)
	}
}

func (p *JavaParser) MethodDeclaration() (localctx IMethodDeclarationContext) {
	localctx = NewMethodDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, JavaParserRULE_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(427)
		p.TypeTypeOrVoid()
	}
	{
		p.SetState(428)
		p.Match(JavaParserIDENTIFIER)
	}
	{
		p.SetState(429)
		p.FormalParameters()
	}
	p.SetState(434)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserLBRACK {
		{
			p.SetState(430)
			p.Match(JavaParserLBRACK)
		}
		{
			p.SetState(431)
			p.Match(JavaParserRBRACK)
		}

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

	if _la == JavaParserTHROWS {
		{
			p.SetState(437)
			p.Match(JavaParserTHROWS)
		}
		{
			p.SetState(438)
			p.QualifiedNameList()
		}

	}
	{
		p.SetState(441)
		p.MethodBody()
	}

	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 = JavaParserRULE_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 = JavaParserRULE_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(JavaParserSEMI, 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.(JavaParserListener); ok {
		listenerT.EnterMethodBody(s)
	}
}

func (s *MethodBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitMethodBody(s)
	}
}

func (p *JavaParser) MethodBody() (localctx IMethodBodyContext) {
	localctx = NewMethodBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, JavaParserRULE_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(445)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserLBRACE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(443)
			p.Block()
		}

	case JavaParserSEMI:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(444)
			p.Match(JavaParserSEMI)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyTypeTypeOrVoidContext() *TypeTypeOrVoidContext {
	var p = new(TypeTypeOrVoidContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_typeTypeOrVoid
	return p
}

func (*TypeTypeOrVoidContext) IsTypeTypeOrVoidContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_typeTypeOrVoid

	return p
}

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

func (s *TypeTypeOrVoidContext) TypeType() ITypeTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *TypeTypeOrVoidContext) VOID() antlr.TerminalNode {
	return s.GetToken(JavaParserVOID, 0)
}

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

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

func (s *TypeTypeOrVoidContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterTypeTypeOrVoid(s)
	}
}

func (s *TypeTypeOrVoidContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitTypeTypeOrVoid(s)
	}
}

func (p *JavaParser) TypeTypeOrVoid() (localctx ITypeTypeOrVoidContext) {
	localctx = NewTypeTypeOrVoidContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, JavaParserRULE_typeTypeOrVoid)

	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(449)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserSHORT, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(447)
			p.TypeType()
		}

	case JavaParserVOID:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(448)
			p.Match(JavaParserVOID)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyGenericMethodDeclarationContext() *GenericMethodDeclarationContext {
	var p = new(GenericMethodDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_genericMethodDeclaration
	return p
}

func (*GenericMethodDeclarationContext) IsGenericMethodDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_genericMethodDeclaration

	return p
}

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

func (s *GenericMethodDeclarationContext) TypeParameters() ITypeParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

func (s *GenericMethodDeclarationContext) MethodDeclaration() IMethodDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodDeclarationContext)
}

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

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

func (s *GenericMethodDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterGenericMethodDeclaration(s)
	}
}

func (s *GenericMethodDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitGenericMethodDeclaration(s)
	}
}

func (p *JavaParser) GenericMethodDeclaration() (localctx IGenericMethodDeclarationContext) {
	localctx = NewGenericMethodDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, JavaParserRULE_genericMethodDeclaration)

	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(451)
		p.TypeParameters()
	}
	{
		p.SetState(452)
		p.MethodDeclaration()
	}

	return localctx
}

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

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

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

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

func NewEmptyGenericConstructorDeclarationContext() *GenericConstructorDeclarationContext {
	var p = new(GenericConstructorDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_genericConstructorDeclaration
	return p
}

func (*GenericConstructorDeclarationContext) IsGenericConstructorDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_genericConstructorDeclaration

	return p
}

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

func (s *GenericConstructorDeclarationContext) TypeParameters() ITypeParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

func (s *GenericConstructorDeclarationContext) ConstructorDeclaration() IConstructorDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstructorDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstructorDeclarationContext)
}

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

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

func (s *GenericConstructorDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterGenericConstructorDeclaration(s)
	}
}

func (s *GenericConstructorDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitGenericConstructorDeclaration(s)
	}
}

func (p *JavaParser) GenericConstructorDeclaration() (localctx IGenericConstructorDeclarationContext) {
	localctx = NewGenericConstructorDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, JavaParserRULE_genericConstructorDeclaration)

	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(454)
		p.TypeParameters()
	}
	{
		p.SetState(455)
		p.ConstructorDeclaration()
	}

	return localctx
}

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

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

	// GetConstructorBody returns the constructorBody rule contexts.
	GetConstructorBody() IBlockContext

	// SetConstructorBody sets the constructorBody rule contexts.
	SetConstructorBody(IBlockContext)

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

type ConstructorDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser          antlr.Parser
	constructorBody IBlockContext
}

func NewEmptyConstructorDeclarationContext() *ConstructorDeclarationContext {
	var p = new(ConstructorDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_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 = JavaParserRULE_constructorDeclaration

	return p
}

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

func (s *ConstructorDeclarationContext) GetConstructorBody() IBlockContext { return s.constructorBody }

func (s *ConstructorDeclarationContext) SetConstructorBody(v IBlockContext) { s.constructorBody = v }

func (s *ConstructorDeclarationContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *ConstructorDeclarationContext) FormalParameters() IFormalParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParametersContext)
}

func (s *ConstructorDeclarationContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *ConstructorDeclarationContext) THROWS() antlr.TerminalNode {
	return s.GetToken(JavaParserTHROWS, 0)
}

func (s *ConstructorDeclarationContext) QualifiedNameList() IQualifiedNameListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IQualifiedNameListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IQualifiedNameListContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterConstructorDeclaration(s)
	}
}

func (s *ConstructorDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitConstructorDeclaration(s)
	}
}

func (p *JavaParser) ConstructorDeclaration() (localctx IConstructorDeclarationContext) {
	localctx = NewConstructorDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 50, JavaParserRULE_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(457)
		p.Match(JavaParserIDENTIFIER)
	}
	{
		p.SetState(458)
		p.FormalParameters()
	}
	p.SetState(461)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserTHROWS {
		{
			p.SetState(459)
			p.Match(JavaParserTHROWS)
		}
		{
			p.SetState(460)
			p.QualifiedNameList()
		}

	}
	{
		p.SetState(463)

		var _x = p.Block()

		localctx.(*ConstructorDeclarationContext).constructorBody = _x
	}

	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 = JavaParserRULE_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 = JavaParserRULE_fieldDeclaration

	return p
}

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

func (s *FieldDeclarationContext) TypeType() ITypeTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *FieldDeclarationContext) VariableDeclarators() IVariableDeclaratorsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorsContext)
}

func (s *FieldDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, 0)
}

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.(JavaParserListener); ok {
		listenerT.EnterFieldDeclaration(s)
	}
}

func (s *FieldDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitFieldDeclaration(s)
	}
}

func (p *JavaParser) FieldDeclaration() (localctx IFieldDeclarationContext) {
	localctx = NewFieldDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, JavaParserRULE_fieldDeclaration)

	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(465)
		p.TypeType()
	}
	{
		p.SetState(466)
		p.VariableDeclarators()
	}
	{
		p.SetState(467)
		p.Match(JavaParserSEMI)
	}

	return localctx
}

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

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

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

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

func NewEmptyInterfaceBodyDeclarationContext() *InterfaceBodyDeclarationContext {
	var p = new(InterfaceBodyDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_interfaceBodyDeclaration
	return p
}

func (*InterfaceBodyDeclarationContext) IsInterfaceBodyDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_interfaceBodyDeclaration

	return p
}

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

func (s *InterfaceBodyDeclarationContext) InterfaceMemberDeclaration() IInterfaceMemberDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceMemberDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceMemberDeclarationContext)
}

func (s *InterfaceBodyDeclarationContext) AllModifier() []IModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IModifierContext)(nil)).Elem())
	var tst = make([]IModifierContext, len(ts))

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

	return tst
}

func (s *InterfaceBodyDeclarationContext) Modifier(i int) IModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IModifierContext)
}

func (s *InterfaceBodyDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, 0)
}

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

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

func (s *InterfaceBodyDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterInterfaceBodyDeclaration(s)
	}
}

func (s *InterfaceBodyDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitInterfaceBodyDeclaration(s)
	}
}

func (p *JavaParser) InterfaceBodyDeclaration() (localctx IInterfaceBodyDeclarationContext) {
	localctx = NewInterfaceBodyDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 54, JavaParserRULE_interfaceBodyDeclaration)

	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(477)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserABSTRACT, JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserCLASS, JavaParserDEFAULT, JavaParserDOUBLE, JavaParserENUM, JavaParserFINAL, JavaParserFLOAT, JavaParserINT, JavaParserINTERFACE, JavaParserLONG, JavaParserNATIVE, JavaParserPRIVATE, JavaParserPROTECTED, JavaParserPUBLIC, JavaParserSHORT, JavaParserSTATIC, JavaParserSTRICTFP, JavaParserSYNCHRONIZED, JavaParserTRANSIENT, JavaParserVOID, JavaParserVOLATILE, JavaParserLT, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(472)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 41, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(469)
					p.Modifier()
				}

			}
			p.SetState(474)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 41, p.GetParserRuleContext())
		}
		{
			p.SetState(475)
			p.InterfaceMemberDeclaration()
		}

	case JavaParserSEMI:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(476)
			p.Match(JavaParserSEMI)
		}

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

	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 = JavaParserRULE_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 = JavaParserRULE_interfaceMemberDeclaration

	return p
}

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

func (s *InterfaceMemberDeclarationContext) ConstDeclaration() IConstDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstDeclarationContext)
}

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) GenericInterfaceMethodDeclaration() IGenericInterfaceMethodDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGenericInterfaceMethodDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGenericInterfaceMethodDeclarationContext)
}

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) AnnotationTypeDeclaration() IAnnotationTypeDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationTypeDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationTypeDeclarationContext)
}

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) EnumDeclaration() IEnumDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumDeclarationContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterInterfaceMemberDeclaration(s)
	}
}

func (s *InterfaceMemberDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitInterfaceMemberDeclaration(s)
	}
}

func (p *JavaParser) InterfaceMemberDeclaration() (localctx IInterfaceMemberDeclarationContext) {
	localctx = NewInterfaceMemberDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, JavaParserRULE_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(486)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 43, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(479)
			p.ConstDeclaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(480)
			p.InterfaceMethodDeclaration()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(481)
			p.GenericInterfaceMethodDeclaration()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(482)
			p.InterfaceDeclaration()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(483)
			p.AnnotationTypeDeclaration()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(484)
			p.ClassDeclaration()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(485)
			p.EnumDeclaration()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyConstDeclarationContext() *ConstDeclarationContext {
	var p = new(ConstDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_constDeclaration
	return p
}

func (*ConstDeclarationContext) IsConstDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_constDeclaration

	return p
}

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

func (s *ConstDeclarationContext) TypeType() ITypeTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *ConstDeclarationContext) AllConstantDeclarator() []IConstantDeclaratorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IConstantDeclaratorContext)(nil)).Elem())
	var tst = make([]IConstantDeclaratorContext, len(ts))

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

	return tst
}

func (s *ConstDeclarationContext) ConstantDeclarator(i int) IConstantDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantDeclaratorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IConstantDeclaratorContext)
}

func (s *ConstDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, 0)
}

func (s *ConstDeclarationContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(JavaParserCOMMA)
}

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

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

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

func (s *ConstDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterConstDeclaration(s)
	}
}

func (s *ConstDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitConstDeclaration(s)
	}
}

func (p *JavaParser) ConstDeclaration() (localctx IConstDeclarationContext) {
	localctx = NewConstDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, JavaParserRULE_constDeclaration)
	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(488)
		p.TypeType()
	}
	{
		p.SetState(489)
		p.ConstantDeclarator()
	}
	p.SetState(494)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(490)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(491)
			p.ConstantDeclarator()
		}

		p.SetState(496)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(497)
		p.Match(JavaParserSEMI)
	}

	return localctx
}

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

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

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

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

func NewEmptyConstantDeclaratorContext() *ConstantDeclaratorContext {
	var p = new(ConstantDeclaratorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_constantDeclarator
	return p
}

func (*ConstantDeclaratorContext) IsConstantDeclaratorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_constantDeclarator

	return p
}

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

func (s *ConstantDeclaratorContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *ConstantDeclaratorContext) ASSIGN() antlr.TerminalNode {
	return s.GetToken(JavaParserASSIGN, 0)
}

func (s *ConstantDeclaratorContext) VariableInitializer() IVariableInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableInitializerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableInitializerContext)
}

func (s *ConstantDeclaratorContext) AllLBRACK() []antlr.TerminalNode {
	return s.GetTokens(JavaParserLBRACK)
}

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

func (s *ConstantDeclaratorContext) AllRBRACK() []antlr.TerminalNode {
	return s.GetTokens(JavaParserRBRACK)
}

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

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

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

func (s *ConstantDeclaratorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterConstantDeclarator(s)
	}
}

func (s *ConstantDeclaratorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitConstantDeclarator(s)
	}
}

func (p *JavaParser) ConstantDeclarator() (localctx IConstantDeclaratorContext) {
	localctx = NewConstantDeclaratorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 60, JavaParserRULE_constantDeclarator)
	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(499)
		p.Match(JavaParserIDENTIFIER)
	}
	p.SetState(504)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserLBRACK {
		{
			p.SetState(500)
			p.Match(JavaParserLBRACK)
		}
		{
			p.SetState(501)
			p.Match(JavaParserRBRACK)
		}

		p.SetState(506)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(507)
		p.Match(JavaParserASSIGN)
	}
	{
		p.SetState(508)
		p.VariableInitializer()
	}

	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 = JavaParserRULE_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 = JavaParserRULE_interfaceMethodDeclaration

	return p
}

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

func (s *InterfaceMethodDeclarationContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *InterfaceMethodDeclarationContext) FormalParameters() IFormalParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParametersContext)
}

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) TypeTypeOrVoid() ITypeTypeOrVoidContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeOrVoidContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeOrVoidContext)
}

func (s *InterfaceMethodDeclarationContext) TypeParameters() ITypeParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

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) AllLBRACK() []antlr.TerminalNode {
	return s.GetTokens(JavaParserLBRACK)
}

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

func (s *InterfaceMethodDeclarationContext) AllRBRACK() []antlr.TerminalNode {
	return s.GetTokens(JavaParserRBRACK)
}

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

func (s *InterfaceMethodDeclarationContext) THROWS() antlr.TerminalNode {
	return s.GetToken(JavaParserTHROWS, 0)
}

func (s *InterfaceMethodDeclarationContext) QualifiedNameList() IQualifiedNameListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IQualifiedNameListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IQualifiedNameListContext)
}

func (s *InterfaceMethodDeclarationContext) 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 *InterfaceMethodDeclarationContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterInterfaceMethodDeclaration(s)
	}
}

func (s *InterfaceMethodDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitInterfaceMethodDeclaration(s)
	}
}

func (p *JavaParser) InterfaceMethodDeclaration() (localctx IInterfaceMethodDeclarationContext) {
	localctx = NewInterfaceMethodDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 62, JavaParserRULE_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)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(513)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 46, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(510)
				p.InterfaceMethodModifier()
			}

		}
		p.SetState(515)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 46, p.GetParserRuleContext())
	}
	p.SetState(526)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserSHORT, JavaParserVOID, JavaParserAT, JavaParserIDENTIFIER:
		{
			p.SetState(516)
			p.TypeTypeOrVoid()
		}

	case JavaParserLT:
		{
			p.SetState(517)
			p.TypeParameters()
		}
		p.SetState(521)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 47, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(518)
					p.Annotation()
				}

			}
			p.SetState(523)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 47, p.GetParserRuleContext())
		}
		{
			p.SetState(524)
			p.TypeTypeOrVoid()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(528)
		p.Match(JavaParserIDENTIFIER)
	}
	{
		p.SetState(529)
		p.FormalParameters()
	}
	p.SetState(534)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserLBRACK {
		{
			p.SetState(530)
			p.Match(JavaParserLBRACK)
		}
		{
			p.SetState(531)
			p.Match(JavaParserRBRACK)
		}

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

	if _la == JavaParserTHROWS {
		{
			p.SetState(537)
			p.Match(JavaParserTHROWS)
		}
		{
			p.SetState(538)
			p.QualifiedNameList()
		}

	}
	{
		p.SetState(541)
		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 = JavaParserRULE_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 = JavaParserRULE_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(JavaParserPUBLIC, 0)
}

func (s *InterfaceMethodModifierContext) ABSTRACT() antlr.TerminalNode {
	return s.GetToken(JavaParserABSTRACT, 0)
}

func (s *InterfaceMethodModifierContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(JavaParserDEFAULT, 0)
}

func (s *InterfaceMethodModifierContext) STATIC() antlr.TerminalNode {
	return s.GetToken(JavaParserSTATIC, 0)
}

func (s *InterfaceMethodModifierContext) STRICTFP() antlr.TerminalNode {
	return s.GetToken(JavaParserSTRICTFP, 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.(JavaParserListener); ok {
		listenerT.EnterInterfaceMethodModifier(s)
	}
}

func (s *InterfaceMethodModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitInterfaceMethodModifier(s)
	}
}

func (p *JavaParser) InterfaceMethodModifier() (localctx IInterfaceMethodModifierContext) {
	localctx = NewInterfaceMethodModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 64, JavaParserRULE_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(549)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserAT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(543)
			p.Annotation()
		}

	case JavaParserPUBLIC:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(544)
			p.Match(JavaParserPUBLIC)
		}

	case JavaParserABSTRACT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(545)
			p.Match(JavaParserABSTRACT)
		}

	case JavaParserDEFAULT:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(546)
			p.Match(JavaParserDEFAULT)
		}

	case JavaParserSTATIC:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(547)
			p.Match(JavaParserSTATIC)
		}

	case JavaParserSTRICTFP:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(548)
			p.Match(JavaParserSTRICTFP)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyGenericInterfaceMethodDeclarationContext() *GenericInterfaceMethodDeclarationContext {
	var p = new(GenericInterfaceMethodDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_genericInterfaceMethodDeclaration
	return p
}

func (*GenericInterfaceMethodDeclarationContext) IsGenericInterfaceMethodDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_genericInterfaceMethodDeclaration

	return p
}

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

func (s *GenericInterfaceMethodDeclarationContext) TypeParameters() ITypeParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

func (s *GenericInterfaceMethodDeclarationContext) InterfaceMethodDeclaration() IInterfaceMethodDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceMethodDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceMethodDeclarationContext)
}

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

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

func (s *GenericInterfaceMethodDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterGenericInterfaceMethodDeclaration(s)
	}
}

func (s *GenericInterfaceMethodDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitGenericInterfaceMethodDeclaration(s)
	}
}

func (p *JavaParser) GenericInterfaceMethodDeclaration() (localctx IGenericInterfaceMethodDeclarationContext) {
	localctx = NewGenericInterfaceMethodDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, JavaParserRULE_genericInterfaceMethodDeclaration)

	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(551)
		p.TypeParameters()
	}
	{
		p.SetState(552)
		p.InterfaceMethodDeclaration()
	}

	return localctx
}

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

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

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

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

func NewEmptyVariableDeclaratorsContext() *VariableDeclaratorsContext {
	var p = new(VariableDeclaratorsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_variableDeclarators
	return p
}

func (*VariableDeclaratorsContext) IsVariableDeclaratorsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_variableDeclarators

	return p
}

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

func (s *VariableDeclaratorsContext) 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 *VariableDeclaratorsContext) VariableDeclarator(i int) IVariableDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorContext)
}

func (s *VariableDeclaratorsContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(JavaParserCOMMA)
}

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

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

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

func (s *VariableDeclaratorsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterVariableDeclarators(s)
	}
}

func (s *VariableDeclaratorsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitVariableDeclarators(s)
	}
}

func (p *JavaParser) VariableDeclarators() (localctx IVariableDeclaratorsContext) {
	localctx = NewVariableDeclaratorsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, JavaParserRULE_variableDeclarators)
	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(554)
		p.VariableDeclarator()
	}
	p.SetState(559)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(555)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(556)
			p.VariableDeclarator()
		}

		p.SetState(561)
		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 = JavaParserRULE_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 = JavaParserRULE_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(JavaParserASSIGN, 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.(JavaParserListener); ok {
		listenerT.EnterVariableDeclarator(s)
	}
}

func (s *VariableDeclaratorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitVariableDeclarator(s)
	}
}

func (p *JavaParser) VariableDeclarator() (localctx IVariableDeclaratorContext) {
	localctx = NewVariableDeclaratorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, JavaParserRULE_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(562)
		p.VariableDeclaratorId()
	}
	p.SetState(565)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserASSIGN {
		{
			p.SetState(563)
			p.Match(JavaParserASSIGN)
		}
		{
			p.SetState(564)
			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 = JavaParserRULE_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 = JavaParserRULE_variableDeclaratorId

	return p
}

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

func (s *VariableDeclaratorIdContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *VariableDeclaratorIdContext) AllLBRACK() []antlr.TerminalNode {
	return s.GetTokens(JavaParserLBRACK)
}

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

func (s *VariableDeclaratorIdContext) AllRBRACK() []antlr.TerminalNode {
	return s.GetTokens(JavaParserRBRACK)
}

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

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.(JavaParserListener); ok {
		listenerT.EnterVariableDeclaratorId(s)
	}
}

func (s *VariableDeclaratorIdContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitVariableDeclaratorId(s)
	}
}

func (p *JavaParser) VariableDeclaratorId() (localctx IVariableDeclaratorIdContext) {
	localctx = NewVariableDeclaratorIdContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, JavaParserRULE_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(567)
		p.Match(JavaParserIDENTIFIER)
	}
	p.SetState(572)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserLBRACK {
		{
			p.SetState(568)
			p.Match(JavaParserLBRACK)
		}
		{
			p.SetState(569)
			p.Match(JavaParserRBRACK)
		}

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

	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 = JavaParserRULE_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 = JavaParserRULE_variableInitializer

	return p
}

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

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) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterVariableInitializer(s)
	}
}

func (s *VariableInitializerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitVariableInitializer(s)
	}
}

func (p *JavaParser) VariableInitializer() (localctx IVariableInitializerContext) {
	localctx = NewVariableInitializerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, JavaParserRULE_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(577)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserLBRACE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(575)
			p.ArrayInitializer()
		}

	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserNEW, JavaParserSHORT, JavaParserSUPER, JavaParserTHIS, JavaParserVOID, JavaParserDECIMAL_LITERAL, JavaParserHEX_LITERAL, JavaParserOCT_LITERAL, JavaParserBINARY_LITERAL, JavaParserFLOAT_LITERAL, JavaParserHEX_FLOAT_LITERAL, JavaParserBOOL_LITERAL, JavaParserCHAR_LITERAL, JavaParserSTRING_LITERAL, JavaParserNULL_LITERAL, JavaParserLPAREN, JavaParserLT, JavaParserBANG, JavaParserTILDE, JavaParserINC, JavaParserDEC, JavaParserADD, JavaParserSUB, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(576)
			p.expression(0)
		}

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

	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 = JavaParserRULE_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 = JavaParserRULE_arrayInitializer

	return p
}

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

func (s *ArrayInitializerContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserLBRACE, 0)
}

func (s *ArrayInitializerContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserRBRACE, 0)
}

func (s *ArrayInitializerContext) 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 *ArrayInitializerContext) VariableInitializer(i int) IVariableInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableInitializerContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableInitializerContext)
}

func (s *ArrayInitializerContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(JavaParserCOMMA)
}

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

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.(JavaParserListener); ok {
		listenerT.EnterArrayInitializer(s)
	}
}

func (s *ArrayInitializerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitArrayInitializer(s)
	}
}

func (p *JavaParser) ArrayInitializer() (localctx IArrayInitializerContext) {
	localctx = NewArrayInitializerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 76, JavaParserRULE_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)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(579)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(591)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserDOUBLE)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserLONG)|(1<<JavaParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(JavaParserSHORT-37))|(1<<(JavaParserSUPER-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37))|(1<<(JavaParserOCT_LITERAL-37))|(1<<(JavaParserBINARY_LITERAL-37))|(1<<(JavaParserFLOAT_LITERAL-37))|(1<<(JavaParserHEX_FLOAT_LITERAL-37))|(1<<(JavaParserBOOL_LITERAL-37))|(1<<(JavaParserCHAR_LITERAL-37))|(1<<(JavaParserSTRING_LITERAL-37))|(1<<(JavaParserNULL_LITERAL-37))|(1<<(JavaParserLPAREN-37))|(1<<(JavaParserLBRACE-37)))) != 0) || (((_la-72)&-(0x1f+1)) == 0 && ((1<<uint((_la-72)))&((1<<(JavaParserLT-72))|(1<<(JavaParserBANG-72))|(1<<(JavaParserTILDE-72))|(1<<(JavaParserINC-72))|(1<<(JavaParserDEC-72))|(1<<(JavaParserADD-72))|(1<<(JavaParserSUB-72)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(580)
			p.VariableInitializer()
		}
		p.SetState(585)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 56, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(581)
					p.Match(JavaParserCOMMA)
				}
				{
					p.SetState(582)
					p.VariableInitializer()
				}

			}
			p.SetState(587)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 56, p.GetParserRuleContext())
		}
		p.SetState(589)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserCOMMA {
			{
				p.SetState(588)
				p.Match(JavaParserCOMMA)
			}

		}

	}
	{
		p.SetState(593)
		p.Match(JavaParserRBRACE)
	}

	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 = JavaParserRULE_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 = JavaParserRULE_classOrInterfaceType

	return p
}

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

func (s *ClassOrInterfaceTypeContext) AllIDENTIFIER() []antlr.TerminalNode {
	return s.GetTokens(JavaParserIDENTIFIER)
}

func (s *ClassOrInterfaceTypeContext) IDENTIFIER(i int) antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, i)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *ClassOrInterfaceTypeContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(JavaParserDOT)
}

func (s *ClassOrInterfaceTypeContext) DOT(i int) antlr.TerminalNode {
	return s.GetToken(JavaParserDOT, i)
}

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.(JavaParserListener); ok {
		listenerT.EnterClassOrInterfaceType(s)
	}
}

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

func (p *JavaParser) ClassOrInterfaceType() (localctx IClassOrInterfaceTypeContext) {
	localctx = NewClassOrInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, JavaParserRULE_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(595)
		p.Match(JavaParserIDENTIFIER)
	}
	p.SetState(597)
	p.GetErrorHandler().Sync(p)

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

	}
	p.SetState(606)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 61, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(599)
				p.Match(JavaParserDOT)
			}
			{
				p.SetState(600)
				p.Match(JavaParserIDENTIFIER)
			}
			p.SetState(602)
			p.GetErrorHandler().Sync(p)

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

			}

		}
		p.SetState(608)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 61, p.GetParserRuleContext())
	}

	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 = JavaParserRULE_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 = JavaParserRULE_typeArgument

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *TypeArgumentContext) QUESTION() antlr.TerminalNode {
	return s.GetToken(JavaParserQUESTION, 0)
}

func (s *TypeArgumentContext) EXTENDS() antlr.TerminalNode {
	return s.GetToken(JavaParserEXTENDS, 0)
}

func (s *TypeArgumentContext) SUPER() antlr.TerminalNode {
	return s.GetToken(JavaParserSUPER, 0)
}

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.(JavaParserListener); ok {
		listenerT.EnterTypeArgument(s)
	}
}

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

func (p *JavaParser) TypeArgument() (localctx ITypeArgumentContext) {
	localctx = NewTypeArgumentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, JavaParserRULE_typeArgument)
	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(615)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserSHORT, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(609)
			p.TypeType()
		}

	case JavaParserQUESTION:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(610)
			p.Match(JavaParserQUESTION)
		}
		p.SetState(613)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserEXTENDS || _la == JavaParserSUPER {
			{
				p.SetState(611)
				_la = p.GetTokenStream().LA(1)

				if !(_la == JavaParserEXTENDS || _la == JavaParserSUPER) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(612)
				p.TypeType()
			}

		}

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

	return localctx
}

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

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

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

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

func NewEmptyQualifiedNameListContext() *QualifiedNameListContext {
	var p = new(QualifiedNameListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_qualifiedNameList
	return p
}

func (*QualifiedNameListContext) IsQualifiedNameListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_qualifiedNameList

	return p
}

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

func (s *QualifiedNameListContext) AllQualifiedName() []IQualifiedNameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IQualifiedNameContext)(nil)).Elem())
	var tst = make([]IQualifiedNameContext, len(ts))

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

	return tst
}

func (s *QualifiedNameListContext) QualifiedName(i int) IQualifiedNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IQualifiedNameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IQualifiedNameContext)
}

func (s *QualifiedNameListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(JavaParserCOMMA)
}

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

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

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

func (s *QualifiedNameListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterQualifiedNameList(s)
	}
}

func (s *QualifiedNameListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitQualifiedNameList(s)
	}
}

func (p *JavaParser) QualifiedNameList() (localctx IQualifiedNameListContext) {
	localctx = NewQualifiedNameListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, JavaParserRULE_qualifiedNameList)
	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(617)
		p.QualifiedName()
	}
	p.SetState(622)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(618)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(619)
			p.QualifiedName()
		}

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

	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 = JavaParserRULE_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 = JavaParserRULE_formalParameters

	return p
}

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

func (s *FormalParametersContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserLPAREN, 0)
}

func (s *FormalParametersContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserRPAREN, 0)
}

func (s *FormalParametersContext) FormalParameterList() IFormalParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterListContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterFormalParameters(s)
	}
}

func (s *FormalParametersContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitFormalParameters(s)
	}
}

func (p *JavaParser) FormalParameters() (localctx IFormalParametersContext) {
	localctx = NewFormalParametersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 84, JavaParserRULE_formalParameters)
	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(625)
		p.Match(JavaParserLPAREN)
	}
	p.SetState(627)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserDOUBLE)|(1<<JavaParserFINAL)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserLONG))) != 0) || _la == JavaParserSHORT || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(626)
			p.FormalParameterList()
		}

	}
	{
		p.SetState(629)
		p.Match(JavaParserRPAREN)
	}

	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 = JavaParserRULE_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 = JavaParserRULE_formalParameterList

	return p
}

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

func (s *FormalParameterListContext) 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 *FormalParameterListContext) FormalParameter(i int) IFormalParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterContext)
}

func (s *FormalParameterListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(JavaParserCOMMA)
}

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

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.(JavaParserListener); ok {
		listenerT.EnterFormalParameterList(s)
	}
}

func (s *FormalParameterListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitFormalParameterList(s)
	}
}

func (p *JavaParser) FormalParameterList() (localctx IFormalParameterListContext) {
	localctx = NewFormalParameterListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, JavaParserRULE_formalParameterList)
	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.SetState(644)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 68, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(631)
			p.FormalParameter()
		}
		p.SetState(636)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 66, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(632)
					p.Match(JavaParserCOMMA)
				}
				{
					p.SetState(633)
					p.FormalParameter()
				}

			}
			p.SetState(638)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 66, p.GetParserRuleContext())
		}
		p.SetState(641)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserCOMMA {
			{
				p.SetState(639)
				p.Match(JavaParserCOMMA)
			}
			{
				p.SetState(640)
				p.LastFormalParameter()
			}

		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(643)
			p.LastFormalParameter()
		}

	}

	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 = JavaParserRULE_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 = JavaParserRULE_formalParameter

	return p
}

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

func (s *FormalParameterContext) TypeType() ITypeTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterFormalParameter(s)
	}
}

func (s *FormalParameterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitFormalParameter(s)
	}
}

func (p *JavaParser) FormalParameter() (localctx IFormalParameterContext) {
	localctx = NewFormalParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, JavaParserRULE_formalParameter)

	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(649)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 69, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(646)
				p.VariableModifier()
			}

		}
		p.SetState(651)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 69, p.GetParserRuleContext())
	}
	{
		p.SetState(652)
		p.TypeType()
	}
	{
		p.SetState(653)
		p.VariableDeclaratorId()
	}

	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 = JavaParserRULE_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 = JavaParserRULE_lastFormalParameter

	return p
}

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

func (s *LastFormalParameterContext) TypeType() ITypeTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *LastFormalParameterContext) ELLIPSIS() antlr.TerminalNode {
	return s.GetToken(JavaParserELLIPSIS, 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) 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.(JavaParserListener); ok {
		listenerT.EnterLastFormalParameter(s)
	}
}

func (s *LastFormalParameterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitLastFormalParameter(s)
	}
}

func (p *JavaParser) LastFormalParameter() (localctx ILastFormalParameterContext) {
	localctx = NewLastFormalParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, JavaParserRULE_lastFormalParameter)

	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(658)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 70, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(655)
				p.VariableModifier()
			}

		}
		p.SetState(660)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 70, p.GetParserRuleContext())
	}
	{
		p.SetState(661)
		p.TypeType()
	}
	{
		p.SetState(662)
		p.Match(JavaParserELLIPSIS)
	}
	{
		p.SetState(663)
		p.VariableDeclaratorId()
	}

	return localctx
}

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

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

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

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

func NewEmptyQualifiedNameContext() *QualifiedNameContext {
	var p = new(QualifiedNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_qualifiedName
	return p
}

func (*QualifiedNameContext) IsQualifiedNameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_qualifiedName

	return p
}

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

func (s *QualifiedNameContext) AllIDENTIFIER() []antlr.TerminalNode {
	return s.GetTokens(JavaParserIDENTIFIER)
}

func (s *QualifiedNameContext) IDENTIFIER(i int) antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, i)
}

func (s *QualifiedNameContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(JavaParserDOT)
}

func (s *QualifiedNameContext) DOT(i int) antlr.TerminalNode {
	return s.GetToken(JavaParserDOT, i)
}

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

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

func (s *QualifiedNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterQualifiedName(s)
	}
}

func (s *QualifiedNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitQualifiedName(s)
	}
}

func (p *JavaParser) QualifiedName() (localctx IQualifiedNameContext) {
	localctx = NewQualifiedNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, JavaParserRULE_qualifiedName)

	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(665)
		p.Match(JavaParserIDENTIFIER)
	}
	p.SetState(670)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 71, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(666)
				p.Match(JavaParserDOT)
			}
			{
				p.SetState(667)
				p.Match(JavaParserIDENTIFIER)
			}

		}
		p.SetState(672)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 71, p.GetParserRuleContext())
	}

	return localctx
}

// 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 = JavaParserRULE_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 = JavaParserRULE_literal

	return p
}

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

func (s *LiteralContext) IntegerLiteral() IIntegerLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIntegerLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIntegerLiteralContext)
}

func (s *LiteralContext) FloatLiteral() IFloatLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFloatLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFloatLiteralContext)
}

func (s *LiteralContext) CHAR_LITERAL() antlr.TerminalNode {
	return s.GetToken(JavaParserCHAR_LITERAL, 0)
}

func (s *LiteralContext) STRING_LITERAL() antlr.TerminalNode {
	return s.GetToken(JavaParserSTRING_LITERAL, 0)
}

func (s *LiteralContext) BOOL_LITERAL() antlr.TerminalNode {
	return s.GetToken(JavaParserBOOL_LITERAL, 0)
}

func (s *LiteralContext) NULL_LITERAL() antlr.TerminalNode {
	return s.GetToken(JavaParserNULL_LITERAL, 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.(JavaParserListener); ok {
		listenerT.EnterLiteral(s)
	}
}

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

func (p *JavaParser) Literal() (localctx ILiteralContext) {
	localctx = NewLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, JavaParserRULE_literal)

	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(679)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserDECIMAL_LITERAL, JavaParserHEX_LITERAL, JavaParserOCT_LITERAL, JavaParserBINARY_LITERAL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(673)
			p.IntegerLiteral()
		}

	case JavaParserFLOAT_LITERAL, JavaParserHEX_FLOAT_LITERAL:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(674)
			p.FloatLiteral()
		}

	case JavaParserCHAR_LITERAL:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(675)
			p.Match(JavaParserCHAR_LITERAL)
		}

	case JavaParserSTRING_LITERAL:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(676)
			p.Match(JavaParserSTRING_LITERAL)
		}

	case JavaParserBOOL_LITERAL:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(677)
			p.Match(JavaParserBOOL_LITERAL)
		}

	case JavaParserNULL_LITERAL:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(678)
			p.Match(JavaParserNULL_LITERAL)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyIntegerLiteralContext() *IntegerLiteralContext {
	var p = new(IntegerLiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_integerLiteral
	return p
}

func (*IntegerLiteralContext) IsIntegerLiteralContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_integerLiteral

	return p
}

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

func (s *IntegerLiteralContext) DECIMAL_LITERAL() antlr.TerminalNode {
	return s.GetToken(JavaParserDECIMAL_LITERAL, 0)
}

func (s *IntegerLiteralContext) HEX_LITERAL() antlr.TerminalNode {
	return s.GetToken(JavaParserHEX_LITERAL, 0)
}

func (s *IntegerLiteralContext) OCT_LITERAL() antlr.TerminalNode {
	return s.GetToken(JavaParserOCT_LITERAL, 0)
}

func (s *IntegerLiteralContext) BINARY_LITERAL() antlr.TerminalNode {
	return s.GetToken(JavaParserBINARY_LITERAL, 0)
}

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

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

func (s *IntegerLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterIntegerLiteral(s)
	}
}

func (s *IntegerLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitIntegerLiteral(s)
	}
}

func (p *JavaParser) IntegerLiteral() (localctx IIntegerLiteralContext) {
	localctx = NewIntegerLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 96, JavaParserRULE_integerLiteral)
	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(681)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-51)&-(0x1f+1)) == 0 && ((1<<uint((_la-51)))&((1<<(JavaParserDECIMAL_LITERAL-51))|(1<<(JavaParserHEX_LITERAL-51))|(1<<(JavaParserOCT_LITERAL-51))|(1<<(JavaParserBINARY_LITERAL-51)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

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

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

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

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

func NewEmptyFloatLiteralContext() *FloatLiteralContext {
	var p = new(FloatLiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_floatLiteral
	return p
}

func (*FloatLiteralContext) IsFloatLiteralContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_floatLiteral

	return p
}

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

func (s *FloatLiteralContext) FLOAT_LITERAL() antlr.TerminalNode {
	return s.GetToken(JavaParserFLOAT_LITERAL, 0)
}

func (s *FloatLiteralContext) HEX_FLOAT_LITERAL() antlr.TerminalNode {
	return s.GetToken(JavaParserHEX_FLOAT_LITERAL, 0)
}

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

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

func (s *FloatLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterFloatLiteral(s)
	}
}

func (s *FloatLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitFloatLiteral(s)
	}
}

func (p *JavaParser) FloatLiteral() (localctx IFloatLiteralContext) {
	localctx = NewFloatLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 98, JavaParserRULE_floatLiteral)
	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(683)
		_la = p.GetTokenStream().LA(1)

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

	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 = JavaParserRULE_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 = JavaParserRULE_annotation

	return p
}

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

func (s *AnnotationContext) AT() antlr.TerminalNode {
	return s.GetToken(JavaParserAT, 0)
}

func (s *AnnotationContext) QualifiedName() IQualifiedNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IQualifiedNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IQualifiedNameContext)
}

func (s *AnnotationContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserLPAREN, 0)
}

func (s *AnnotationContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserRPAREN, 0)
}

func (s *AnnotationContext) ElementValuePairs() IElementValuePairsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementValuePairsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementValuePairsContext)
}

func (s *AnnotationContext) ElementValue() IElementValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementValueContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterAnnotation(s)
	}
}

func (s *AnnotationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitAnnotation(s)
	}
}

func (p *JavaParser) Annotation() (localctx IAnnotationContext) {
	localctx = NewAnnotationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, JavaParserRULE_annotation)
	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(685)
		p.Match(JavaParserAT)
	}
	{
		p.SetState(686)
		p.QualifiedName()
	}
	p.SetState(693)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserLPAREN {
		{
			p.SetState(687)
			p.Match(JavaParserLPAREN)
		}
		p.SetState(690)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 73, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(688)
				p.ElementValuePairs()
			}

		} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 73, p.GetParserRuleContext()) == 2 {
			{
				p.SetState(689)
				p.ElementValue()
			}

		}
		{
			p.SetState(692)
			p.Match(JavaParserRPAREN)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyElementValuePairsContext() *ElementValuePairsContext {
	var p = new(ElementValuePairsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_elementValuePairs
	return p
}

func (*ElementValuePairsContext) IsElementValuePairsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_elementValuePairs

	return p
}

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

func (s *ElementValuePairsContext) 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 *ElementValuePairsContext) ElementValuePair(i int) IElementValuePairContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementValuePairContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IElementValuePairContext)
}

func (s *ElementValuePairsContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(JavaParserCOMMA)
}

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

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

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

func (s *ElementValuePairsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterElementValuePairs(s)
	}
}

func (s *ElementValuePairsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitElementValuePairs(s)
	}
}

func (p *JavaParser) ElementValuePairs() (localctx IElementValuePairsContext) {
	localctx = NewElementValuePairsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, JavaParserRULE_elementValuePairs)
	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(695)
		p.ElementValuePair()
	}
	p.SetState(700)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(696)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(697)
			p.ElementValuePair()
		}

		p.SetState(702)
		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 = JavaParserRULE_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 = JavaParserRULE_elementValuePair

	return p
}

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

func (s *ElementValuePairContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *ElementValuePairContext) ASSIGN() antlr.TerminalNode {
	return s.GetToken(JavaParserASSIGN, 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.(JavaParserListener); ok {
		listenerT.EnterElementValuePair(s)
	}
}

func (s *ElementValuePairContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitElementValuePair(s)
	}
}

func (p *JavaParser) ElementValuePair() (localctx IElementValuePairContext) {
	localctx = NewElementValuePairContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 104, JavaParserRULE_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(703)
		p.Match(JavaParserIDENTIFIER)
	}
	{
		p.SetState(704)
		p.Match(JavaParserASSIGN)
	}
	{
		p.SetState(705)
		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 = JavaParserRULE_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 = JavaParserRULE_elementValue

	return p
}

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

func (s *ElementValueContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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) ElementValueArrayInitializer() IElementValueArrayInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementValueArrayInitializerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementValueArrayInitializerContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterElementValue(s)
	}
}

func (s *ElementValueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitElementValue(s)
	}
}

func (p *JavaParser) ElementValue() (localctx IElementValueContext) {
	localctx = NewElementValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, JavaParserRULE_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(710)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 76, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(707)
			p.expression(0)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(708)
			p.Annotation()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(709)
			p.ElementValueArrayInitializer()
		}

	}

	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 = JavaParserRULE_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 = JavaParserRULE_elementValueArrayInitializer

	return p
}

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

func (s *ElementValueArrayInitializerContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserLBRACE, 0)
}

func (s *ElementValueArrayInitializerContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserRBRACE, 0)
}

func (s *ElementValueArrayInitializerContext) 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 *ElementValueArrayInitializerContext) ElementValue(i int) IElementValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementValueContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IElementValueContext)
}

func (s *ElementValueArrayInitializerContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(JavaParserCOMMA)
}

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

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.(JavaParserListener); ok {
		listenerT.EnterElementValueArrayInitializer(s)
	}
}

func (s *ElementValueArrayInitializerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitElementValueArrayInitializer(s)
	}
}

func (p *JavaParser) ElementValueArrayInitializer() (localctx IElementValueArrayInitializerContext) {
	localctx = NewElementValueArrayInitializerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, JavaParserRULE_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)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(712)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(721)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserDOUBLE)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserLONG)|(1<<JavaParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(JavaParserSHORT-37))|(1<<(JavaParserSUPER-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37))|(1<<(JavaParserOCT_LITERAL-37))|(1<<(JavaParserBINARY_LITERAL-37))|(1<<(JavaParserFLOAT_LITERAL-37))|(1<<(JavaParserHEX_FLOAT_LITERAL-37))|(1<<(JavaParserBOOL_LITERAL-37))|(1<<(JavaParserCHAR_LITERAL-37))|(1<<(JavaParserSTRING_LITERAL-37))|(1<<(JavaParserNULL_LITERAL-37))|(1<<(JavaParserLPAREN-37))|(1<<(JavaParserLBRACE-37)))) != 0) || (((_la-72)&-(0x1f+1)) == 0 && ((1<<uint((_la-72)))&((1<<(JavaParserLT-72))|(1<<(JavaParserBANG-72))|(1<<(JavaParserTILDE-72))|(1<<(JavaParserINC-72))|(1<<(JavaParserDEC-72))|(1<<(JavaParserADD-72))|(1<<(JavaParserSUB-72)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(713)
			p.ElementValue()
		}
		p.SetState(718)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 77, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(714)
					p.Match(JavaParserCOMMA)
				}
				{
					p.SetState(715)
					p.ElementValue()
				}

			}
			p.SetState(720)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 77, p.GetParserRuleContext())
		}

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

	if _la == JavaParserCOMMA {
		{
			p.SetState(723)
			p.Match(JavaParserCOMMA)
		}

	}
	{
		p.SetState(726)
		p.Match(JavaParserRBRACE)
	}

	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 = JavaParserRULE_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 = JavaParserRULE_annotationTypeDeclaration

	return p
}

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

func (s *AnnotationTypeDeclarationContext) AT() antlr.TerminalNode {
	return s.GetToken(JavaParserAT, 0)
}

func (s *AnnotationTypeDeclarationContext) INTERFACE() antlr.TerminalNode {
	return s.GetToken(JavaParserINTERFACE, 0)
}

func (s *AnnotationTypeDeclarationContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 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) 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.(JavaParserListener); ok {
		listenerT.EnterAnnotationTypeDeclaration(s)
	}
}

func (s *AnnotationTypeDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitAnnotationTypeDeclaration(s)
	}
}

func (p *JavaParser) AnnotationTypeDeclaration() (localctx IAnnotationTypeDeclarationContext) {
	localctx = NewAnnotationTypeDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, JavaParserRULE_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)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(728)
		p.Match(JavaParserAT)
	}
	{
		p.SetState(729)
		p.Match(JavaParserINTERFACE)
	}
	{
		p.SetState(730)
		p.Match(JavaParserIDENTIFIER)
	}
	{
		p.SetState(731)
		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 = JavaParserRULE_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 = JavaParserRULE_annotationTypeBody

	return p
}

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

func (s *AnnotationTypeBodyContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserLBRACE, 0)
}

func (s *AnnotationTypeBodyContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserRBRACE, 0)
}

func (s *AnnotationTypeBodyContext) AllAnnotationTypeElementDeclaration() []IAnnotationTypeElementDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationTypeElementDeclarationContext)(nil)).Elem())
	var tst = make([]IAnnotationTypeElementDeclarationContext, len(ts))

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

	return tst
}

func (s *AnnotationTypeBodyContext) AnnotationTypeElementDeclaration(i int) IAnnotationTypeElementDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationTypeElementDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationTypeElementDeclarationContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterAnnotationTypeBody(s)
	}
}

func (s *AnnotationTypeBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitAnnotationTypeBody(s)
	}
}

func (p *JavaParser) AnnotationTypeBody() (localctx IAnnotationTypeBodyContext) {
	localctx = NewAnnotationTypeBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 112, JavaParserRULE_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(733)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(737)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserABSTRACT)|(1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserCLASS)|(1<<JavaParserDOUBLE)|(1<<JavaParserENUM)|(1<<JavaParserFINAL)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserINTERFACE)|(1<<JavaParserLONG)|(1<<JavaParserNATIVE))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(JavaParserPRIVATE-33))|(1<<(JavaParserPROTECTED-33))|(1<<(JavaParserPUBLIC-33))|(1<<(JavaParserSHORT-33))|(1<<(JavaParserSTATIC-33))|(1<<(JavaParserSTRICTFP-33))|(1<<(JavaParserSYNCHRONIZED-33))|(1<<(JavaParserTRANSIENT-33))|(1<<(JavaParserVOLATILE-33)))) != 0) || _la == JavaParserSEMI || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(734)
			p.AnnotationTypeElementDeclaration()
		}

		p.SetState(739)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(740)
		p.Match(JavaParserRBRACE)
	}

	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 = JavaParserRULE_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 = JavaParserRULE_annotationTypeElementDeclaration

	return p
}

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

func (s *AnnotationTypeElementDeclarationContext) AnnotationTypeElementRest() IAnnotationTypeElementRestContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationTypeElementRestContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationTypeElementRestContext)
}

func (s *AnnotationTypeElementDeclarationContext) AllModifier() []IModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IModifierContext)(nil)).Elem())
	var tst = make([]IModifierContext, len(ts))

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

	return tst
}

func (s *AnnotationTypeElementDeclarationContext) Modifier(i int) IModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IModifierContext)
}

func (s *AnnotationTypeElementDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, 0)
}

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.(JavaParserListener); ok {
		listenerT.EnterAnnotationTypeElementDeclaration(s)
	}
}

func (s *AnnotationTypeElementDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitAnnotationTypeElementDeclaration(s)
	}
}

func (p *JavaParser) AnnotationTypeElementDeclaration() (localctx IAnnotationTypeElementDeclarationContext) {
	localctx = NewAnnotationTypeElementDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 114, JavaParserRULE_annotationTypeElementDeclaration)

	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(750)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserABSTRACT, JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserCLASS, JavaParserDOUBLE, JavaParserENUM, JavaParserFINAL, JavaParserFLOAT, JavaParserINT, JavaParserINTERFACE, JavaParserLONG, JavaParserNATIVE, JavaParserPRIVATE, JavaParserPROTECTED, JavaParserPUBLIC, JavaParserSHORT, JavaParserSTATIC, JavaParserSTRICTFP, JavaParserSYNCHRONIZED, JavaParserTRANSIENT, JavaParserVOLATILE, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(745)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 81, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(742)
					p.Modifier()
				}

			}
			p.SetState(747)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 81, p.GetParserRuleContext())
		}
		{
			p.SetState(748)
			p.AnnotationTypeElementRest()
		}

	case JavaParserSEMI:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(749)
			p.Match(JavaParserSEMI)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAnnotationTypeElementRestContext() *AnnotationTypeElementRestContext {
	var p = new(AnnotationTypeElementRestContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_annotationTypeElementRest
	return p
}

func (*AnnotationTypeElementRestContext) IsAnnotationTypeElementRestContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_annotationTypeElementRest

	return p
}

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

func (s *AnnotationTypeElementRestContext) TypeType() ITypeTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *AnnotationTypeElementRestContext) AnnotationMethodOrConstantRest() IAnnotationMethodOrConstantRestContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationMethodOrConstantRestContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationMethodOrConstantRestContext)
}

func (s *AnnotationTypeElementRestContext) SEMI() antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, 0)
}

func (s *AnnotationTypeElementRestContext) ClassDeclaration() IClassDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassDeclarationContext)
}

func (s *AnnotationTypeElementRestContext) InterfaceDeclaration() IInterfaceDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceDeclarationContext)
}

func (s *AnnotationTypeElementRestContext) EnumDeclaration() IEnumDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumDeclarationContext)
}

func (s *AnnotationTypeElementRestContext) AnnotationTypeDeclaration() IAnnotationTypeDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationTypeDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationTypeDeclarationContext)
}

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

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

func (s *AnnotationTypeElementRestContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterAnnotationTypeElementRest(s)
	}
}

func (s *AnnotationTypeElementRestContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitAnnotationTypeElementRest(s)
	}
}

func (p *JavaParser) AnnotationTypeElementRest() (localctx IAnnotationTypeElementRestContext) {
	localctx = NewAnnotationTypeElementRestContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, JavaParserRULE_annotationTypeElementRest)

	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(772)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 87, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(752)
			p.TypeType()
		}
		{
			p.SetState(753)
			p.AnnotationMethodOrConstantRest()
		}
		{
			p.SetState(754)
			p.Match(JavaParserSEMI)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(756)
			p.ClassDeclaration()
		}
		p.SetState(758)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 83, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(757)
				p.Match(JavaParserSEMI)
			}

		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(760)
			p.InterfaceDeclaration()
		}
		p.SetState(762)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 84, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(761)
				p.Match(JavaParserSEMI)
			}

		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(764)
			p.EnumDeclaration()
		}
		p.SetState(766)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 85, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(765)
				p.Match(JavaParserSEMI)
			}

		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(768)
			p.AnnotationTypeDeclaration()
		}
		p.SetState(770)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 86, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(769)
				p.Match(JavaParserSEMI)
			}

		}

	}

	return localctx
}

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

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

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

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

func NewEmptyAnnotationMethodOrConstantRestContext() *AnnotationMethodOrConstantRestContext {
	var p = new(AnnotationMethodOrConstantRestContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_annotationMethodOrConstantRest
	return p
}

func (*AnnotationMethodOrConstantRestContext) IsAnnotationMethodOrConstantRestContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_annotationMethodOrConstantRest

	return p
}

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

func (s *AnnotationMethodOrConstantRestContext) AnnotationMethodRest() IAnnotationMethodRestContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationMethodRestContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationMethodRestContext)
}

func (s *AnnotationMethodOrConstantRestContext) AnnotationConstantRest() IAnnotationConstantRestContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationConstantRestContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnnotationConstantRestContext)
}

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

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

func (s *AnnotationMethodOrConstantRestContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterAnnotationMethodOrConstantRest(s)
	}
}

func (s *AnnotationMethodOrConstantRestContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitAnnotationMethodOrConstantRest(s)
	}
}

func (p *JavaParser) AnnotationMethodOrConstantRest() (localctx IAnnotationMethodOrConstantRestContext) {
	localctx = NewAnnotationMethodOrConstantRestContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, JavaParserRULE_annotationMethodOrConstantRest)

	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(776)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 88, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(774)
			p.AnnotationMethodRest()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(775)
			p.AnnotationConstantRest()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyAnnotationMethodRestContext() *AnnotationMethodRestContext {
	var p = new(AnnotationMethodRestContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_annotationMethodRest
	return p
}

func (*AnnotationMethodRestContext) IsAnnotationMethodRestContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_annotationMethodRest

	return p
}

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

func (s *AnnotationMethodRestContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *AnnotationMethodRestContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserLPAREN, 0)
}

func (s *AnnotationMethodRestContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserRPAREN, 0)
}

func (s *AnnotationMethodRestContext) DefaultValue() IDefaultValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDefaultValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDefaultValueContext)
}

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

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

func (s *AnnotationMethodRestContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterAnnotationMethodRest(s)
	}
}

func (s *AnnotationMethodRestContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitAnnotationMethodRest(s)
	}
}

func (p *JavaParser) AnnotationMethodRest() (localctx IAnnotationMethodRestContext) {
	localctx = NewAnnotationMethodRestContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, JavaParserRULE_annotationMethodRest)
	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(778)
		p.Match(JavaParserIDENTIFIER)
	}
	{
		p.SetState(779)
		p.Match(JavaParserLPAREN)
	}
	{
		p.SetState(780)
		p.Match(JavaParserRPAREN)
	}
	p.SetState(782)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserDEFAULT {
		{
			p.SetState(781)
			p.DefaultValue()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyAnnotationConstantRestContext() *AnnotationConstantRestContext {
	var p = new(AnnotationConstantRestContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_annotationConstantRest
	return p
}

func (*AnnotationConstantRestContext) IsAnnotationConstantRestContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_annotationConstantRest

	return p
}

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

func (s *AnnotationConstantRestContext) VariableDeclarators() IVariableDeclaratorsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorsContext)
}

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

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

func (s *AnnotationConstantRestContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterAnnotationConstantRest(s)
	}
}

func (s *AnnotationConstantRestContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitAnnotationConstantRest(s)
	}
}

func (p *JavaParser) AnnotationConstantRest() (localctx IAnnotationConstantRestContext) {
	localctx = NewAnnotationConstantRestContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 122, JavaParserRULE_annotationConstantRest)

	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.VariableDeclarators()
	}

	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 = JavaParserRULE_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 = JavaParserRULE_defaultValue

	return p
}

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

func (s *DefaultValueContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(JavaParserDEFAULT, 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.(JavaParserListener); ok {
		listenerT.EnterDefaultValue(s)
	}
}

func (s *DefaultValueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitDefaultValue(s)
	}
}

func (p *JavaParser) DefaultValue() (localctx IDefaultValueContext) {
	localctx = NewDefaultValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 124, JavaParserRULE_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(786)
		p.Match(JavaParserDEFAULT)
	}
	{
		p.SetState(787)
		p.ElementValue()
	}

	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 = JavaParserRULE_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 = JavaParserRULE_block

	return p
}

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

func (s *BlockContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserLBRACE, 0)
}

func (s *BlockContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserRBRACE, 0)
}

func (s *BlockContext) 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 *BlockContext) BlockStatement(i int) IBlockStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IBlockStatementContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterBlock(s)
	}
}

func (s *BlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitBlock(s)
	}
}

func (p *JavaParser) Block() (localctx IBlockContext) {
	localctx = NewBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 126, JavaParserRULE_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(789)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(793)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserABSTRACT)|(1<<JavaParserASSERT)|(1<<JavaParserBOOLEAN)|(1<<JavaParserBREAK)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserCLASS)|(1<<JavaParserCONTINUE)|(1<<JavaParserDO)|(1<<JavaParserDOUBLE)|(1<<JavaParserFINAL)|(1<<JavaParserFLOAT)|(1<<JavaParserFOR)|(1<<JavaParserIF)|(1<<JavaParserINT)|(1<<JavaParserINTERFACE)|(1<<JavaParserLONG)|(1<<JavaParserNEW))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(JavaParserPRIVATE-33))|(1<<(JavaParserPROTECTED-33))|(1<<(JavaParserPUBLIC-33))|(1<<(JavaParserRETURN-33))|(1<<(JavaParserSHORT-33))|(1<<(JavaParserSTATIC-33))|(1<<(JavaParserSTRICTFP-33))|(1<<(JavaParserSUPER-33))|(1<<(JavaParserSWITCH-33))|(1<<(JavaParserSYNCHRONIZED-33))|(1<<(JavaParserTHIS-33))|(1<<(JavaParserTHROW-33))|(1<<(JavaParserTRY-33))|(1<<(JavaParserVOID-33))|(1<<(JavaParserWHILE-33))|(1<<(JavaParserDECIMAL_LITERAL-33))|(1<<(JavaParserHEX_LITERAL-33))|(1<<(JavaParserOCT_LITERAL-33))|(1<<(JavaParserBINARY_LITERAL-33))|(1<<(JavaParserFLOAT_LITERAL-33))|(1<<(JavaParserHEX_FLOAT_LITERAL-33))|(1<<(JavaParserBOOL_LITERAL-33))|(1<<(JavaParserCHAR_LITERAL-33))|(1<<(JavaParserSTRING_LITERAL-33))|(1<<(JavaParserNULL_LITERAL-33))|(1<<(JavaParserLPAREN-33))|(1<<(JavaParserLBRACE-33)))) != 0) || (((_la-67)&-(0x1f+1)) == 0 && ((1<<uint((_la-67)))&((1<<(JavaParserSEMI-67))|(1<<(JavaParserLT-67))|(1<<(JavaParserBANG-67))|(1<<(JavaParserTILDE-67))|(1<<(JavaParserINC-67))|(1<<(JavaParserDEC-67))|(1<<(JavaParserADD-67))|(1<<(JavaParserSUB-67)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(790)
			p.BlockStatement()
		}

		p.SetState(795)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(796)
		p.Match(JavaParserRBRACE)
	}

	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 = JavaParserRULE_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 = JavaParserRULE_blockStatement

	return p
}

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

func (s *BlockStatementContext) LocalVariableDeclaration() ILocalVariableDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILocalVariableDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILocalVariableDeclarationContext)
}

func (s *BlockStatementContext) SEMI() antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, 0)
}

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) LocalTypeDeclaration() ILocalTypeDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILocalTypeDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILocalTypeDeclarationContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterBlockStatement(s)
	}
}

func (s *BlockStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitBlockStatement(s)
	}
}

func (p *JavaParser) BlockStatement() (localctx IBlockStatementContext) {
	localctx = NewBlockStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 128, JavaParserRULE_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(803)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 91, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(798)
			p.LocalVariableDeclaration()
		}
		{
			p.SetState(799)
			p.Match(JavaParserSEMI)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(801)
			p.Statement()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(802)
			p.LocalTypeDeclaration()
		}

	}

	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 = JavaParserRULE_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 = JavaParserRULE_localVariableDeclaration

	return p
}

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

func (s *LocalVariableDeclarationContext) TypeType() ITypeTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *LocalVariableDeclarationContext) VariableDeclarators() IVariableDeclaratorsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorsContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterLocalVariableDeclaration(s)
	}
}

func (s *LocalVariableDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitLocalVariableDeclaration(s)
	}
}

func (p *JavaParser) LocalVariableDeclaration() (localctx ILocalVariableDeclarationContext) {
	localctx = NewLocalVariableDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 130, JavaParserRULE_localVariableDeclaration)

	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(808)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 92, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(805)
				p.VariableModifier()
			}

		}
		p.SetState(810)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 92, p.GetParserRuleContext())
	}
	{
		p.SetState(811)
		p.TypeType()
	}
	{
		p.SetState(812)
		p.VariableDeclarators()
	}

	return localctx
}

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

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

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

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

func NewEmptyLocalTypeDeclarationContext() *LocalTypeDeclarationContext {
	var p = new(LocalTypeDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_localTypeDeclaration
	return p
}

func (*LocalTypeDeclarationContext) IsLocalTypeDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_localTypeDeclaration

	return p
}

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

func (s *LocalTypeDeclarationContext) ClassDeclaration() IClassDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassDeclarationContext)
}

func (s *LocalTypeDeclarationContext) InterfaceDeclaration() IInterfaceDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceDeclarationContext)
}

func (s *LocalTypeDeclarationContext) AllClassOrInterfaceModifier() []IClassOrInterfaceModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IClassOrInterfaceModifierContext)(nil)).Elem())
	var tst = make([]IClassOrInterfaceModifierContext, len(ts))

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

	return tst
}

func (s *LocalTypeDeclarationContext) ClassOrInterfaceModifier(i int) IClassOrInterfaceModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassOrInterfaceModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IClassOrInterfaceModifierContext)
}

func (s *LocalTypeDeclarationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, 0)
}

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

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

func (s *LocalTypeDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterLocalTypeDeclaration(s)
	}
}

func (s *LocalTypeDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitLocalTypeDeclaration(s)
	}
}

func (p *JavaParser) LocalTypeDeclaration() (localctx ILocalTypeDeclarationContext) {
	localctx = NewLocalTypeDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 132, JavaParserRULE_localTypeDeclaration)
	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(825)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserABSTRACT, JavaParserCLASS, JavaParserFINAL, JavaParserINTERFACE, JavaParserPRIVATE, JavaParserPROTECTED, JavaParserPUBLIC, JavaParserSTATIC, JavaParserSTRICTFP, JavaParserAT:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(817)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == JavaParserABSTRACT || _la == JavaParserFINAL || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(JavaParserPRIVATE-33))|(1<<(JavaParserPROTECTED-33))|(1<<(JavaParserPUBLIC-33))|(1<<(JavaParserSTATIC-33))|(1<<(JavaParserSTRICTFP-33)))) != 0) || _la == JavaParserAT {
			{
				p.SetState(814)
				p.ClassOrInterfaceModifier()
			}

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

		switch p.GetTokenStream().LA(1) {
		case JavaParserCLASS:
			{
				p.SetState(820)
				p.ClassDeclaration()
			}

		case JavaParserINTERFACE:
			{
				p.SetState(821)
				p.InterfaceDeclaration()
			}

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

	case JavaParserSEMI:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(824)
			p.Match(JavaParserSEMI)
		}

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

	return localctx
}

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

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

	// GetIdentifierLabel returns the identifierLabel token.
	GetIdentifierLabel() antlr.Token

	// SetIdentifierLabel sets the identifierLabel token.
	SetIdentifierLabel(antlr.Token)

	// GetBlockLabel returns the blockLabel rule contexts.
	GetBlockLabel() IBlockContext

	// GetStatementExpression returns the statementExpression rule contexts.
	GetStatementExpression() IExpressionContext

	// SetBlockLabel sets the blockLabel rule contexts.
	SetBlockLabel(IBlockContext)

	// SetStatementExpression sets the statementExpression rule contexts.
	SetStatementExpression(IExpressionContext)

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

type StatementContext struct {
	*antlr.BaseParserRuleContext
	parser              antlr.Parser
	blockLabel          IBlockContext
	statementExpression IExpressionContext
	identifierLabel     antlr.Token
}

func NewEmptyStatementContext() *StatementContext {
	var p = new(StatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_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 = JavaParserRULE_statement

	return p
}

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

func (s *StatementContext) GetIdentifierLabel() antlr.Token { return s.identifierLabel }

func (s *StatementContext) SetIdentifierLabel(v antlr.Token) { s.identifierLabel = v }

func (s *StatementContext) GetBlockLabel() IBlockContext { return s.blockLabel }

func (s *StatementContext) GetStatementExpression() IExpressionContext { return s.statementExpression }

func (s *StatementContext) SetBlockLabel(v IBlockContext) { s.blockLabel = v }

func (s *StatementContext) SetStatementExpression(v IExpressionContext) { s.statementExpression = v }

func (s *StatementContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *StatementContext) ASSERT() antlr.TerminalNode {
	return s.GetToken(JavaParserASSERT, 0)
}

func (s *StatementContext) 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 *StatementContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *StatementContext) SEMI() antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, 0)
}

func (s *StatementContext) COLON() antlr.TerminalNode {
	return s.GetToken(JavaParserCOLON, 0)
}

func (s *StatementContext) IF() antlr.TerminalNode {
	return s.GetToken(JavaParserIF, 0)
}

func (s *StatementContext) ParExpression() IParExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParExpressionContext)
}

func (s *StatementContext) AllStatement() []IStatementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IStatementContext)(nil)).Elem())
	var tst = make([]IStatementContext, len(ts))

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

	return tst
}

func (s *StatementContext) Statement(i int) IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *StatementContext) ELSE() antlr.TerminalNode {
	return s.GetToken(JavaParserELSE, 0)
}

func (s *StatementContext) FOR() antlr.TerminalNode {
	return s.GetToken(JavaParserFOR, 0)
}

func (s *StatementContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserLPAREN, 0)
}

func (s *StatementContext) ForControl() IForControlContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForControlContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForControlContext)
}

func (s *StatementContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserRPAREN, 0)
}

func (s *StatementContext) WHILE() antlr.TerminalNode {
	return s.GetToken(JavaParserWHILE, 0)
}

func (s *StatementContext) DO() antlr.TerminalNode {
	return s.GetToken(JavaParserDO, 0)
}

func (s *StatementContext) TRY() antlr.TerminalNode {
	return s.GetToken(JavaParserTRY, 0)
}

func (s *StatementContext) FinallyBlock() IFinallyBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFinallyBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFinallyBlockContext)
}

func (s *StatementContext) 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 *StatementContext) CatchClause(i int) ICatchClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICatchClauseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICatchClauseContext)
}

func (s *StatementContext) ResourceSpecification() IResourceSpecificationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResourceSpecificationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IResourceSpecificationContext)
}

func (s *StatementContext) SWITCH() antlr.TerminalNode {
	return s.GetToken(JavaParserSWITCH, 0)
}

func (s *StatementContext) LBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserLBRACE, 0)
}

func (s *StatementContext) RBRACE() antlr.TerminalNode {
	return s.GetToken(JavaParserRBRACE, 0)
}

func (s *StatementContext) 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 *StatementContext) SwitchBlockStatementGroup(i int) ISwitchBlockStatementGroupContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISwitchBlockStatementGroupContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISwitchBlockStatementGroupContext)
}

func (s *StatementContext) 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 *StatementContext) SwitchLabel(i int) ISwitchLabelContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISwitchLabelContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISwitchLabelContext)
}

func (s *StatementContext) SYNCHRONIZED() antlr.TerminalNode {
	return s.GetToken(JavaParserSYNCHRONIZED, 0)
}

func (s *StatementContext) RETURN() antlr.TerminalNode {
	return s.GetToken(JavaParserRETURN, 0)
}

func (s *StatementContext) THROW() antlr.TerminalNode {
	return s.GetToken(JavaParserTHROW, 0)
}

func (s *StatementContext) BREAK() antlr.TerminalNode {
	return s.GetToken(JavaParserBREAK, 0)
}

func (s *StatementContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *StatementContext) CONTINUE() antlr.TerminalNode {
	return s.GetToken(JavaParserCONTINUE, 0)
}

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.(JavaParserListener); ok {
		listenerT.EnterStatement(s)
	}
}

func (s *StatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitStatement(s)
	}
}

func (p *JavaParser) Statement() (localctx IStatementContext) {
	localctx = NewStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 134, JavaParserRULE_statement)
	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.SetState(931)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 108, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(827)

			var _x = p.Block()

			localctx.(*StatementContext).blockLabel = _x
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(828)
			p.Match(JavaParserASSERT)
		}
		{
			p.SetState(829)
			p.expression(0)
		}
		p.SetState(832)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserCOLON {
			{
				p.SetState(830)
				p.Match(JavaParserCOLON)
			}
			{
				p.SetState(831)
				p.expression(0)
			}

		}
		{
			p.SetState(834)
			p.Match(JavaParserSEMI)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(836)
			p.Match(JavaParserIF)
		}
		{
			p.SetState(837)
			p.ParExpression()
		}
		{
			p.SetState(838)
			p.Statement()
		}
		p.SetState(841)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 97, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(839)
				p.Match(JavaParserELSE)
			}
			{
				p.SetState(840)
				p.Statement()
			}

		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(843)
			p.Match(JavaParserFOR)
		}
		{
			p.SetState(844)
			p.Match(JavaParserLPAREN)
		}
		{
			p.SetState(845)
			p.ForControl()
		}
		{
			p.SetState(846)
			p.Match(JavaParserRPAREN)
		}
		{
			p.SetState(847)
			p.Statement()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(849)
			p.Match(JavaParserWHILE)
		}
		{
			p.SetState(850)
			p.ParExpression()
		}
		{
			p.SetState(851)
			p.Statement()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(853)
			p.Match(JavaParserDO)
		}
		{
			p.SetState(854)
			p.Statement()
		}
		{
			p.SetState(855)
			p.Match(JavaParserWHILE)
		}
		{
			p.SetState(856)
			p.ParExpression()
		}
		{
			p.SetState(857)
			p.Match(JavaParserSEMI)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(859)
			p.Match(JavaParserTRY)
		}
		{
			p.SetState(860)
			p.Block()
		}
		p.SetState(870)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case JavaParserCATCH:
			p.SetState(862)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for ok := true; ok; ok = _la == JavaParserCATCH {
				{
					p.SetState(861)
					p.CatchClause()
				}

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

			if _la == JavaParserFINALLY {
				{
					p.SetState(866)
					p.FinallyBlock()
				}

			}

		case JavaParserFINALLY:
			{
				p.SetState(869)
				p.FinallyBlock()
			}

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

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(872)
			p.Match(JavaParserTRY)
		}
		{
			p.SetState(873)
			p.ResourceSpecification()
		}
		{
			p.SetState(874)
			p.Block()
		}
		p.SetState(878)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == JavaParserCATCH {
			{
				p.SetState(875)
				p.CatchClause()
			}

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

		if _la == JavaParserFINALLY {
			{
				p.SetState(881)
				p.FinallyBlock()
			}

		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(884)
			p.Match(JavaParserSWITCH)
		}
		{
			p.SetState(885)
			p.ParExpression()
		}
		{
			p.SetState(886)
			p.Match(JavaParserLBRACE)
		}
		p.SetState(890)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 103, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(887)
					p.SwitchBlockStatementGroup()
				}

			}
			p.SetState(892)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 103, p.GetParserRuleContext())
		}
		p.SetState(896)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == JavaParserCASE || _la == JavaParserDEFAULT {
			{
				p.SetState(893)
				p.SwitchLabel()
			}

			p.SetState(898)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(899)
			p.Match(JavaParserRBRACE)
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(901)
			p.Match(JavaParserSYNCHRONIZED)
		}
		{
			p.SetState(902)
			p.ParExpression()
		}
		{
			p.SetState(903)
			p.Block()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(905)
			p.Match(JavaParserRETURN)
		}
		p.SetState(907)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserDOUBLE)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserLONG)|(1<<JavaParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(JavaParserSHORT-37))|(1<<(JavaParserSUPER-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37))|(1<<(JavaParserOCT_LITERAL-37))|(1<<(JavaParserBINARY_LITERAL-37))|(1<<(JavaParserFLOAT_LITERAL-37))|(1<<(JavaParserHEX_FLOAT_LITERAL-37))|(1<<(JavaParserBOOL_LITERAL-37))|(1<<(JavaParserCHAR_LITERAL-37))|(1<<(JavaParserSTRING_LITERAL-37))|(1<<(JavaParserNULL_LITERAL-37))|(1<<(JavaParserLPAREN-37)))) != 0) || (((_la-72)&-(0x1f+1)) == 0 && ((1<<uint((_la-72)))&((1<<(JavaParserLT-72))|(1<<(JavaParserBANG-72))|(1<<(JavaParserTILDE-72))|(1<<(JavaParserINC-72))|(1<<(JavaParserDEC-72))|(1<<(JavaParserADD-72))|(1<<(JavaParserSUB-72)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
			{
				p.SetState(906)
				p.expression(0)
			}

		}
		{
			p.SetState(909)
			p.Match(JavaParserSEMI)
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(910)
			p.Match(JavaParserTHROW)
		}
		{
			p.SetState(911)
			p.expression(0)
		}
		{
			p.SetState(912)
			p.Match(JavaParserSEMI)
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(914)
			p.Match(JavaParserBREAK)
		}
		p.SetState(916)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserIDENTIFIER {
			{
				p.SetState(915)
				p.Match(JavaParserIDENTIFIER)
			}

		}
		{
			p.SetState(918)
			p.Match(JavaParserSEMI)
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(919)
			p.Match(JavaParserCONTINUE)
		}
		p.SetState(921)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserIDENTIFIER {
			{
				p.SetState(920)
				p.Match(JavaParserIDENTIFIER)
			}

		}
		{
			p.SetState(923)
			p.Match(JavaParserSEMI)
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(924)
			p.Match(JavaParserSEMI)
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(925)

			var _x = p.expression(0)

			localctx.(*StatementContext).statementExpression = _x
		}
		{
			p.SetState(926)
			p.Match(JavaParserSEMI)
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(928)

			var _m = p.Match(JavaParserIDENTIFIER)

			localctx.(*StatementContext).identifierLabel = _m
		}
		{
			p.SetState(929)
			p.Match(JavaParserCOLON)
		}
		{
			p.SetState(930)
			p.Statement()
		}

	}

	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 = JavaParserRULE_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 = JavaParserRULE_catchClause

	return p
}

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

func (s *CatchClauseContext) CATCH() antlr.TerminalNode {
	return s.GetToken(JavaParserCATCH, 0)
}

func (s *CatchClauseContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserLPAREN, 0)
}

func (s *CatchClauseContext) CatchType() ICatchTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICatchTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICatchTypeContext)
}

func (s *CatchClauseContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *CatchClauseContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserRPAREN, 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) 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 *CatchClauseContext) VariableModifier(i int) IVariableModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableModifierContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterCatchClause(s)
	}
}

func (s *CatchClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitCatchClause(s)
	}
}

func (p *JavaParser) CatchClause() (localctx ICatchClauseContext) {
	localctx = NewCatchClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 136, JavaParserRULE_catchClause)
	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(933)
		p.Match(JavaParserCATCH)
	}
	{
		p.SetState(934)
		p.Match(JavaParserLPAREN)
	}
	p.SetState(938)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserFINAL || _la == JavaParserAT {
		{
			p.SetState(935)
			p.VariableModifier()
		}

		p.SetState(940)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(941)
		p.CatchType()
	}
	{
		p.SetState(942)
		p.Match(JavaParserIDENTIFIER)
	}
	{
		p.SetState(943)
		p.Match(JavaParserRPAREN)
	}
	{
		p.SetState(944)
		p.Block()
	}

	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 = JavaParserRULE_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 = JavaParserRULE_catchType

	return p
}

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

func (s *CatchTypeContext) AllQualifiedName() []IQualifiedNameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IQualifiedNameContext)(nil)).Elem())
	var tst = make([]IQualifiedNameContext, len(ts))

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

	return tst
}

func (s *CatchTypeContext) QualifiedName(i int) IQualifiedNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IQualifiedNameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IQualifiedNameContext)
}

func (s *CatchTypeContext) AllBITOR() []antlr.TerminalNode {
	return s.GetTokens(JavaParserBITOR)
}

func (s *CatchTypeContext) BITOR(i int) antlr.TerminalNode {
	return s.GetToken(JavaParserBITOR, i)
}

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.(JavaParserListener); ok {
		listenerT.EnterCatchType(s)
	}
}

func (s *CatchTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitCatchType(s)
	}
}

func (p *JavaParser) CatchType() (localctx ICatchTypeContext) {
	localctx = NewCatchTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 138, JavaParserRULE_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(946)
		p.QualifiedName()
	}
	p.SetState(951)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserBITOR {
		{
			p.SetState(947)
			p.Match(JavaParserBITOR)
		}
		{
			p.SetState(948)
			p.QualifiedName()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyFinallyBlockContext() *FinallyBlockContext {
	var p = new(FinallyBlockContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_finallyBlock
	return p
}

func (*FinallyBlockContext) IsFinallyBlockContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_finallyBlock

	return p
}

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

func (s *FinallyBlockContext) FINALLY() antlr.TerminalNode {
	return s.GetToken(JavaParserFINALLY, 0)
}

func (s *FinallyBlockContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

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

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

func (s *FinallyBlockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterFinallyBlock(s)
	}
}

func (s *FinallyBlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitFinallyBlock(s)
	}
}

func (p *JavaParser) FinallyBlock() (localctx IFinallyBlockContext) {
	localctx = NewFinallyBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 140, JavaParserRULE_finallyBlock)

	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(954)
		p.Match(JavaParserFINALLY)
	}
	{
		p.SetState(955)
		p.Block()
	}

	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 = JavaParserRULE_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 = JavaParserRULE_resourceSpecification

	return p
}

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

func (s *ResourceSpecificationContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserLPAREN, 0)
}

func (s *ResourceSpecificationContext) Resources() IResourcesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResourcesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IResourcesContext)
}

func (s *ResourceSpecificationContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserRPAREN, 0)
}

func (s *ResourceSpecificationContext) SEMI() antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, 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.(JavaParserListener); ok {
		listenerT.EnterResourceSpecification(s)
	}
}

func (s *ResourceSpecificationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitResourceSpecification(s)
	}
}

func (p *JavaParser) ResourceSpecification() (localctx IResourceSpecificationContext) {
	localctx = NewResourceSpecificationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 142, JavaParserRULE_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(957)
		p.Match(JavaParserLPAREN)
	}
	{
		p.SetState(958)
		p.Resources()
	}
	p.SetState(960)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserSEMI {
		{
			p.SetState(959)
			p.Match(JavaParserSEMI)
		}

	}
	{
		p.SetState(962)
		p.Match(JavaParserRPAREN)
	}

	return localctx
}

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

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

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

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

func NewEmptyResourcesContext() *ResourcesContext {
	var p = new(ResourcesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_resources
	return p
}

func (*ResourcesContext) IsResourcesContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_resources

	return p
}

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

func (s *ResourcesContext) 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 *ResourcesContext) Resource(i int) IResourceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResourceContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IResourceContext)
}

func (s *ResourcesContext) AllSEMI() []antlr.TerminalNode {
	return s.GetTokens(JavaParserSEMI)
}

func (s *ResourcesContext) SEMI(i int) antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, i)
}

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

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

func (s *ResourcesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterResources(s)
	}
}

func (s *ResourcesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitResources(s)
	}
}

func (p *JavaParser) Resources() (localctx IResourcesContext) {
	localctx = NewResourcesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 144, JavaParserRULE_resources)

	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(964)
		p.Resource()
	}
	p.SetState(969)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 112, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(965)
				p.Match(JavaParserSEMI)
			}
			{
				p.SetState(966)
				p.Resource()
			}

		}
		p.SetState(971)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 112, 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 = JavaParserRULE_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 = JavaParserRULE_resource

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IClassOrInterfaceTypeContext)
}

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(JavaParserASSIGN, 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.(JavaParserListener); ok {
		listenerT.EnterResource(s)
	}
}

func (s *ResourceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitResource(s)
	}
}

func (p *JavaParser) Resource() (localctx IResourceContext) {
	localctx = NewResourceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 146, JavaParserRULE_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(975)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserFINAL || _la == JavaParserAT {
		{
			p.SetState(972)
			p.VariableModifier()
		}

		p.SetState(977)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(978)
		p.ClassOrInterfaceType()
	}
	{
		p.SetState(979)
		p.VariableDeclaratorId()
	}
	{
		p.SetState(980)
		p.Match(JavaParserASSIGN)
	}
	{
		p.SetState(981)
		p.expression(0)
	}

	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 = JavaParserRULE_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 = JavaParserRULE_switchBlockStatementGroup

	return p
}

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

func (s *SwitchBlockStatementGroupContext) 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 *SwitchBlockStatementGroupContext) SwitchLabel(i int) ISwitchLabelContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISwitchLabelContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISwitchLabelContext)
}

func (s *SwitchBlockStatementGroupContext) 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 *SwitchBlockStatementGroupContext) BlockStatement(i int) IBlockStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IBlockStatementContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterSwitchBlockStatementGroup(s)
	}
}

func (s *SwitchBlockStatementGroupContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitSwitchBlockStatementGroup(s)
	}
}

func (p *JavaParser) SwitchBlockStatementGroup() (localctx ISwitchBlockStatementGroupContext) {
	localctx = NewSwitchBlockStatementGroupContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 148, JavaParserRULE_switchBlockStatementGroup)
	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(984)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == JavaParserCASE || _la == JavaParserDEFAULT {
		{
			p.SetState(983)
			p.SwitchLabel()
		}

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

	for ok := true; ok; ok = (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserABSTRACT)|(1<<JavaParserASSERT)|(1<<JavaParserBOOLEAN)|(1<<JavaParserBREAK)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserCLASS)|(1<<JavaParserCONTINUE)|(1<<JavaParserDO)|(1<<JavaParserDOUBLE)|(1<<JavaParserFINAL)|(1<<JavaParserFLOAT)|(1<<JavaParserFOR)|(1<<JavaParserIF)|(1<<JavaParserINT)|(1<<JavaParserINTERFACE)|(1<<JavaParserLONG)|(1<<JavaParserNEW))) != 0) || (((_la-33)&-(0x1f+1)) == 0 && ((1<<uint((_la-33)))&((1<<(JavaParserPRIVATE-33))|(1<<(JavaParserPROTECTED-33))|(1<<(JavaParserPUBLIC-33))|(1<<(JavaParserRETURN-33))|(1<<(JavaParserSHORT-33))|(1<<(JavaParserSTATIC-33))|(1<<(JavaParserSTRICTFP-33))|(1<<(JavaParserSUPER-33))|(1<<(JavaParserSWITCH-33))|(1<<(JavaParserSYNCHRONIZED-33))|(1<<(JavaParserTHIS-33))|(1<<(JavaParserTHROW-33))|(1<<(JavaParserTRY-33))|(1<<(JavaParserVOID-33))|(1<<(JavaParserWHILE-33))|(1<<(JavaParserDECIMAL_LITERAL-33))|(1<<(JavaParserHEX_LITERAL-33))|(1<<(JavaParserOCT_LITERAL-33))|(1<<(JavaParserBINARY_LITERAL-33))|(1<<(JavaParserFLOAT_LITERAL-33))|(1<<(JavaParserHEX_FLOAT_LITERAL-33))|(1<<(JavaParserBOOL_LITERAL-33))|(1<<(JavaParserCHAR_LITERAL-33))|(1<<(JavaParserSTRING_LITERAL-33))|(1<<(JavaParserNULL_LITERAL-33))|(1<<(JavaParserLPAREN-33))|(1<<(JavaParserLBRACE-33)))) != 0) || (((_la-67)&-(0x1f+1)) == 0 && ((1<<uint((_la-67)))&((1<<(JavaParserSEMI-67))|(1<<(JavaParserLT-67))|(1<<(JavaParserBANG-67))|(1<<(JavaParserTILDE-67))|(1<<(JavaParserINC-67))|(1<<(JavaParserDEC-67))|(1<<(JavaParserADD-67))|(1<<(JavaParserSUB-67)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(988)
			p.BlockStatement()
		}

		p.SetState(991)
		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

	// GetEnumConstantName returns the enumConstantName token.
	GetEnumConstantName() antlr.Token

	// SetEnumConstantName sets the enumConstantName token.
	SetEnumConstantName(antlr.Token)

	// GetConstantExpression returns the constantExpression rule contexts.
	GetConstantExpression() IExpressionContext

	// SetConstantExpression sets the constantExpression rule contexts.
	SetConstantExpression(IExpressionContext)

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

type SwitchLabelContext struct {
	*antlr.BaseParserRuleContext
	parser             antlr.Parser
	constantExpression IExpressionContext
	enumConstantName   antlr.Token
}

func NewEmptySwitchLabelContext() *SwitchLabelContext {
	var p = new(SwitchLabelContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_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 = JavaParserRULE_switchLabel

	return p
}

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

func (s *SwitchLabelContext) GetEnumConstantName() antlr.Token { return s.enumConstantName }

func (s *SwitchLabelContext) SetEnumConstantName(v antlr.Token) { s.enumConstantName = v }

func (s *SwitchLabelContext) GetConstantExpression() IExpressionContext { return s.constantExpression }

func (s *SwitchLabelContext) SetConstantExpression(v IExpressionContext) { s.constantExpression = v }

func (s *SwitchLabelContext) CASE() antlr.TerminalNode {
	return s.GetToken(JavaParserCASE, 0)
}

func (s *SwitchLabelContext) COLON() antlr.TerminalNode {
	return s.GetToken(JavaParserCOLON, 0)
}

func (s *SwitchLabelContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *SwitchLabelContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *SwitchLabelContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(JavaParserDEFAULT, 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.(JavaParserListener); ok {
		listenerT.EnterSwitchLabel(s)
	}
}

func (s *SwitchLabelContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitSwitchLabel(s)
	}
}

func (p *JavaParser) SwitchLabel() (localctx ISwitchLabelContext) {
	localctx = NewSwitchLabelContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 150, JavaParserRULE_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(1001)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserCASE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(993)
			p.Match(JavaParserCASE)
		}
		p.SetState(996)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 116, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(994)

				var _x = p.expression(0)

				localctx.(*SwitchLabelContext).constantExpression = _x
			}

		case 2:
			{
				p.SetState(995)

				var _m = p.Match(JavaParserIDENTIFIER)

				localctx.(*SwitchLabelContext).enumConstantName = _m
			}

		}
		{
			p.SetState(998)
			p.Match(JavaParserCOLON)
		}

	case JavaParserDEFAULT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(999)
			p.Match(JavaParserDEFAULT)
		}
		{
			p.SetState(1000)
			p.Match(JavaParserCOLON)
		}

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

	return localctx
}

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

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

	// GetForUpdate returns the forUpdate rule contexts.
	GetForUpdate() IExpressionListContext

	// SetForUpdate sets the forUpdate rule contexts.
	SetForUpdate(IExpressionListContext)

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

type ForControlContext struct {
	*antlr.BaseParserRuleContext
	parser    antlr.Parser
	forUpdate IExpressionListContext
}

func NewEmptyForControlContext() *ForControlContext {
	var p = new(ForControlContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_forControl
	return p
}

func (*ForControlContext) IsForControlContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_forControl

	return p
}

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

func (s *ForControlContext) GetForUpdate() IExpressionListContext { return s.forUpdate }

func (s *ForControlContext) SetForUpdate(v IExpressionListContext) { s.forUpdate = v }

func (s *ForControlContext) EnhancedForControl() IEnhancedForControlContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnhancedForControlContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnhancedForControlContext)
}

func (s *ForControlContext) AllSEMI() []antlr.TerminalNode {
	return s.GetTokens(JavaParserSEMI)
}

func (s *ForControlContext) SEMI(i int) antlr.TerminalNode {
	return s.GetToken(JavaParserSEMI, i)
}

func (s *ForControlContext) ForInit() IForInitContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForInitContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForInitContext)
}

func (s *ForControlContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ForControlContext) ExpressionList() IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

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

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

func (s *ForControlContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterForControl(s)
	}
}

func (s *ForControlContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitForControl(s)
	}
}

func (p *JavaParser) ForControl() (localctx IForControlContext) {
	localctx = NewForControlContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 152, JavaParserRULE_forControl)
	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(1015)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 121, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1003)
			p.EnhancedForControl()
		}

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

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserDOUBLE)|(1<<JavaParserFINAL)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserLONG)|(1<<JavaParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(JavaParserSHORT-37))|(1<<(JavaParserSUPER-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37))|(1<<(JavaParserOCT_LITERAL-37))|(1<<(JavaParserBINARY_LITERAL-37))|(1<<(JavaParserFLOAT_LITERAL-37))|(1<<(JavaParserHEX_FLOAT_LITERAL-37))|(1<<(JavaParserBOOL_LITERAL-37))|(1<<(JavaParserCHAR_LITERAL-37))|(1<<(JavaParserSTRING_LITERAL-37))|(1<<(JavaParserNULL_LITERAL-37))|(1<<(JavaParserLPAREN-37)))) != 0) || (((_la-72)&-(0x1f+1)) == 0 && ((1<<uint((_la-72)))&((1<<(JavaParserLT-72))|(1<<(JavaParserBANG-72))|(1<<(JavaParserTILDE-72))|(1<<(JavaParserINC-72))|(1<<(JavaParserDEC-72))|(1<<(JavaParserADD-72))|(1<<(JavaParserSUB-72)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
			{
				p.SetState(1004)
				p.ForInit()
			}

		}
		{
			p.SetState(1007)
			p.Match(JavaParserSEMI)
		}
		p.SetState(1009)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserDOUBLE)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserLONG)|(1<<JavaParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(JavaParserSHORT-37))|(1<<(JavaParserSUPER-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37))|(1<<(JavaParserOCT_LITERAL-37))|(1<<(JavaParserBINARY_LITERAL-37))|(1<<(JavaParserFLOAT_LITERAL-37))|(1<<(JavaParserHEX_FLOAT_LITERAL-37))|(1<<(JavaParserBOOL_LITERAL-37))|(1<<(JavaParserCHAR_LITERAL-37))|(1<<(JavaParserSTRING_LITERAL-37))|(1<<(JavaParserNULL_LITERAL-37))|(1<<(JavaParserLPAREN-37)))) != 0) || (((_la-72)&-(0x1f+1)) == 0 && ((1<<uint((_la-72)))&((1<<(JavaParserLT-72))|(1<<(JavaParserBANG-72))|(1<<(JavaParserTILDE-72))|(1<<(JavaParserINC-72))|(1<<(JavaParserDEC-72))|(1<<(JavaParserADD-72))|(1<<(JavaParserSUB-72)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
			{
				p.SetState(1008)
				p.expression(0)
			}

		}
		{
			p.SetState(1011)
			p.Match(JavaParserSEMI)
		}
		p.SetState(1013)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserDOUBLE)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserLONG)|(1<<JavaParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(JavaParserSHORT-37))|(1<<(JavaParserSUPER-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37))|(1<<(JavaParserOCT_LITERAL-37))|(1<<(JavaParserBINARY_LITERAL-37))|(1<<(JavaParserFLOAT_LITERAL-37))|(1<<(JavaParserHEX_FLOAT_LITERAL-37))|(1<<(JavaParserBOOL_LITERAL-37))|(1<<(JavaParserCHAR_LITERAL-37))|(1<<(JavaParserSTRING_LITERAL-37))|(1<<(JavaParserNULL_LITERAL-37))|(1<<(JavaParserLPAREN-37)))) != 0) || (((_la-72)&-(0x1f+1)) == 0 && ((1<<uint((_la-72)))&((1<<(JavaParserLT-72))|(1<<(JavaParserBANG-72))|(1<<(JavaParserTILDE-72))|(1<<(JavaParserINC-72))|(1<<(JavaParserDEC-72))|(1<<(JavaParserADD-72))|(1<<(JavaParserSUB-72)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
			{
				p.SetState(1012)

				var _x = p.ExpressionList()

				localctx.(*ForControlContext).forUpdate = _x
			}

		}

	}

	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 = JavaParserRULE_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 = JavaParserRULE_forInit

	return p
}

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

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) ExpressionList() IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterForInit(s)
	}
}

func (s *ForInitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitForInit(s)
	}
}

func (p *JavaParser) ForInit() (localctx IForInitContext) {
	localctx = NewForInitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 154, JavaParserRULE_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(1019)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 122, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1017)
			p.LocalVariableDeclaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1018)
			p.ExpressionList()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyEnhancedForControlContext() *EnhancedForControlContext {
	var p = new(EnhancedForControlContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_enhancedForControl
	return p
}

func (*EnhancedForControlContext) IsEnhancedForControlContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_enhancedForControl

	return p
}

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

func (s *EnhancedForControlContext) TypeType() ITypeTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *EnhancedForControlContext) VariableDeclaratorId() IVariableDeclaratorIdContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclaratorIdContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclaratorIdContext)
}

func (s *EnhancedForControlContext) COLON() antlr.TerminalNode {
	return s.GetToken(JavaParserCOLON, 0)
}

func (s *EnhancedForControlContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *EnhancedForControlContext) 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 *EnhancedForControlContext) VariableModifier(i int) IVariableModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableModifierContext)
}

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

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

func (s *EnhancedForControlContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterEnhancedForControl(s)
	}
}

func (s *EnhancedForControlContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitEnhancedForControl(s)
	}
}

func (p *JavaParser) EnhancedForControl() (localctx IEnhancedForControlContext) {
	localctx = NewEnhancedForControlContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 156, JavaParserRULE_enhancedForControl)

	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(1024)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 123, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1021)
				p.VariableModifier()
			}

		}
		p.SetState(1026)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 123, p.GetParserRuleContext())
	}
	{
		p.SetState(1027)
		p.TypeType()
	}
	{
		p.SetState(1028)
		p.VariableDeclaratorId()
	}
	{
		p.SetState(1029)
		p.Match(JavaParserCOLON)
	}
	{
		p.SetState(1030)
		p.expression(0)
	}

	return localctx
}

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

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

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

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

func NewEmptyParExpressionContext() *ParExpressionContext {
	var p = new(ParExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_parExpression
	return p
}

func (*ParExpressionContext) IsParExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_parExpression

	return p
}

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

func (s *ParExpressionContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserLPAREN, 0)
}

func (s *ParExpressionContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ParExpressionContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserRPAREN, 0)
}

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

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

func (s *ParExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterParExpression(s)
	}
}

func (s *ParExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitParExpression(s)
	}
}

func (p *JavaParser) ParExpression() (localctx IParExpressionContext) {
	localctx = NewParExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 158, JavaParserRULE_parExpression)

	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(1032)
		p.Match(JavaParserLPAREN)
	}
	{
		p.SetState(1033)
		p.expression(0)
	}
	{
		p.SetState(1034)
		p.Match(JavaParserRPAREN)
	}

	return localctx
}

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

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

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

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

func NewEmptyExpressionListContext() *ExpressionListContext {
	var p = new(ExpressionListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_expressionList
	return p
}

func (*ExpressionListContext) IsExpressionListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_expressionList

	return p
}

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

func (s *ExpressionListContext) 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 *ExpressionListContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ExpressionListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(JavaParserCOMMA)
}

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

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

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

func (s *ExpressionListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterExpressionList(s)
	}
}

func (s *ExpressionListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitExpressionList(s)
	}
}

func (p *JavaParser) ExpressionList() (localctx IExpressionListContext) {
	localctx = NewExpressionListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 160, JavaParserRULE_expressionList)
	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(1036)
		p.expression(0)
	}
	p.SetState(1041)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(1037)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(1038)
			p.expression(0)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyMethodCallContext() *MethodCallContext {
	var p = new(MethodCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_methodCall
	return p
}

func (*MethodCallContext) IsMethodCallContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_methodCall

	return p
}

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

func (s *MethodCallContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *MethodCallContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserLPAREN, 0)
}

func (s *MethodCallContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserRPAREN, 0)
}

func (s *MethodCallContext) ExpressionList() IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

func (s *MethodCallContext) THIS() antlr.TerminalNode {
	return s.GetToken(JavaParserTHIS, 0)
}

func (s *MethodCallContext) SUPER() antlr.TerminalNode {
	return s.GetToken(JavaParserSUPER, 0)
}

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

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

func (s *MethodCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterMethodCall(s)
	}
}

func (s *MethodCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitMethodCall(s)
	}
}

func (p *JavaParser) MethodCall() (localctx IMethodCallContext) {
	localctx = NewMethodCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 162, JavaParserRULE_methodCall)
	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(1062)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1044)
			p.Match(JavaParserIDENTIFIER)
		}
		{
			p.SetState(1045)
			p.Match(JavaParserLPAREN)
		}
		p.SetState(1047)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserDOUBLE)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserLONG)|(1<<JavaParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(JavaParserSHORT-37))|(1<<(JavaParserSUPER-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37))|(1<<(JavaParserOCT_LITERAL-37))|(1<<(JavaParserBINARY_LITERAL-37))|(1<<(JavaParserFLOAT_LITERAL-37))|(1<<(JavaParserHEX_FLOAT_LITERAL-37))|(1<<(JavaParserBOOL_LITERAL-37))|(1<<(JavaParserCHAR_LITERAL-37))|(1<<(JavaParserSTRING_LITERAL-37))|(1<<(JavaParserNULL_LITERAL-37))|(1<<(JavaParserLPAREN-37)))) != 0) || (((_la-72)&-(0x1f+1)) == 0 && ((1<<uint((_la-72)))&((1<<(JavaParserLT-72))|(1<<(JavaParserBANG-72))|(1<<(JavaParserTILDE-72))|(1<<(JavaParserINC-72))|(1<<(JavaParserDEC-72))|(1<<(JavaParserADD-72))|(1<<(JavaParserSUB-72)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
			{
				p.SetState(1046)
				p.ExpressionList()
			}

		}
		{
			p.SetState(1049)
			p.Match(JavaParserRPAREN)
		}

	case JavaParserTHIS:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1050)
			p.Match(JavaParserTHIS)
		}
		{
			p.SetState(1051)
			p.Match(JavaParserLPAREN)
		}
		p.SetState(1053)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserDOUBLE)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserLONG)|(1<<JavaParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(JavaParserSHORT-37))|(1<<(JavaParserSUPER-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37))|(1<<(JavaParserOCT_LITERAL-37))|(1<<(JavaParserBINARY_LITERAL-37))|(1<<(JavaParserFLOAT_LITERAL-37))|(1<<(JavaParserHEX_FLOAT_LITERAL-37))|(1<<(JavaParserBOOL_LITERAL-37))|(1<<(JavaParserCHAR_LITERAL-37))|(1<<(JavaParserSTRING_LITERAL-37))|(1<<(JavaParserNULL_LITERAL-37))|(1<<(JavaParserLPAREN-37)))) != 0) || (((_la-72)&-(0x1f+1)) == 0 && ((1<<uint((_la-72)))&((1<<(JavaParserLT-72))|(1<<(JavaParserBANG-72))|(1<<(JavaParserTILDE-72))|(1<<(JavaParserINC-72))|(1<<(JavaParserDEC-72))|(1<<(JavaParserADD-72))|(1<<(JavaParserSUB-72)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
			{
				p.SetState(1052)
				p.ExpressionList()
			}

		}
		{
			p.SetState(1055)
			p.Match(JavaParserRPAREN)
		}

	case JavaParserSUPER:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1056)
			p.Match(JavaParserSUPER)
		}
		{
			p.SetState(1057)
			p.Match(JavaParserLPAREN)
		}
		p.SetState(1059)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserDOUBLE)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserLONG)|(1<<JavaParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(JavaParserSHORT-37))|(1<<(JavaParserSUPER-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37))|(1<<(JavaParserOCT_LITERAL-37))|(1<<(JavaParserBINARY_LITERAL-37))|(1<<(JavaParserFLOAT_LITERAL-37))|(1<<(JavaParserHEX_FLOAT_LITERAL-37))|(1<<(JavaParserBOOL_LITERAL-37))|(1<<(JavaParserCHAR_LITERAL-37))|(1<<(JavaParserSTRING_LITERAL-37))|(1<<(JavaParserNULL_LITERAL-37))|(1<<(JavaParserLPAREN-37)))) != 0) || (((_la-72)&-(0x1f+1)) == 0 && ((1<<uint((_la-72)))&((1<<(JavaParserLT-72))|(1<<(JavaParserBANG-72))|(1<<(JavaParserTILDE-72))|(1<<(JavaParserINC-72))|(1<<(JavaParserDEC-72))|(1<<(JavaParserADD-72))|(1<<(JavaParserSUB-72)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
			{
				p.SetState(1058)
				p.ExpressionList()
			}

		}
		{
			p.SetState(1061)
			p.Match(JavaParserRPAREN)
		}

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

	return localctx
}

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

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

	// GetPrefix returns the prefix token.
	GetPrefix() antlr.Token

	// GetBop returns the bop token.
	GetBop() antlr.Token

	// GetPostfix returns the postfix token.
	GetPostfix() antlr.Token

	// SetPrefix sets the prefix token.
	SetPrefix(antlr.Token)

	// SetBop sets the bop token.
	SetBop(antlr.Token)

	// SetPostfix sets the postfix token.
	SetPostfix(antlr.Token)

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

type ExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser  antlr.Parser
	prefix  antlr.Token
	bop     antlr.Token
	postfix antlr.Token
}

func NewEmptyExpressionContext() *ExpressionContext {
	var p = new(ExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_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 = JavaParserRULE_expression

	return p
}

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

func (s *ExpressionContext) GetPrefix() antlr.Token { return s.prefix }

func (s *ExpressionContext) GetBop() antlr.Token { return s.bop }

func (s *ExpressionContext) GetPostfix() antlr.Token { return s.postfix }

func (s *ExpressionContext) SetPrefix(v antlr.Token) { s.prefix = v }

func (s *ExpressionContext) SetBop(v antlr.Token) { s.bop = v }

func (s *ExpressionContext) SetPostfix(v antlr.Token) { s.postfix = v }

func (s *ExpressionContext) Primary() IPrimaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryContext)
}

func (s *ExpressionContext) MethodCall() IMethodCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodCallContext)
}

func (s *ExpressionContext) NEW() antlr.TerminalNode {
	return s.GetToken(JavaParserNEW, 0)
}

func (s *ExpressionContext) Creator() ICreatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreatorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreatorContext)
}

func (s *ExpressionContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserLPAREN, 0)
}

func (s *ExpressionContext) TypeType() ITypeTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *ExpressionContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserRPAREN, 0)
}

func (s *ExpressionContext) 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 *ExpressionContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ExpressionContext) ADD() antlr.TerminalNode {
	return s.GetToken(JavaParserADD, 0)
}

func (s *ExpressionContext) SUB() antlr.TerminalNode {
	return s.GetToken(JavaParserSUB, 0)
}

func (s *ExpressionContext) INC() antlr.TerminalNode {
	return s.GetToken(JavaParserINC, 0)
}

func (s *ExpressionContext) DEC() antlr.TerminalNode {
	return s.GetToken(JavaParserDEC, 0)
}

func (s *ExpressionContext) TILDE() antlr.TerminalNode {
	return s.GetToken(JavaParserTILDE, 0)
}

func (s *ExpressionContext) BANG() antlr.TerminalNode {
	return s.GetToken(JavaParserBANG, 0)
}

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) COLONCOLON() antlr.TerminalNode {
	return s.GetToken(JavaParserCOLONCOLON, 0)
}

func (s *ExpressionContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IClassTypeContext)
}

func (s *ExpressionContext) MUL() antlr.TerminalNode {
	return s.GetToken(JavaParserMUL, 0)
}

func (s *ExpressionContext) DIV() antlr.TerminalNode {
	return s.GetToken(JavaParserDIV, 0)
}

func (s *ExpressionContext) MOD() antlr.TerminalNode {
	return s.GetToken(JavaParserMOD, 0)
}

func (s *ExpressionContext) AllLT() []antlr.TerminalNode {
	return s.GetTokens(JavaParserLT)
}

func (s *ExpressionContext) LT(i int) antlr.TerminalNode {
	return s.GetToken(JavaParserLT, i)
}

func (s *ExpressionContext) AllGT() []antlr.TerminalNode {
	return s.GetTokens(JavaParserGT)
}

func (s *ExpressionContext) GT(i int) antlr.TerminalNode {
	return s.GetToken(JavaParserGT, i)
}

func (s *ExpressionContext) LE() antlr.TerminalNode {
	return s.GetToken(JavaParserLE, 0)
}

func (s *ExpressionContext) GE() antlr.TerminalNode {
	return s.GetToken(JavaParserGE, 0)
}

func (s *ExpressionContext) EQUAL() antlr.TerminalNode {
	return s.GetToken(JavaParserEQUAL, 0)
}

func (s *ExpressionContext) NOTEQUAL() antlr.TerminalNode {
	return s.GetToken(JavaParserNOTEQUAL, 0)
}

func (s *ExpressionContext) BITAND() antlr.TerminalNode {
	return s.GetToken(JavaParserBITAND, 0)
}

func (s *ExpressionContext) CARET() antlr.TerminalNode {
	return s.GetToken(JavaParserCARET, 0)
}

func (s *ExpressionContext) BITOR() antlr.TerminalNode {
	return s.GetToken(JavaParserBITOR, 0)
}

func (s *ExpressionContext) AND() antlr.TerminalNode {
	return s.GetToken(JavaParserAND, 0)
}

func (s *ExpressionContext) OR() antlr.TerminalNode {
	return s.GetToken(JavaParserOR, 0)
}

func (s *ExpressionContext) COLON() antlr.TerminalNode {
	return s.GetToken(JavaParserCOLON, 0)
}

func (s *ExpressionContext) QUESTION() antlr.TerminalNode {
	return s.GetToken(JavaParserQUESTION, 0)
}

func (s *ExpressionContext) ASSIGN() antlr.TerminalNode {
	return s.GetToken(JavaParserASSIGN, 0)
}

func (s *ExpressionContext) ADD_ASSIGN() antlr.TerminalNode {
	return s.GetToken(JavaParserADD_ASSIGN, 0)
}

func (s *ExpressionContext) SUB_ASSIGN() antlr.TerminalNode {
	return s.GetToken(JavaParserSUB_ASSIGN, 0)
}

func (s *ExpressionContext) MUL_ASSIGN() antlr.TerminalNode {
	return s.GetToken(JavaParserMUL_ASSIGN, 0)
}

func (s *ExpressionContext) DIV_ASSIGN() antlr.TerminalNode {
	return s.GetToken(JavaParserDIV_ASSIGN, 0)
}

func (s *ExpressionContext) AND_ASSIGN() antlr.TerminalNode {
	return s.GetToken(JavaParserAND_ASSIGN, 0)
}

func (s *ExpressionContext) OR_ASSIGN() antlr.TerminalNode {
	return s.GetToken(JavaParserOR_ASSIGN, 0)
}

func (s *ExpressionContext) XOR_ASSIGN() antlr.TerminalNode {
	return s.GetToken(JavaParserXOR_ASSIGN, 0)
}

func (s *ExpressionContext) RSHIFT_ASSIGN() antlr.TerminalNode {
	return s.GetToken(JavaParserRSHIFT_ASSIGN, 0)
}

func (s *ExpressionContext) URSHIFT_ASSIGN() antlr.TerminalNode {
	return s.GetToken(JavaParserURSHIFT_ASSIGN, 0)
}

func (s *ExpressionContext) LSHIFT_ASSIGN() antlr.TerminalNode {
	return s.GetToken(JavaParserLSHIFT_ASSIGN, 0)
}

func (s *ExpressionContext) MOD_ASSIGN() antlr.TerminalNode {
	return s.GetToken(JavaParserMOD_ASSIGN, 0)
}

func (s *ExpressionContext) DOT() antlr.TerminalNode {
	return s.GetToken(JavaParserDOT, 0)
}

func (s *ExpressionContext) THIS() antlr.TerminalNode {
	return s.GetToken(JavaParserTHIS, 0)
}

func (s *ExpressionContext) InnerCreator() IInnerCreatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInnerCreatorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInnerCreatorContext)
}

func (s *ExpressionContext) SUPER() antlr.TerminalNode {
	return s.GetToken(JavaParserSUPER, 0)
}

func (s *ExpressionContext) SuperSuffix() ISuperSuffixContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISuperSuffixContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISuperSuffixContext)
}

func (s *ExpressionContext) ExplicitGenericInvocation() IExplicitGenericInvocationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExplicitGenericInvocationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExplicitGenericInvocationContext)
}

func (s *ExpressionContext) NonWildcardTypeArguments() INonWildcardTypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INonWildcardTypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INonWildcardTypeArgumentsContext)
}

func (s *ExpressionContext) LBRACK() antlr.TerminalNode {
	return s.GetToken(JavaParserLBRACK, 0)
}

func (s *ExpressionContext) RBRACK() antlr.TerminalNode {
	return s.GetToken(JavaParserRBRACK, 0)
}

func (s *ExpressionContext) INSTANCEOF() antlr.TerminalNode {
	return s.GetToken(JavaParserINSTANCEOF, 0)
}

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.(JavaParserListener); ok {
		listenerT.EnterExpression(s)
	}
}

func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitExpression(s)
	}
}

func (p *JavaParser) Expression() (localctx IExpressionContext) {
	return p.expression(0)
}

func (p *JavaParser) expression(_p int) (localctx IExpressionContext) {
	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewExpressionContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IExpressionContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 164
	p.EnterRecursionRule(localctx, 164, JavaParserRULE_expression, _p)
	var _la int

	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(1095)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 132, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1065)
			p.Primary()
		}

	case 2:
		{
			p.SetState(1066)
			p.MethodCall()
		}

	case 3:
		{
			p.SetState(1067)
			p.Match(JavaParserNEW)
		}
		{
			p.SetState(1068)
			p.Creator()
		}

	case 4:
		{
			p.SetState(1069)
			p.Match(JavaParserLPAREN)
		}
		{
			p.SetState(1070)
			p.TypeType()
		}
		{
			p.SetState(1071)
			p.Match(JavaParserRPAREN)
		}
		{
			p.SetState(1072)
			p.expression(21)
		}

	case 5:
		{
			p.SetState(1074)

			var _lt = p.GetTokenStream().LT(1)

			localctx.(*ExpressionContext).prefix = _lt

			_la = p.GetTokenStream().LA(1)

			if !(((_la-83)&-(0x1f+1)) == 0 && ((1<<uint((_la-83)))&((1<<(JavaParserINC-83))|(1<<(JavaParserDEC-83))|(1<<(JavaParserADD-83))|(1<<(JavaParserSUB-83)))) != 0) {
				var _ri = p.GetErrorHandler().RecoverInline(p)

				localctx.(*ExpressionContext).prefix = _ri
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1075)
			p.expression(19)
		}

	case 6:
		{
			p.SetState(1076)

			var _lt = p.GetTokenStream().LT(1)

			localctx.(*ExpressionContext).prefix = _lt

			_la = p.GetTokenStream().LA(1)

			if !(_la == JavaParserBANG || _la == JavaParserTILDE) {
				var _ri = p.GetErrorHandler().RecoverInline(p)

				localctx.(*ExpressionContext).prefix = _ri
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1077)
			p.expression(18)
		}

	case 7:
		{
			p.SetState(1078)
			p.LambdaExpression()
		}

	case 8:
		{
			p.SetState(1079)
			p.TypeType()
		}
		{
			p.SetState(1080)
			p.Match(JavaParserCOLONCOLON)
		}
		p.SetState(1086)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case JavaParserLT, JavaParserIDENTIFIER:
			p.SetState(1082)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == JavaParserLT {
				{
					p.SetState(1081)
					p.TypeArguments()
				}

			}
			{
				p.SetState(1084)
				p.Match(JavaParserIDENTIFIER)
			}

		case JavaParserNEW:
			{
				p.SetState(1085)
				p.Match(JavaParserNEW)
			}

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

	case 9:
		{
			p.SetState(1088)
			p.ClassType()
		}
		{
			p.SetState(1089)
			p.Match(JavaParserCOLONCOLON)
		}
		p.SetState(1091)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserLT {
			{
				p.SetState(1090)
				p.TypeArguments()
			}

		}
		{
			p.SetState(1093)
			p.Match(JavaParserNEW)
		}

	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(1177)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 138, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(1175)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 137, p.GetParserRuleContext()) {
			case 1:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1097)

				if !(p.Precpred(p.GetParserRuleContext(), 17)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 17)", ""))
				}
				{
					p.SetState(1098)

					var _lt = p.GetTokenStream().LT(1)

					localctx.(*ExpressionContext).bop = _lt

					_la = p.GetTokenStream().LA(1)

					if !(((_la-87)&-(0x1f+1)) == 0 && ((1<<uint((_la-87)))&((1<<(JavaParserMUL-87))|(1<<(JavaParserDIV-87))|(1<<(JavaParserMOD-87)))) != 0) {
						var _ri = p.GetErrorHandler().RecoverInline(p)

						localctx.(*ExpressionContext).bop = _ri
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1099)
					p.expression(18)
				}

			case 2:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1100)

				if !(p.Precpred(p.GetParserRuleContext(), 16)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 16)", ""))
				}
				{
					p.SetState(1101)

					var _lt = p.GetTokenStream().LT(1)

					localctx.(*ExpressionContext).bop = _lt

					_la = p.GetTokenStream().LA(1)

					if !(_la == JavaParserADD || _la == JavaParserSUB) {
						var _ri = p.GetErrorHandler().RecoverInline(p)

						localctx.(*ExpressionContext).bop = _ri
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1102)
					p.expression(17)
				}

			case 3:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1103)

				if !(p.Precpred(p.GetParserRuleContext(), 15)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 15)", ""))
				}
				p.SetState(1111)
				p.GetErrorHandler().Sync(p)
				switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 133, p.GetParserRuleContext()) {
				case 1:
					{
						p.SetState(1104)
						p.Match(JavaParserLT)
					}
					{
						p.SetState(1105)
						p.Match(JavaParserLT)
					}

				case 2:
					{
						p.SetState(1106)
						p.Match(JavaParserGT)
					}
					{
						p.SetState(1107)
						p.Match(JavaParserGT)
					}
					{
						p.SetState(1108)
						p.Match(JavaParserGT)
					}

				case 3:
					{
						p.SetState(1109)
						p.Match(JavaParserGT)
					}
					{
						p.SetState(1110)
						p.Match(JavaParserGT)
					}

				}
				{
					p.SetState(1113)
					p.expression(16)
				}

			case 4:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1114)

				if !(p.Precpred(p.GetParserRuleContext(), 14)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", ""))
				}
				{
					p.SetState(1115)

					var _lt = p.GetTokenStream().LT(1)

					localctx.(*ExpressionContext).bop = _lt

					_la = p.GetTokenStream().LA(1)

					if !(((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(JavaParserGT-71))|(1<<(JavaParserLT-71))|(1<<(JavaParserLE-71))|(1<<(JavaParserGE-71)))) != 0) {
						var _ri = p.GetErrorHandler().RecoverInline(p)

						localctx.(*ExpressionContext).bop = _ri
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1116)
					p.expression(15)
				}

			case 5:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1117)

				if !(p.Precpred(p.GetParserRuleContext(), 12)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 12)", ""))
				}
				{
					p.SetState(1118)

					var _lt = p.GetTokenStream().LT(1)

					localctx.(*ExpressionContext).bop = _lt

					_la = p.GetTokenStream().LA(1)

					if !(_la == JavaParserEQUAL || _la == JavaParserNOTEQUAL) {
						var _ri = p.GetErrorHandler().RecoverInline(p)

						localctx.(*ExpressionContext).bop = _ri
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1119)
					p.expression(13)
				}

			case 6:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1120)

				if !(p.Precpred(p.GetParserRuleContext(), 11)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 11)", ""))
				}
				{
					p.SetState(1121)

					var _m = p.Match(JavaParserBITAND)

					localctx.(*ExpressionContext).bop = _m
				}
				{
					p.SetState(1122)
					p.expression(12)
				}

			case 7:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1123)

				if !(p.Precpred(p.GetParserRuleContext(), 10)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", ""))
				}
				{
					p.SetState(1124)

					var _m = p.Match(JavaParserCARET)

					localctx.(*ExpressionContext).bop = _m
				}
				{
					p.SetState(1125)
					p.expression(11)
				}

			case 8:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1126)

				if !(p.Precpred(p.GetParserRuleContext(), 9)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", ""))
				}
				{
					p.SetState(1127)

					var _m = p.Match(JavaParserBITOR)

					localctx.(*ExpressionContext).bop = _m
				}
				{
					p.SetState(1128)
					p.expression(10)
				}

			case 9:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1129)

				if !(p.Precpred(p.GetParserRuleContext(), 8)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", ""))
				}
				{
					p.SetState(1130)

					var _m = p.Match(JavaParserAND)

					localctx.(*ExpressionContext).bop = _m
				}
				{
					p.SetState(1131)
					p.expression(9)
				}

			case 10:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1132)

				if !(p.Precpred(p.GetParserRuleContext(), 7)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", ""))
				}
				{
					p.SetState(1133)

					var _m = p.Match(JavaParserOR)

					localctx.(*ExpressionContext).bop = _m
				}
				{
					p.SetState(1134)
					p.expression(8)
				}

			case 11:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1135)

				if !(p.Precpred(p.GetParserRuleContext(), 6)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", ""))
				}
				{
					p.SetState(1136)

					var _m = p.Match(JavaParserQUESTION)

					localctx.(*ExpressionContext).bop = _m
				}
				{
					p.SetState(1137)
					p.expression(0)
				}
				{
					p.SetState(1138)
					p.Match(JavaParserCOLON)
				}
				{
					p.SetState(1139)
					p.expression(6)
				}

			case 12:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1141)

				if !(p.Precpred(p.GetParserRuleContext(), 5)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
				}
				{
					p.SetState(1142)

					var _lt = p.GetTokenStream().LT(1)

					localctx.(*ExpressionContext).bop = _lt

					_la = p.GetTokenStream().LA(1)

					if !((((_la-70)&-(0x1f+1)) == 0 && ((1<<uint((_la-70)))&((1<<(JavaParserASSIGN-70))|(1<<(JavaParserADD_ASSIGN-70))|(1<<(JavaParserSUB_ASSIGN-70))|(1<<(JavaParserMUL_ASSIGN-70))|(1<<(JavaParserDIV_ASSIGN-70))|(1<<(JavaParserAND_ASSIGN-70))|(1<<(JavaParserOR_ASSIGN-70))|(1<<(JavaParserXOR_ASSIGN-70))|(1<<(JavaParserMOD_ASSIGN-70))|(1<<(JavaParserLSHIFT_ASSIGN-70)))) != 0) || _la == JavaParserRSHIFT_ASSIGN || _la == JavaParserURSHIFT_ASSIGN) {
						var _ri = p.GetErrorHandler().RecoverInline(p)

						localctx.(*ExpressionContext).bop = _ri
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1143)
					p.expression(5)
				}

			case 13:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1144)

				if !(p.Precpred(p.GetParserRuleContext(), 25)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 25)", ""))
				}
				{
					p.SetState(1145)

					var _m = p.Match(JavaParserDOT)

					localctx.(*ExpressionContext).bop = _m
				}
				p.SetState(1157)
				p.GetErrorHandler().Sync(p)
				switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 135, p.GetParserRuleContext()) {
				case 1:
					{
						p.SetState(1146)
						p.Match(JavaParserIDENTIFIER)
					}

				case 2:
					{
						p.SetState(1147)
						p.MethodCall()
					}

				case 3:
					{
						p.SetState(1148)
						p.Match(JavaParserTHIS)
					}

				case 4:
					{
						p.SetState(1149)
						p.Match(JavaParserNEW)
					}
					p.SetState(1151)
					p.GetErrorHandler().Sync(p)
					_la = p.GetTokenStream().LA(1)

					if _la == JavaParserLT {
						{
							p.SetState(1150)
							p.NonWildcardTypeArguments()
						}

					}
					{
						p.SetState(1153)
						p.InnerCreator()
					}

				case 5:
					{
						p.SetState(1154)
						p.Match(JavaParserSUPER)
					}
					{
						p.SetState(1155)
						p.SuperSuffix()
					}

				case 6:
					{
						p.SetState(1156)
						p.ExplicitGenericInvocation()
					}

				}

			case 14:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1159)

				if !(p.Precpred(p.GetParserRuleContext(), 24)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 24)", ""))
				}
				{
					p.SetState(1160)
					p.Match(JavaParserLBRACK)
				}
				{
					p.SetState(1161)
					p.expression(0)
				}
				{
					p.SetState(1162)
					p.Match(JavaParserRBRACK)
				}

			case 15:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1164)

				if !(p.Precpred(p.GetParserRuleContext(), 20)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 20)", ""))
				}
				{
					p.SetState(1165)

					var _lt = p.GetTokenStream().LT(1)

					localctx.(*ExpressionContext).postfix = _lt

					_la = p.GetTokenStream().LA(1)

					if !(_la == JavaParserINC || _la == JavaParserDEC) {
						var _ri = p.GetErrorHandler().RecoverInline(p)

						localctx.(*ExpressionContext).postfix = _ri
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}

			case 16:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1166)

				if !(p.Precpred(p.GetParserRuleContext(), 13)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 13)", ""))
				}
				{
					p.SetState(1167)

					var _m = p.Match(JavaParserINSTANCEOF)

					localctx.(*ExpressionContext).bop = _m
				}
				{
					p.SetState(1168)
					p.TypeType()
				}

			case 17:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1169)

				if !(p.Precpred(p.GetParserRuleContext(), 3)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
				}
				{
					p.SetState(1170)
					p.Match(JavaParserCOLONCOLON)
				}
				p.SetState(1172)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == JavaParserLT {
					{
						p.SetState(1171)
						p.TypeArguments()
					}

				}
				{
					p.SetState(1174)
					p.Match(JavaParserIDENTIFIER)
				}

			}

		}
		p.SetState(1179)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 138, p.GetParserRuleContext())
	}

	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 = JavaParserRULE_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 = JavaParserRULE_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(JavaParserARROW, 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.(JavaParserListener); ok {
		listenerT.EnterLambdaExpression(s)
	}
}

func (s *LambdaExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitLambdaExpression(s)
	}
}

func (p *JavaParser) LambdaExpression() (localctx ILambdaExpressionContext) {
	localctx = NewLambdaExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 166, JavaParserRULE_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(1180)
		p.LambdaParameters()
	}
	{
		p.SetState(1181)
		p.Match(JavaParserARROW)
	}
	{
		p.SetState(1182)
		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 = JavaParserRULE_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 = JavaParserRULE_lambdaParameters

	return p
}

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

func (s *LambdaParametersContext) AllIDENTIFIER() []antlr.TerminalNode {
	return s.GetTokens(JavaParserIDENTIFIER)
}

func (s *LambdaParametersContext) IDENTIFIER(i int) antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, i)
}

func (s *LambdaParametersContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserLPAREN, 0)
}

func (s *LambdaParametersContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserRPAREN, 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) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(JavaParserCOMMA)
}

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

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.(JavaParserListener); ok {
		listenerT.EnterLambdaParameters(s)
	}
}

func (s *LambdaParametersContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitLambdaParameters(s)
	}
}

func (p *JavaParser) LambdaParameters() (localctx ILambdaParametersContext) {
	localctx = NewLambdaParametersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 168, JavaParserRULE_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(1200)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 141, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1184)
			p.Match(JavaParserIDENTIFIER)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1185)
			p.Match(JavaParserLPAREN)
		}
		p.SetState(1187)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserDOUBLE)|(1<<JavaParserFINAL)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserLONG))) != 0) || _la == JavaParserSHORT || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
			{
				p.SetState(1186)
				p.FormalParameterList()
			}

		}
		{
			p.SetState(1189)
			p.Match(JavaParserRPAREN)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1190)
			p.Match(JavaParserLPAREN)
		}
		{
			p.SetState(1191)
			p.Match(JavaParserIDENTIFIER)
		}
		p.SetState(1196)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == JavaParserCOMMA {
			{
				p.SetState(1192)
				p.Match(JavaParserCOMMA)
			}
			{
				p.SetState(1193)
				p.Match(JavaParserIDENTIFIER)
			}

			p.SetState(1198)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1199)
			p.Match(JavaParserRPAREN)
		}

	}

	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 = JavaParserRULE_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 = JavaParserRULE_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.(JavaParserListener); ok {
		listenerT.EnterLambdaBody(s)
	}
}

func (s *LambdaBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitLambdaBody(s)
	}
}

func (p *JavaParser) LambdaBody() (localctx ILambdaBodyContext) {
	localctx = NewLambdaBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 170, JavaParserRULE_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(1204)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserNEW, JavaParserSHORT, JavaParserSUPER, JavaParserTHIS, JavaParserVOID, JavaParserDECIMAL_LITERAL, JavaParserHEX_LITERAL, JavaParserOCT_LITERAL, JavaParserBINARY_LITERAL, JavaParserFLOAT_LITERAL, JavaParserHEX_FLOAT_LITERAL, JavaParserBOOL_LITERAL, JavaParserCHAR_LITERAL, JavaParserSTRING_LITERAL, JavaParserNULL_LITERAL, JavaParserLPAREN, JavaParserLT, JavaParserBANG, JavaParserTILDE, JavaParserINC, JavaParserDEC, JavaParserADD, JavaParserSUB, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1202)
			p.expression(0)
		}

	case JavaParserLBRACE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1203)
			p.Block()
		}

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

	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 = JavaParserRULE_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 = JavaParserRULE_primary

	return p
}

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

func (s *PrimaryContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserLPAREN, 0)
}

func (s *PrimaryContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *PrimaryContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserRPAREN, 0)
}

func (s *PrimaryContext) THIS() antlr.TerminalNode {
	return s.GetToken(JavaParserTHIS, 0)
}

func (s *PrimaryContext) SUPER() antlr.TerminalNode {
	return s.GetToken(JavaParserSUPER, 0)
}

func (s *PrimaryContext) Literal() ILiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *PrimaryContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *PrimaryContext) TypeTypeOrVoid() ITypeTypeOrVoidContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeOrVoidContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeOrVoidContext)
}

func (s *PrimaryContext) DOT() antlr.TerminalNode {
	return s.GetToken(JavaParserDOT, 0)
}

func (s *PrimaryContext) CLASS() antlr.TerminalNode {
	return s.GetToken(JavaParserCLASS, 0)
}

func (s *PrimaryContext) NonWildcardTypeArguments() INonWildcardTypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INonWildcardTypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INonWildcardTypeArgumentsContext)
}

func (s *PrimaryContext) ExplicitGenericInvocationSuffix() IExplicitGenericInvocationSuffixContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExplicitGenericInvocationSuffixContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExplicitGenericInvocationSuffixContext)
}

func (s *PrimaryContext) Arguments() IArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentsContext)
}

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.(JavaParserListener); ok {
		listenerT.EnterPrimary(s)
	}
}

func (s *PrimaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitPrimary(s)
	}
}

func (p *JavaParser) Primary() (localctx IPrimaryContext) {
	localctx = NewPrimaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 172, JavaParserRULE_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(1224)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 144, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1206)
			p.Match(JavaParserLPAREN)
		}
		{
			p.SetState(1207)
			p.expression(0)
		}
		{
			p.SetState(1208)
			p.Match(JavaParserRPAREN)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1210)
			p.Match(JavaParserTHIS)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1211)
			p.Match(JavaParserSUPER)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1212)
			p.Literal()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1213)
			p.Match(JavaParserIDENTIFIER)
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1214)
			p.TypeTypeOrVoid()
		}
		{
			p.SetState(1215)
			p.Match(JavaParserDOT)
		}
		{
			p.SetState(1216)
			p.Match(JavaParserCLASS)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1218)
			p.NonWildcardTypeArguments()
		}
		p.SetState(1222)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case JavaParserSUPER, JavaParserIDENTIFIER:
			{
				p.SetState(1219)
				p.ExplicitGenericInvocationSuffix()
			}

		case JavaParserTHIS:
			{
				p.SetState(1220)
				p.Match(JavaParserTHIS)
			}
			{
				p.SetState(1221)
				p.Arguments()
			}

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

	}

	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 = JavaParserRULE_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 = JavaParserRULE_classType

	return p
}

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

func (s *ClassTypeContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

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(JavaParserDOT, 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) 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.(JavaParserListener); ok {
		listenerT.EnterClassType(s)
	}
}

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

func (p *JavaParser) ClassType() (localctx IClassTypeContext) {
	localctx = NewClassTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 174, JavaParserRULE_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.EnterOuterAlt(localctx, 1)
	p.SetState(1229)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 145, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1226)
			p.ClassOrInterfaceType()
		}
		{
			p.SetState(1227)
			p.Match(JavaParserDOT)
		}

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

	for _la == JavaParserAT {
		{
			p.SetState(1231)
			p.Annotation()
		}

		p.SetState(1236)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1237)
		p.Match(JavaParserIDENTIFIER)
	}
	p.SetState(1239)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserLT {
		{
			p.SetState(1238)
			p.TypeArguments()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyCreatorContext() *CreatorContext {
	var p = new(CreatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_creator
	return p
}

func (*CreatorContext) IsCreatorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_creator

	return p
}

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

func (s *CreatorContext) NonWildcardTypeArguments() INonWildcardTypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INonWildcardTypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INonWildcardTypeArgumentsContext)
}

func (s *CreatorContext) CreatedName() ICreatedNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreatedNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreatedNameContext)
}

func (s *CreatorContext) ClassCreatorRest() IClassCreatorRestContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassCreatorRestContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassCreatorRestContext)
}

func (s *CreatorContext) ArrayCreatorRest() IArrayCreatorRestContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayCreatorRestContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayCreatorRestContext)
}

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

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

func (s *CreatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterCreator(s)
	}
}

func (s *CreatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitCreator(s)
	}
}

func (p *JavaParser) Creator() (localctx ICreatorContext) {
	localctx = NewCreatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 176, JavaParserRULE_creator)

	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(1250)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserLT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1241)
			p.NonWildcardTypeArguments()
		}
		{
			p.SetState(1242)
			p.CreatedName()
		}
		{
			p.SetState(1243)
			p.ClassCreatorRest()
		}

	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserSHORT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1245)
			p.CreatedName()
		}
		p.SetState(1248)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case JavaParserLBRACK:
			{
				p.SetState(1246)
				p.ArrayCreatorRest()
			}

		case JavaParserLPAREN:
			{
				p.SetState(1247)
				p.ClassCreatorRest()
			}

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

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

	return localctx
}

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

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

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

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

func NewEmptyCreatedNameContext() *CreatedNameContext {
	var p = new(CreatedNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_createdName
	return p
}

func (*CreatedNameContext) IsCreatedNameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_createdName

	return p
}

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

func (s *CreatedNameContext) AllIDENTIFIER() []antlr.TerminalNode {
	return s.GetTokens(JavaParserIDENTIFIER)
}

func (s *CreatedNameContext) IDENTIFIER(i int) antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, i)
}

func (s *CreatedNameContext) AllTypeArgumentsOrDiamond() []ITypeArgumentsOrDiamondContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeArgumentsOrDiamondContext)(nil)).Elem())
	var tst = make([]ITypeArgumentsOrDiamondContext, len(ts))

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

	return tst
}

func (s *CreatedNameContext) TypeArgumentsOrDiamond(i int) ITypeArgumentsOrDiamondContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsOrDiamondContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsOrDiamondContext)
}

func (s *CreatedNameContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(JavaParserDOT)
}

func (s *CreatedNameContext) DOT(i int) antlr.TerminalNode {
	return s.GetToken(JavaParserDOT, i)
}

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

	if t == nil {
		return nil
	}

	return t.(IPrimitiveTypeContext)
}

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

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

func (s *CreatedNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterCreatedName(s)
	}
}

func (s *CreatedNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitCreatedName(s)
	}
}

func (p *JavaParser) CreatedName() (localctx ICreatedNameContext) {
	localctx = NewCreatedNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 178, JavaParserRULE_createdName)
	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(1267)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1252)
			p.Match(JavaParserIDENTIFIER)
		}
		p.SetState(1254)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserLT {
			{
				p.SetState(1253)
				p.TypeArgumentsOrDiamond()
			}

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

		for _la == JavaParserDOT {
			{
				p.SetState(1256)
				p.Match(JavaParserDOT)
			}
			{
				p.SetState(1257)
				p.Match(JavaParserIDENTIFIER)
			}
			p.SetState(1259)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == JavaParserLT {
				{
					p.SetState(1258)
					p.TypeArgumentsOrDiamond()
				}

			}

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

	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserSHORT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1266)
			p.PrimitiveType()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyInnerCreatorContext() *InnerCreatorContext {
	var p = new(InnerCreatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_innerCreator
	return p
}

func (*InnerCreatorContext) IsInnerCreatorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_innerCreator

	return p
}

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

func (s *InnerCreatorContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *InnerCreatorContext) ClassCreatorRest() IClassCreatorRestContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassCreatorRestContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassCreatorRestContext)
}

func (s *InnerCreatorContext) NonWildcardTypeArgumentsOrDiamond() INonWildcardTypeArgumentsOrDiamondContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INonWildcardTypeArgumentsOrDiamondContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INonWildcardTypeArgumentsOrDiamondContext)
}

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

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

func (s *InnerCreatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterInnerCreator(s)
	}
}

func (s *InnerCreatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitInnerCreator(s)
	}
}

func (p *JavaParser) InnerCreator() (localctx IInnerCreatorContext) {
	localctx = NewInnerCreatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 180, JavaParserRULE_innerCreator)
	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(1269)
		p.Match(JavaParserIDENTIFIER)
	}
	p.SetState(1271)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserLT {
		{
			p.SetState(1270)
			p.NonWildcardTypeArgumentsOrDiamond()
		}

	}
	{
		p.SetState(1273)
		p.ClassCreatorRest()
	}

	return localctx
}

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

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

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

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

func NewEmptyArrayCreatorRestContext() *ArrayCreatorRestContext {
	var p = new(ArrayCreatorRestContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_arrayCreatorRest
	return p
}

func (*ArrayCreatorRestContext) IsArrayCreatorRestContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_arrayCreatorRest

	return p
}

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

func (s *ArrayCreatorRestContext) AllLBRACK() []antlr.TerminalNode {
	return s.GetTokens(JavaParserLBRACK)
}

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

func (s *ArrayCreatorRestContext) AllRBRACK() []antlr.TerminalNode {
	return s.GetTokens(JavaParserRBRACK)
}

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

func (s *ArrayCreatorRestContext) ArrayInitializer() IArrayInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayInitializerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayInitializerContext)
}

func (s *ArrayCreatorRestContext) 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 *ArrayCreatorRestContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

func (s *ArrayCreatorRestContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterArrayCreatorRest(s)
	}
}

func (s *ArrayCreatorRestContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitArrayCreatorRest(s)
	}
}

func (p *JavaParser) ArrayCreatorRest() (localctx IArrayCreatorRestContext) {
	localctx = NewArrayCreatorRestContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 182, JavaParserRULE_arrayCreatorRest)
	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(1275)
		p.Match(JavaParserLBRACK)
	}
	p.SetState(1303)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserRBRACK:
		{
			p.SetState(1276)
			p.Match(JavaParserRBRACK)
		}
		p.SetState(1281)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == JavaParserLBRACK {
			{
				p.SetState(1277)
				p.Match(JavaParserLBRACK)
			}
			{
				p.SetState(1278)
				p.Match(JavaParserRBRACK)
			}

			p.SetState(1283)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1284)
			p.ArrayInitializer()
		}

	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserNEW, JavaParserSHORT, JavaParserSUPER, JavaParserTHIS, JavaParserVOID, JavaParserDECIMAL_LITERAL, JavaParserHEX_LITERAL, JavaParserOCT_LITERAL, JavaParserBINARY_LITERAL, JavaParserFLOAT_LITERAL, JavaParserHEX_FLOAT_LITERAL, JavaParserBOOL_LITERAL, JavaParserCHAR_LITERAL, JavaParserSTRING_LITERAL, JavaParserNULL_LITERAL, JavaParserLPAREN, JavaParserLT, JavaParserBANG, JavaParserTILDE, JavaParserINC, JavaParserDEC, JavaParserADD, JavaParserSUB, JavaParserAT, JavaParserIDENTIFIER:
		{
			p.SetState(1285)
			p.expression(0)
		}
		{
			p.SetState(1286)
			p.Match(JavaParserRBRACK)
		}
		p.SetState(1293)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 156, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(1287)
					p.Match(JavaParserLBRACK)
				}
				{
					p.SetState(1288)
					p.expression(0)
				}
				{
					p.SetState(1289)
					p.Match(JavaParserRBRACK)
				}

			}
			p.SetState(1295)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 156, p.GetParserRuleContext())
		}
		p.SetState(1300)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 157, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(1296)
					p.Match(JavaParserLBRACK)
				}
				{
					p.SetState(1297)
					p.Match(JavaParserRBRACK)
				}

			}
			p.SetState(1302)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 157, p.GetParserRuleContext())
		}

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

	return localctx
}

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

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

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

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

func NewEmptyClassCreatorRestContext() *ClassCreatorRestContext {
	var p = new(ClassCreatorRestContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_classCreatorRest
	return p
}

func (*ClassCreatorRestContext) IsClassCreatorRestContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_classCreatorRest

	return p
}

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

func (s *ClassCreatorRestContext) Arguments() IArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentsContext)
}

func (s *ClassCreatorRestContext) ClassBody() IClassBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassBodyContext)
}

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

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

func (s *ClassCreatorRestContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterClassCreatorRest(s)
	}
}

func (s *ClassCreatorRestContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitClassCreatorRest(s)
	}
}

func (p *JavaParser) ClassCreatorRest() (localctx IClassCreatorRestContext) {
	localctx = NewClassCreatorRestContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 184, JavaParserRULE_classCreatorRest)

	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(1305)
		p.Arguments()
	}
	p.SetState(1307)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 159, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1306)
			p.ClassBody()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyExplicitGenericInvocationContext() *ExplicitGenericInvocationContext {
	var p = new(ExplicitGenericInvocationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_explicitGenericInvocation
	return p
}

func (*ExplicitGenericInvocationContext) IsExplicitGenericInvocationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_explicitGenericInvocation

	return p
}

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

func (s *ExplicitGenericInvocationContext) NonWildcardTypeArguments() INonWildcardTypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INonWildcardTypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INonWildcardTypeArgumentsContext)
}

func (s *ExplicitGenericInvocationContext) ExplicitGenericInvocationSuffix() IExplicitGenericInvocationSuffixContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExplicitGenericInvocationSuffixContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExplicitGenericInvocationSuffixContext)
}

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

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

func (s *ExplicitGenericInvocationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterExplicitGenericInvocation(s)
	}
}

func (s *ExplicitGenericInvocationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitExplicitGenericInvocation(s)
	}
}

func (p *JavaParser) ExplicitGenericInvocation() (localctx IExplicitGenericInvocationContext) {
	localctx = NewExplicitGenericInvocationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 186, JavaParserRULE_explicitGenericInvocation)

	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(1309)
		p.NonWildcardTypeArguments()
	}
	{
		p.SetState(1310)
		p.ExplicitGenericInvocationSuffix()
	}

	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 = JavaParserRULE_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 = JavaParserRULE_typeArgumentsOrDiamond

	return p
}

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

func (s *TypeArgumentsOrDiamondContext) LT() antlr.TerminalNode {
	return s.GetToken(JavaParserLT, 0)
}

func (s *TypeArgumentsOrDiamondContext) GT() antlr.TerminalNode {
	return s.GetToken(JavaParserGT, 0)
}

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) 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.(JavaParserListener); ok {
		listenerT.EnterTypeArgumentsOrDiamond(s)
	}
}

func (s *TypeArgumentsOrDiamondContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitTypeArgumentsOrDiamond(s)
	}
}

func (p *JavaParser) TypeArgumentsOrDiamond() (localctx ITypeArgumentsOrDiamondContext) {
	localctx = NewTypeArgumentsOrDiamondContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 188, JavaParserRULE_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(1315)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 160, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1312)
			p.Match(JavaParserLT)
		}
		{
			p.SetState(1313)
			p.Match(JavaParserGT)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1314)
			p.TypeArguments()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyNonWildcardTypeArgumentsOrDiamondContext() *NonWildcardTypeArgumentsOrDiamondContext {
	var p = new(NonWildcardTypeArgumentsOrDiamondContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_nonWildcardTypeArgumentsOrDiamond
	return p
}

func (*NonWildcardTypeArgumentsOrDiamondContext) IsNonWildcardTypeArgumentsOrDiamondContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_nonWildcardTypeArgumentsOrDiamond

	return p
}

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

func (s *NonWildcardTypeArgumentsOrDiamondContext) LT() antlr.TerminalNode {
	return s.GetToken(JavaParserLT, 0)
}

func (s *NonWildcardTypeArgumentsOrDiamondContext) GT() antlr.TerminalNode {
	return s.GetToken(JavaParserGT, 0)
}

func (s *NonWildcardTypeArgumentsOrDiamondContext) NonWildcardTypeArguments() INonWildcardTypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INonWildcardTypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INonWildcardTypeArgumentsContext)
}

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

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

func (s *NonWildcardTypeArgumentsOrDiamondContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterNonWildcardTypeArgumentsOrDiamond(s)
	}
}

func (s *NonWildcardTypeArgumentsOrDiamondContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitNonWildcardTypeArgumentsOrDiamond(s)
	}
}

func (p *JavaParser) NonWildcardTypeArgumentsOrDiamond() (localctx INonWildcardTypeArgumentsOrDiamondContext) {
	localctx = NewNonWildcardTypeArgumentsOrDiamondContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 190, JavaParserRULE_nonWildcardTypeArgumentsOrDiamond)

	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(1320)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 161, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1317)
			p.Match(JavaParserLT)
		}
		{
			p.SetState(1318)
			p.Match(JavaParserGT)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1319)
			p.NonWildcardTypeArguments()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyNonWildcardTypeArgumentsContext() *NonWildcardTypeArgumentsContext {
	var p = new(NonWildcardTypeArgumentsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_nonWildcardTypeArguments
	return p
}

func (*NonWildcardTypeArgumentsContext) IsNonWildcardTypeArgumentsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_nonWildcardTypeArguments

	return p
}

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

func (s *NonWildcardTypeArgumentsContext) LT() antlr.TerminalNode {
	return s.GetToken(JavaParserLT, 0)
}

func (s *NonWildcardTypeArgumentsContext) TypeList() ITypeListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeListContext)
}

func (s *NonWildcardTypeArgumentsContext) GT() antlr.TerminalNode {
	return s.GetToken(JavaParserGT, 0)
}

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

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

func (s *NonWildcardTypeArgumentsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterNonWildcardTypeArguments(s)
	}
}

func (s *NonWildcardTypeArgumentsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitNonWildcardTypeArguments(s)
	}
}

func (p *JavaParser) NonWildcardTypeArguments() (localctx INonWildcardTypeArgumentsContext) {
	localctx = NewNonWildcardTypeArgumentsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 192, JavaParserRULE_nonWildcardTypeArguments)

	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(1322)
		p.Match(JavaParserLT)
	}
	{
		p.SetState(1323)
		p.TypeList()
	}
	{
		p.SetState(1324)
		p.Match(JavaParserGT)
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeListContext() *TypeListContext {
	var p = new(TypeListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_typeList
	return p
}

func (*TypeListContext) IsTypeListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_typeList

	return p
}

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

func (s *TypeListContext) AllTypeType() []ITypeTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem())
	var tst = make([]ITypeTypeContext, len(ts))

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

	return tst
}

func (s *TypeListContext) TypeType(i int) ITypeTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *TypeListContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(JavaParserCOMMA)
}

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

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

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

func (s *TypeListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterTypeList(s)
	}
}

func (s *TypeListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitTypeList(s)
	}
}

func (p *JavaParser) TypeList() (localctx ITypeListContext) {
	localctx = NewTypeListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 194, JavaParserRULE_typeList)
	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(1326)
		p.TypeType()
	}
	p.SetState(1331)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(1327)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(1328)
			p.TypeType()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyTypeTypeContext() *TypeTypeContext {
	var p = new(TypeTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_typeType
	return p
}

func (*TypeTypeContext) IsTypeTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_typeType

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IClassOrInterfaceTypeContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IPrimitiveTypeContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *TypeTypeContext) AllLBRACK() []antlr.TerminalNode {
	return s.GetTokens(JavaParserLBRACK)
}

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

func (s *TypeTypeContext) AllRBRACK() []antlr.TerminalNode {
	return s.GetTokens(JavaParserRBRACK)
}

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

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

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

func (s *TypeTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterTypeType(s)
	}
}

func (s *TypeTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitTypeType(s)
	}
}

func (p *JavaParser) TypeType() (localctx ITypeTypeContext) {
	localctx = NewTypeTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 196, JavaParserRULE_typeType)
	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(1335)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserAT {
		{
			p.SetState(1334)
			p.Annotation()
		}

	}
	p.SetState(1339)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserIDENTIFIER:
		{
			p.SetState(1337)
			p.ClassOrInterfaceType()
		}

	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserSHORT:
		{
			p.SetState(1338)
			p.PrimitiveType()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	p.SetState(1345)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 165, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1341)
				p.Match(JavaParserLBRACK)
			}
			{
				p.SetState(1342)
				p.Match(JavaParserRBRACK)
			}

		}
		p.SetState(1347)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 165, p.GetParserRuleContext())
	}

	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 = JavaParserRULE_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 = JavaParserRULE_primitiveType

	return p
}

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

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

func (s *PrimitiveTypeContext) CHAR() antlr.TerminalNode {
	return s.GetToken(JavaParserCHAR, 0)
}

func (s *PrimitiveTypeContext) BYTE() antlr.TerminalNode {
	return s.GetToken(JavaParserBYTE, 0)
}

func (s *PrimitiveTypeContext) SHORT() antlr.TerminalNode {
	return s.GetToken(JavaParserSHORT, 0)
}

func (s *PrimitiveTypeContext) INT() antlr.TerminalNode {
	return s.GetToken(JavaParserINT, 0)
}

func (s *PrimitiveTypeContext) LONG() antlr.TerminalNode {
	return s.GetToken(JavaParserLONG, 0)
}

func (s *PrimitiveTypeContext) FLOAT() antlr.TerminalNode {
	return s.GetToken(JavaParserFLOAT, 0)
}

func (s *PrimitiveTypeContext) DOUBLE() antlr.TerminalNode {
	return s.GetToken(JavaParserDOUBLE, 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.(JavaParserListener); ok {
		listenerT.EnterPrimitiveType(s)
	}
}

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

func (p *JavaParser) PrimitiveType() (localctx IPrimitiveTypeContext) {
	localctx = NewPrimitiveTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 198, JavaParserRULE_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.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1348)
		_la = p.GetTokenStream().LA(1)

		if !((((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserDOUBLE)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserLONG))) != 0) || _la == JavaParserSHORT) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	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 = JavaParserRULE_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 = JavaParserRULE_typeArguments

	return p
}

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

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

func (s *TypeArgumentsContext) 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 *TypeArgumentsContext) TypeArgument(i int) ITypeArgumentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentContext)
}

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

func (s *TypeArgumentsContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(JavaParserCOMMA)
}

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

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.(JavaParserListener); ok {
		listenerT.EnterTypeArguments(s)
	}
}

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

func (p *JavaParser) TypeArguments() (localctx ITypeArgumentsContext) {
	localctx = NewTypeArgumentsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 200, JavaParserRULE_typeArguments)
	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(1350)
		p.Match(JavaParserLT)
	}
	{
		p.SetState(1351)
		p.TypeArgument()
	}
	p.SetState(1356)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(1352)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(1353)
			p.TypeArgument()
		}

		p.SetState(1358)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1359)
		p.Match(JavaParserGT)
	}

	return localctx
}

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

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

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

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

func NewEmptySuperSuffixContext() *SuperSuffixContext {
	var p = new(SuperSuffixContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_superSuffix
	return p
}

func (*SuperSuffixContext) IsSuperSuffixContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_superSuffix

	return p
}

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

func (s *SuperSuffixContext) Arguments() IArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentsContext)
}

func (s *SuperSuffixContext) DOT() antlr.TerminalNode {
	return s.GetToken(JavaParserDOT, 0)
}

func (s *SuperSuffixContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

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

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

func (s *SuperSuffixContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterSuperSuffix(s)
	}
}

func (s *SuperSuffixContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitSuperSuffix(s)
	}
}

func (p *JavaParser) SuperSuffix() (localctx ISuperSuffixContext) {
	localctx = NewSuperSuffixContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 202, JavaParserRULE_superSuffix)

	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(1367)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserLPAREN:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1361)
			p.Arguments()
		}

	case JavaParserDOT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1362)
			p.Match(JavaParserDOT)
		}
		{
			p.SetState(1363)
			p.Match(JavaParserIDENTIFIER)
		}
		p.SetState(1365)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 167, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1364)
				p.Arguments()
			}

		}

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

	return localctx
}

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

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

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

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

func NewEmptyExplicitGenericInvocationSuffixContext() *ExplicitGenericInvocationSuffixContext {
	var p = new(ExplicitGenericInvocationSuffixContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_explicitGenericInvocationSuffix
	return p
}

func (*ExplicitGenericInvocationSuffixContext) IsExplicitGenericInvocationSuffixContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_explicitGenericInvocationSuffix

	return p
}

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

func (s *ExplicitGenericInvocationSuffixContext) SUPER() antlr.TerminalNode {
	return s.GetToken(JavaParserSUPER, 0)
}

func (s *ExplicitGenericInvocationSuffixContext) SuperSuffix() ISuperSuffixContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISuperSuffixContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISuperSuffixContext)
}

func (s *ExplicitGenericInvocationSuffixContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(JavaParserIDENTIFIER, 0)
}

func (s *ExplicitGenericInvocationSuffixContext) Arguments() IArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentsContext)
}

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

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

func (s *ExplicitGenericInvocationSuffixContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterExplicitGenericInvocationSuffix(s)
	}
}

func (s *ExplicitGenericInvocationSuffixContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitExplicitGenericInvocationSuffix(s)
	}
}

func (p *JavaParser) ExplicitGenericInvocationSuffix() (localctx IExplicitGenericInvocationSuffixContext) {
	localctx = NewExplicitGenericInvocationSuffixContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 204, JavaParserRULE_explicitGenericInvocationSuffix)

	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(1373)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserSUPER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1369)
			p.Match(JavaParserSUPER)
		}
		{
			p.SetState(1370)
			p.SuperSuffix()
		}

	case JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1371)
			p.Match(JavaParserIDENTIFIER)
		}
		{
			p.SetState(1372)
			p.Arguments()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyArgumentsContext() *ArgumentsContext {
	var p = new(ArgumentsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_arguments
	return p
}

func (*ArgumentsContext) IsArgumentsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_arguments

	return p
}

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

func (s *ArgumentsContext) LPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserLPAREN, 0)
}

func (s *ArgumentsContext) RPAREN() antlr.TerminalNode {
	return s.GetToken(JavaParserRPAREN, 0)
}

func (s *ArgumentsContext) ExpressionList() IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

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

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

func (s *ArgumentsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.EnterArguments(s)
	}
}

func (s *ArgumentsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(JavaParserListener); ok {
		listenerT.ExitArguments(s)
	}
}

func (p *JavaParser) Arguments() (localctx IArgumentsContext) {
	localctx = NewArgumentsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 206, JavaParserRULE_arguments)
	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(1375)
		p.Match(JavaParserLPAREN)
	}
	p.SetState(1377)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<JavaParserBOOLEAN)|(1<<JavaParserBYTE)|(1<<JavaParserCHAR)|(1<<JavaParserDOUBLE)|(1<<JavaParserFLOAT)|(1<<JavaParserINT)|(1<<JavaParserLONG)|(1<<JavaParserNEW))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(JavaParserSHORT-37))|(1<<(JavaParserSUPER-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37))|(1<<(JavaParserOCT_LITERAL-37))|(1<<(JavaParserBINARY_LITERAL-37))|(1<<(JavaParserFLOAT_LITERAL-37))|(1<<(JavaParserHEX_FLOAT_LITERAL-37))|(1<<(JavaParserBOOL_LITERAL-37))|(1<<(JavaParserCHAR_LITERAL-37))|(1<<(JavaParserSTRING_LITERAL-37))|(1<<(JavaParserNULL_LITERAL-37))|(1<<(JavaParserLPAREN-37)))) != 0) || (((_la-72)&-(0x1f+1)) == 0 && ((1<<uint((_la-72)))&((1<<(JavaParserLT-72))|(1<<(JavaParserBANG-72))|(1<<(JavaParserTILDE-72))|(1<<(JavaParserINC-72))|(1<<(JavaParserDEC-72))|(1<<(JavaParserADD-72))|(1<<(JavaParserSUB-72)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(1376)
			p.ExpressionList()
		}

	}
	{
		p.SetState(1379)
		p.Match(JavaParserRPAREN)
	}

	return localctx
}

func (p *JavaParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
	switch ruleIndex {
	case 82:
		var t *ExpressionContext = nil
		if localctx != nil {
			t = localctx.(*ExpressionContext)
		}
		return p.Expression_Sempred(t, predIndex)

	default:
		panic("No predicate with index: " + fmt.Sprint(ruleIndex))
	}
}

func (p *JavaParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 0:
		return p.Precpred(p.GetParserRuleContext(), 17)

	case 1:
		return p.Precpred(p.GetParserRuleContext(), 16)

	case 2:
		return p.Precpred(p.GetParserRuleContext(), 15)

	case 3:
		return p.Precpred(p.GetParserRuleContext(), 14)

	case 4:
		return p.Precpred(p.GetParserRuleContext(), 12)

	case 5:
		return p.Precpred(p.GetParserRuleContext(), 11)

	case 6:
		return p.Precpred(p.GetParserRuleContext(), 10)

	case 7:
		return p.Precpred(p.GetParserRuleContext(), 9)

	case 8:
		return p.Precpred(p.GetParserRuleContext(), 8)

	case 9:
		return p.Precpred(p.GetParserRuleContext(), 7)

	case 10:
		return p.Precpred(p.GetParserRuleContext(), 6)

	case 11:
		return p.Precpred(p.GetParserRuleContext(), 5)

	case 12:
		return p.Precpred(p.GetParserRuleContext(), 25)

	case 13:
		return p.Precpred(p.GetParserRuleContext(), 24)

	case 14:
		return p.Precpred(p.GetParserRuleContext(), 20)

	case 15:
		return p.Precpred(p.GetParserRuleContext(), 13)

	case 16:
		return p.Precpred(p.GetParserRuleContext(), 3)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}
