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

package java // 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, 130, 1762,
	4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7,
	4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13,
	9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9,
	18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23,
	4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4,
	29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34,
	9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9,
	39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44,
	4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4,
	50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55,
	9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9,
	60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65,
	4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4,
	71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76,
	9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9,
	81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86,
	4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4,
	92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97,
	9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102,
	9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106,
	4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111,
	9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115,
	4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120,
	9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124,
	4, 125, 9, 125, 3, 2, 5, 2, 252, 10, 2, 3, 2, 7, 2, 255, 10, 2, 12, 2,
	14, 2, 258, 11, 2, 3, 2, 7, 2, 261, 10, 2, 12, 2, 14, 2, 264, 11, 2, 3,
	2, 3, 2, 3, 2, 5, 2, 269, 10, 2, 3, 3, 7, 3, 272, 10, 3, 12, 3, 14, 3,
	275, 11, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 5, 4, 283, 10, 4, 3, 4,
	3, 4, 3, 4, 5, 4, 288, 10, 4, 3, 4, 3, 4, 3, 5, 7, 5, 293, 10, 5, 12, 5,
	14, 5, 296, 11, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 303, 10, 5, 3, 5,
	5, 5, 306, 10, 5, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 5, 6, 313, 10, 6, 3, 7,
	3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 325, 10, 7,
	3, 8, 3, 8, 5, 8, 329, 10, 8, 3, 9, 3, 9, 3, 9, 5, 9, 334, 10, 9, 3, 9,
	3, 9, 5, 9, 338, 10, 9, 3, 9, 3, 9, 5, 9, 342, 10, 9, 3, 9, 3, 9, 5, 9,
	346, 10, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 10, 7, 10, 354, 10, 10,
	12, 10, 14, 10, 357, 11, 10, 3, 10, 3, 10, 3, 11, 7, 11, 362, 10, 11, 12,
	11, 14, 11, 365, 11, 11, 3, 11, 3, 11, 3, 11, 7, 11, 370, 10, 11, 12, 11,
	14, 11, 373, 11, 11, 3, 11, 5, 11, 376, 10, 11, 3, 12, 3, 12, 3, 12, 7,
	12, 381, 10, 12, 12, 12, 14, 12, 384, 11, 12, 3, 13, 3, 13, 3, 13, 3, 13,
	5, 13, 390, 10, 13, 3, 13, 3, 13, 5, 13, 394, 10, 13, 3, 13, 5, 13, 397,
	10, 13, 3, 13, 5, 13, 400, 10, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 7,
	14, 407, 10, 14, 12, 14, 14, 14, 410, 11, 14, 3, 15, 7, 15, 413, 10, 15,
	12, 15, 14, 15, 416, 11, 15, 3, 15, 3, 15, 5, 15, 420, 10, 15, 3, 15, 5,
	15, 423, 10, 15, 3, 16, 3, 16, 7, 16, 427, 10, 16, 12, 16, 14, 16, 430,
	11, 16, 3, 17, 3, 17, 3, 17, 5, 17, 435, 10, 17, 3, 17, 3, 17, 5, 17, 439,
	10, 17, 3, 17, 3, 17, 3, 18, 3, 18, 7, 18, 445, 10, 18, 12, 18, 14, 18,
	448, 11, 18, 3, 18, 3, 18, 3, 19, 3, 19, 7, 19, 454, 10, 19, 12, 19, 14,
	19, 457, 11, 19, 3, 19, 3, 19, 3, 20, 3, 20, 5, 20, 463, 10, 20, 3, 20,
	3, 20, 7, 20, 467, 10, 20, 12, 20, 14, 20, 470, 11, 20, 3, 20, 5, 20, 473,
	10, 20, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21,
	3, 21, 5, 21, 485, 10, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 7, 22, 492,
	10, 22, 12, 22, 14, 22, 495, 11, 22, 3, 22, 3, 22, 5, 22, 499, 10, 22,
	3, 22, 3, 22, 3, 23, 3, 23, 5, 23, 505, 10, 23, 3, 24, 3, 24, 5, 24, 509,
	10, 24, 3, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27,
	3, 27, 5, 27, 521, 10, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3,
	29, 7, 29, 530, 10, 29, 12, 29, 14, 29, 533, 11, 29, 3, 29, 3, 29, 5, 29,
	537, 10, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 5,
	30, 547, 10, 30, 3, 31, 3, 31, 3, 31, 3, 31, 7, 31, 553, 10, 31, 12, 31,
	14, 31, 556, 11, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 7, 32, 563, 10,
	32, 12, 32, 14, 32, 566, 11, 32, 3, 32, 3, 32, 3, 32, 3, 33, 7, 33, 572,
	10, 33, 12, 33, 14, 33, 575, 11, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34,
	3, 34, 3, 34, 3, 34, 5, 34, 585, 10, 34, 3, 35, 7, 35, 588, 10, 35, 12,
	35, 14, 35, 591, 11, 35, 3, 35, 3, 35, 3, 35, 3, 36, 7, 36, 597, 10, 36,
	12, 36, 14, 36, 600, 11, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 7, 36,
	607, 10, 36, 12, 36, 14, 36, 610, 11, 36, 3, 36, 3, 36, 5, 36, 614, 10,
	36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 7, 37, 621, 10, 37, 12, 37, 14,
	37, 624, 11, 37, 3, 38, 3, 38, 3, 38, 5, 38, 629, 10, 38, 3, 39, 3, 39,
	3, 39, 7, 39, 634, 10, 39, 12, 39, 14, 39, 637, 11, 39, 3, 40, 3, 40, 5,
	40, 641, 10, 40, 3, 41, 3, 41, 3, 41, 3, 41, 7, 41, 647, 10, 41, 12, 41,
	14, 41, 650, 11, 41, 3, 41, 5, 41, 653, 10, 41, 5, 41, 655, 10, 41, 3,
	41, 3, 41, 3, 42, 3, 42, 5, 42, 661, 10, 42, 3, 42, 3, 42, 3, 42, 5, 42,
	666, 10, 42, 7, 42, 668, 10, 42, 12, 42, 14, 42, 671, 11, 42, 3, 43, 3,
	43, 7, 43, 675, 10, 43, 12, 43, 14, 43, 678, 11, 43, 3, 43, 3, 43, 3, 43,
	5, 43, 683, 10, 43, 5, 43, 685, 10, 43, 3, 44, 3, 44, 3, 44, 7, 44, 690,
	10, 44, 12, 44, 14, 44, 693, 11, 44, 3, 45, 3, 45, 5, 45, 697, 10, 45,
	3, 45, 3, 45, 3, 45, 5, 45, 702, 10, 45, 3, 45, 5, 45, 705, 10, 45, 5,
	45, 707, 10, 45, 3, 45, 3, 45, 3, 46, 3, 46, 3, 46, 3, 46, 7, 46, 715,
	10, 46, 12, 46, 14, 46, 718, 11, 46, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47,
	7, 47, 725, 10, 47, 12, 47, 14, 47, 728, 11, 47, 3, 47, 3, 47, 5, 47, 732,
	10, 47, 3, 47, 5, 47, 735, 10, 47, 3, 48, 7, 48, 738, 10, 48, 12, 48, 14,
	48, 741, 11, 48, 3, 48, 3, 48, 3, 48, 3, 49, 7, 49, 747, 10, 49, 12, 49,
	14, 49, 750, 11, 49, 3, 49, 3, 49, 7, 49, 754, 10, 49, 12, 49, 14, 49,
	757, 11, 49, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 7, 50, 765, 10,
	50, 12, 50, 14, 50, 768, 11, 50, 3, 51, 7, 51, 771, 10, 51, 12, 51, 14,
	51, 774, 11, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 7, 52, 782,
	10, 52, 12, 52, 14, 52, 785, 11, 52, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53,
	3, 53, 3, 53, 5, 53, 794, 10, 53, 3, 54, 3, 54, 3, 55, 3, 55, 3, 56, 3,
	56, 3, 56, 7, 56, 803, 10, 56, 12, 56, 14, 56, 806, 11, 56, 3, 56, 3, 56,
	3, 56, 3, 57, 3, 57, 3, 57, 5, 57, 814, 10, 57, 3, 57, 3, 57, 3, 57, 5,
	57, 819, 10, 57, 3, 57, 5, 57, 822, 10, 57, 3, 58, 3, 58, 3, 58, 7, 58,
	827, 10, 58, 12, 58, 14, 58, 830, 11, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3,
	60, 3, 60, 3, 60, 5, 60, 839, 10, 60, 3, 61, 3, 61, 3, 61, 3, 61, 7, 61,
	845, 10, 61, 12, 61, 14, 61, 848, 11, 61, 5, 61, 850, 10, 61, 3, 61, 5,
	61, 853, 10, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 63,
	3, 63, 7, 63, 864, 10, 63, 12, 63, 14, 63, 867, 11, 63, 3, 63, 3, 63, 3,
	64, 7, 64, 872, 10, 64, 12, 64, 14, 64, 875, 11, 64, 3, 64, 3, 64, 5, 64,
	879, 10, 64, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 5, 65, 887, 10,
	65, 3, 65, 3, 65, 5, 65, 891, 10, 65, 3, 65, 3, 65, 5, 65, 895, 10, 65,
	3, 65, 3, 65, 5, 65, 899, 10, 65, 3, 65, 3, 65, 5, 65, 903, 10, 65, 5,
	65, 905, 10, 65, 3, 66, 3, 66, 5, 66, 909, 10, 66, 3, 67, 3, 67, 3, 67,
	3, 67, 5, 67, 915, 10, 67, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 3, 70, 5,
	70, 923, 10, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 71, 3, 71, 7, 71, 931,
	10, 71, 12, 71, 14, 71, 934, 11, 71, 3, 71, 3, 71, 3, 72, 3, 72, 7, 72,
	940, 10, 72, 12, 72, 14, 72, 943, 11, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3,
	72, 3, 72, 3, 72, 5, 72, 952, 10, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72,
	3, 72, 5, 72, 960, 10, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3,
	72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 5, 72, 974, 10, 72, 3, 73, 3, 73,
	3, 74, 3, 74, 3, 74, 5, 74, 981, 10, 74, 3, 74, 3, 74, 3, 74, 5, 74, 986,
	10, 74, 3, 74, 3, 74, 3, 75, 3, 75, 5, 75, 992, 10, 75, 3, 75, 3, 75, 3,
	76, 3, 76, 3, 76, 7, 76, 999, 10, 76, 12, 76, 14, 76, 1002, 11, 76, 3,
	77, 3, 77, 3, 77, 3, 78, 3, 78, 7, 78, 1009, 10, 78, 12, 78, 14, 78, 1012,
	11, 78, 3, 78, 3, 78, 3, 79, 3, 79, 7, 79, 1018, 10, 79, 12, 79, 14, 79,
	1021, 11, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 5, 80, 1030,
	10, 80, 3, 81, 7, 81, 1033, 10, 81, 12, 81, 14, 81, 1036, 11, 81, 3, 81,
	3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 5, 81, 1046, 10, 81, 3,
	82, 3, 82, 3, 83, 7, 83, 1051, 10, 83, 12, 83, 14, 83, 1054, 11, 83, 3,
	83, 3, 83, 3, 83, 5, 83, 1059, 10, 83, 3, 83, 5, 83, 1062, 10, 83, 3, 84,
	3, 84, 3, 84, 3, 84, 3, 84, 5, 84, 1069, 10, 84, 3, 84, 3, 84, 3, 84, 3,
	84, 3, 84, 3, 84, 3, 84, 5, 84, 1078, 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, 6, 84, 1099, 10, 84, 13, 84, 14, 84, 1100,
	3, 84, 5, 84, 1104, 10, 84, 3, 84, 5, 84, 1107, 10, 84, 3, 84, 3, 84, 3,
	84, 3, 84, 7, 84, 1113, 10, 84, 12, 84, 14, 84, 1116, 11, 84, 3, 84, 5,
	84, 1119, 10, 84, 3, 84, 3, 84, 3, 84, 3, 84, 7, 84, 1125, 10, 84, 12,
	84, 14, 84, 1128, 11, 84, 3, 84, 7, 84, 1131, 10, 84, 12, 84, 14, 84, 1134,
	11, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 5, 84,
	1144, 10, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 5, 84, 1153,
	10, 84, 3, 84, 3, 84, 3, 84, 5, 84, 1158, 10, 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, 1171, 10,
	84, 3, 84, 3, 84, 3, 84, 3, 84, 5, 84, 1177, 10, 84, 3, 85, 3, 85, 3, 85,
	7, 85, 1182, 10, 85, 12, 85, 14, 85, 1185, 11, 85, 3, 85, 3, 85, 3, 85,
	3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 7, 86, 1195, 10, 86, 12, 86, 14, 86,
	1198, 11, 86, 3, 87, 3, 87, 3, 87, 3, 88, 3, 88, 3, 88, 5, 88, 1206, 10,
	88, 3, 88, 3, 88, 3, 89, 3, 89, 3, 89, 7, 89, 1213, 10, 89, 12, 89, 14,
	89, 1216, 11, 89, 3, 90, 7, 90, 1219, 10, 90, 12, 90, 14, 90, 1222, 11,
	90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 5, 90, 1229, 10, 90, 3, 90, 3, 90,
	3, 90, 3, 90, 5, 90, 1235, 10, 90, 3, 91, 6, 91, 1238, 10, 91, 13, 91,
	14, 91, 1239, 3, 91, 6, 91, 1243, 10, 91, 13, 91, 14, 91, 1244, 3, 92,
	3, 92, 3, 92, 3, 92, 3, 92, 3, 92, 5, 92, 1253, 10, 92, 3, 92, 3, 92, 3,
	92, 5, 92, 1258, 10, 92, 3, 93, 3, 93, 5, 93, 1262, 10, 93, 3, 93, 3, 93,
	5, 93, 1266, 10, 93, 3, 93, 3, 93, 5, 93, 1270, 10, 93, 5, 93, 1272, 10,
	93, 3, 94, 3, 94, 5, 94, 1276, 10, 94, 3, 95, 7, 95, 1279, 10, 95, 12,
	95, 14, 95, 1282, 11, 95, 3, 95, 3, 95, 5, 95, 1286, 10, 95, 3, 95, 3,
	95, 3, 95, 3, 95, 3, 96, 3, 96, 3, 96, 3, 96, 3, 97, 3, 97, 3, 97, 7, 97,
	1299, 10, 97, 12, 97, 14, 97, 1302, 11, 97, 3, 98, 3, 98, 3, 98, 5, 98,
	1307, 10, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 5, 98, 1314, 10, 98, 3,
	98, 3, 98, 3, 98, 3, 98, 5, 98, 1320, 10, 98, 3, 98, 5, 98, 1323, 10, 98,
	3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 7, 99, 1332, 10, 99, 12,
	99, 14, 99, 1335, 11, 99, 3, 99, 3, 99, 3, 99, 7, 99, 1340, 10, 99, 12,
	99, 14, 99, 1343, 11, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3,
	99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 5, 99, 1357, 10, 99, 3, 99, 3, 99,
	5, 99, 1361, 10, 99, 3, 99, 3, 99, 3, 99, 5, 99, 1366, 10, 99, 3, 99, 3,
	99, 5, 99, 1370, 10, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99,
	3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 5, 99, 1386, 10, 99, 3,
	99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99,
	3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3,
	99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99,
	3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 5, 99, 1426, 10, 99, 3, 99, 3,
	99, 3, 99, 3, 99, 5, 99, 1432, 10, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99,
	3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 5, 99, 1445, 10, 99, 3, 99, 3,
	99, 3, 99, 5, 99, 1450, 10, 99, 3, 99, 7, 99, 1453, 10, 99, 12, 99, 14,
	99, 1456, 11, 99, 3, 100, 7, 100, 1459, 10, 100, 12, 100, 14, 100, 1462,
	11, 100, 3, 100, 3, 100, 7, 100, 1466, 10, 100, 12, 100, 14, 100, 1469,
	11, 100, 3, 100, 3, 100, 3, 101, 3, 101, 3, 101, 3, 101, 3, 102, 3, 102,
	3, 102, 5, 102, 1480, 10, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102,
	7, 102, 1487, 10, 102, 12, 102, 14, 102, 1490, 11, 102, 3, 102, 3, 102,
	3, 102, 3, 102, 5, 102, 1496, 10, 102, 3, 102, 5, 102, 1499, 10, 102, 3,
	103, 3, 103, 5, 103, 1503, 10, 103, 3, 104, 3, 104, 3, 104, 3, 104, 3,
	104, 3, 104, 3, 104, 3, 104, 3, 104, 3, 104, 3, 104, 3, 104, 3, 104, 3,
	104, 3, 104, 3, 104, 5, 104, 1521, 10, 104, 5, 104, 1523, 10, 104, 3, 105,
	3, 105, 3, 105, 3, 105, 7, 105, 1529, 10, 105, 12, 105, 14, 105, 1532,
	11, 105, 3, 105, 3, 105, 3, 106, 3, 106, 3, 106, 3, 106, 5, 106, 1540,
	10, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 5, 106, 1547, 10, 106,
	3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 7, 107, 1555, 10, 107,
	12, 107, 14, 107, 1558, 11, 107, 3, 107, 3, 107, 7, 107, 1562, 10, 107,
	12, 107, 14, 107, 1565, 11, 107, 3, 107, 3, 107, 3, 107, 7, 107, 1570,
	10, 107, 12, 107, 14, 107, 1573, 11, 107, 5, 107, 1575, 10, 107, 3, 107,
	3, 107, 3, 107, 7, 107, 1580, 10, 107, 12, 107, 14, 107, 1583, 11, 107,
	3, 108, 3, 108, 7, 108, 1587, 10, 108, 12, 108, 14, 108, 1590, 11, 108,
	5, 108, 1592, 10, 108, 3, 109, 3, 109, 3, 109, 5, 109, 1597, 10, 109, 3,
	109, 7, 109, 1600, 10, 109, 12, 109, 14, 109, 1603, 11, 109, 3, 109, 3,
	109, 5, 109, 1607, 10, 109, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3,
	110, 3, 110, 5, 110, 1616, 10, 110, 5, 110, 1618, 10, 110, 3, 111, 3, 111,
	5, 111, 1622, 10, 111, 3, 111, 3, 111, 3, 111, 5, 111, 1627, 10, 111, 7,
	111, 1629, 10, 111, 12, 111, 14, 111, 1632, 11, 111, 3, 111, 5, 111, 1635,
	10, 111, 3, 112, 3, 112, 5, 112, 1639, 10, 112, 3, 112, 3, 112, 3, 113,
	3, 113, 3, 113, 3, 113, 7, 113, 1647, 10, 113, 12, 113, 14, 113, 1650,
	11, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 7, 113,
	1659, 10, 113, 12, 113, 14, 113, 1662, 11, 113, 3, 113, 3, 113, 7, 113,
	1666, 10, 113, 12, 113, 14, 113, 1669, 11, 113, 5, 113, 1671, 10, 113,
	3, 114, 3, 114, 5, 114, 1675, 10, 114, 3, 115, 3, 115, 3, 115, 3, 116,
	3, 116, 3, 116, 5, 116, 1683, 10, 116, 3, 117, 3, 117, 3, 117, 5, 117,
	1688, 10, 117, 3, 118, 3, 118, 3, 118, 3, 118, 3, 119, 3, 119, 3, 119,
	7, 119, 1697, 10, 119, 12, 119, 14, 119, 1700, 11, 119, 3, 120, 7, 120,
	1703, 10, 120, 12, 120, 14, 120, 1706, 11, 120, 3, 120, 3, 120, 5, 120,
	1710, 10, 120, 3, 120, 7, 120, 1713, 10, 120, 12, 120, 14, 120, 1716, 11,
	120, 3, 120, 3, 120, 7, 120, 1720, 10, 120, 12, 120, 14, 120, 1723, 11,
	120, 3, 121, 3, 121, 3, 122, 3, 122, 3, 122, 3, 122, 7, 122, 1731, 10,
	122, 12, 122, 14, 122, 1734, 11, 122, 3, 122, 3, 122, 3, 123, 3, 123, 3,
	123, 5, 123, 1741, 10, 123, 3, 123, 3, 123, 5, 123, 1745, 10, 123, 5, 123,
	1747, 10, 123, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 5, 124, 1754, 10,
	124, 3, 125, 3, 125, 5, 125, 1758, 10, 125, 3, 125, 3, 125, 3, 125, 2,
	4, 196, 212, 126, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30,
	32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66,
	68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102,
	104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132,
	134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162,
	164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192,
	194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222,
	224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 2, 17,
	4, 2, 19, 19, 42, 42, 3, 2, 69, 72, 3, 2, 73, 74, 4, 2, 40, 40, 62, 62,
	4, 2, 53, 67, 130, 130, 3, 2, 102, 105, 3, 2, 92, 93, 4, 2, 106, 107, 111,
	111, 3, 2, 104, 105, 4, 2, 90, 91, 97, 98, 4, 2, 96, 96, 99, 99, 4, 2,
	89, 89, 112, 122, 3, 2, 102, 103, 4, 2, 95, 95, 123, 123, 10, 2, 5, 5,
	7, 7, 10, 10, 16, 16, 22, 22, 29, 29, 31, 31, 39, 39, 2, 1961, 2, 268,
	3, 2, 2, 2, 4, 273, 3, 2, 2, 2, 6, 280, 3, 2, 2, 2, 8, 305, 3, 2, 2, 2,
	10, 312, 3, 2, 2, 2, 12, 324, 3, 2, 2, 2, 14, 328, 3, 2, 2, 2, 16, 330,
	3, 2, 2, 2, 18, 349, 3, 2, 2, 2, 20, 363, 3, 2, 2, 2, 22, 377, 3, 2, 2,
	2, 24, 385, 3, 2, 2, 2, 26, 403, 3, 2, 2, 2, 28, 414, 3, 2, 2, 2, 30, 424,
	3, 2, 2, 2, 32, 431, 3, 2, 2, 2, 34, 442, 3, 2, 2, 2, 36, 451, 3, 2, 2,
	2, 38, 472, 3, 2, 2, 2, 40, 484, 3, 2, 2, 2, 42, 486, 3, 2, 2, 2, 44, 504,
	3, 2, 2, 2, 46, 508, 3, 2, 2, 2, 48, 510, 3, 2, 2, 2, 50, 513, 3, 2, 2,
	2, 52, 516, 3, 2, 2, 2, 54, 524, 3, 2, 2, 2, 56, 536, 3, 2, 2, 2, 58, 546,
	3, 2, 2, 2, 60, 548, 3, 2, 2, 2, 62, 559, 3, 2, 2, 2, 64, 573, 3, 2, 2,
	2, 66, 584, 3, 2, 2, 2, 68, 589, 3, 2, 2, 2, 70, 598, 3, 2, 2, 2, 72, 617,
	3, 2, 2, 2, 74, 625, 3, 2, 2, 2, 76, 630, 3, 2, 2, 2, 78, 640, 3, 2, 2,
	2, 80, 642, 3, 2, 2, 2, 82, 658, 3, 2, 2, 2, 84, 684, 3, 2, 2, 2, 86, 686,
	3, 2, 2, 2, 88, 694, 3, 2, 2, 2, 90, 710, 3, 2, 2, 2, 92, 734, 3, 2, 2,
	2, 94, 739, 3, 2, 2, 2, 96, 748, 3, 2, 2, 2, 98, 761, 3, 2, 2, 2, 100,
	772, 3, 2, 2, 2, 102, 778, 3, 2, 2, 2, 104, 793, 3, 2, 2, 2, 106, 795,
	3, 2, 2, 2, 108, 797, 3, 2, 2, 2, 110, 804, 3, 2, 2, 2, 112, 813, 3, 2,
	2, 2, 114, 823, 3, 2, 2, 2, 116, 831, 3, 2, 2, 2, 118, 838, 3, 2, 2, 2,
	120, 840, 3, 2, 2, 2, 122, 856, 3, 2, 2, 2, 124, 861, 3, 2, 2, 2, 126,
	878, 3, 2, 2, 2, 128, 904, 3, 2, 2, 2, 130, 908, 3, 2, 2, 2, 132, 910,
	3, 2, 2, 2, 134, 916, 3, 2, 2, 2, 136, 918, 3, 2, 2, 2, 138, 922, 3, 2,
	2, 2, 140, 928, 3, 2, 2, 2, 142, 973, 3, 2, 2, 2, 144, 975, 3, 2, 2, 2,
	146, 977, 3, 2, 2, 2, 148, 989, 3, 2, 2, 2, 150, 995, 3, 2, 2, 2, 152,
	1003, 3, 2, 2, 2, 154, 1006, 3, 2, 2, 2, 156, 1015, 3, 2, 2, 2, 158, 1029,
	3, 2, 2, 2, 160, 1034, 3, 2, 2, 2, 162, 1047, 3, 2, 2, 2, 164, 1061, 3,
	2, 2, 2, 166, 1176, 3, 2, 2, 2, 168, 1178, 3, 2, 2, 2, 170, 1191, 3, 2,
	2, 2, 172, 1199, 3, 2, 2, 2, 174, 1202, 3, 2, 2, 2, 176, 1209, 3, 2, 2,
	2, 178, 1234, 3, 2, 2, 2, 180, 1237, 3, 2, 2, 2, 182, 1257, 3, 2, 2, 2,
	184, 1271, 3, 2, 2, 2, 186, 1275, 3, 2, 2, 2, 188, 1280, 3, 2, 2, 2, 190,
	1291, 3, 2, 2, 2, 192, 1295, 3, 2, 2, 2, 194, 1322, 3, 2, 2, 2, 196, 1369,
	3, 2, 2, 2, 198, 1460, 3, 2, 2, 2, 200, 1472, 3, 2, 2, 2, 202, 1498, 3,
	2, 2, 2, 204, 1502, 3, 2, 2, 2, 206, 1522, 3, 2, 2, 2, 208, 1524, 3, 2,
	2, 2, 210, 1546, 3, 2, 2, 2, 212, 1574, 3, 2, 2, 2, 214, 1591, 3, 2, 2,
	2, 216, 1596, 3, 2, 2, 2, 218, 1617, 3, 2, 2, 2, 220, 1634, 3, 2, 2, 2,
	222, 1636, 3, 2, 2, 2, 224, 1642, 3, 2, 2, 2, 226, 1672, 3, 2, 2, 2, 228,
	1676, 3, 2, 2, 2, 230, 1682, 3, 2, 2, 2, 232, 1687, 3, 2, 2, 2, 234, 1689,
	3, 2, 2, 2, 236, 1693, 3, 2, 2, 2, 238, 1704, 3, 2, 2, 2, 240, 1724, 3,
	2, 2, 2, 242, 1726, 3, 2, 2, 2, 244, 1746, 3, 2, 2, 2, 246, 1753, 3, 2,
	2, 2, 248, 1755, 3, 2, 2, 2, 250, 252, 5, 4, 3, 2, 251, 250, 3, 2, 2, 2,
	251, 252, 3, 2, 2, 2, 252, 256, 3, 2, 2, 2, 253, 255, 5, 6, 4, 2, 254,
	253, 3, 2, 2, 2, 255, 258, 3, 2, 2, 2, 256, 254, 3, 2, 2, 2, 256, 257,
	3, 2, 2, 2, 257, 262, 3, 2, 2, 2, 258, 256, 3, 2, 2, 2, 259, 261, 5, 8,
	5, 2, 260, 259, 3, 2, 2, 2, 261, 264, 3, 2, 2, 2, 262, 260, 3, 2, 2, 2,
	262, 263, 3, 2, 2, 2, 263, 269, 3, 2, 2, 2, 264, 262, 3, 2, 2, 2, 265,
	266, 5, 138, 70, 2, 266, 267, 7, 2, 2, 3, 267, 269, 3, 2, 2, 2, 268, 251,
	3, 2, 2, 2, 268, 265, 3, 2, 2, 2, 269, 3, 3, 2, 2, 2, 270, 272, 5, 112,
	57, 2, 271, 270, 3, 2, 2, 2, 272, 275, 3, 2, 2, 2, 273, 271, 3, 2, 2, 2,
	273, 274, 3, 2, 2, 2, 274, 276, 3, 2, 2, 2, 275, 273, 3, 2, 2, 2, 276,
	277, 7, 34, 2, 2, 277, 278, 5, 102, 52, 2, 278, 279, 7, 86, 2, 2, 279,
	5, 3, 2, 2, 2, 280, 282, 7, 27, 2, 2, 281, 283, 7, 40, 2, 2, 282, 281,
	3, 2, 2, 2, 282, 283, 3, 2, 2, 2, 283, 284, 3, 2, 2, 2, 284, 287, 5, 102,
	52, 2, 285, 286, 7, 88, 2, 2, 286, 288, 7, 106, 2, 2, 287, 285, 3, 2, 2,
	2, 287, 288, 3, 2, 2, 2, 288, 289, 3, 2, 2, 2, 289, 290, 7, 86, 2, 2, 290,
	7, 3, 2, 2, 2, 291, 293, 5, 12, 7, 2, 292, 291, 3, 2, 2, 2, 293, 296, 3,
	2, 2, 2, 294, 292, 3, 2, 2, 2, 294, 295, 3, 2, 2, 2, 295, 302, 3, 2, 2,
	2, 296, 294, 3, 2, 2, 2, 297, 303, 5, 16, 9, 2, 298, 303, 5, 24, 13, 2,
	299, 303, 5, 32, 17, 2, 300, 303, 5, 122, 62, 2, 301, 303, 5, 146, 74,
	2, 302, 297, 3, 2, 2, 2, 302, 298, 3, 2, 2, 2, 302, 299, 3, 2, 2, 2, 302,
	300, 3, 2, 2, 2, 302, 301, 3, 2, 2, 2, 303, 306, 3, 2, 2, 2, 304, 306,
	7, 86, 2, 2, 305, 294, 3, 2, 2, 2, 305, 304, 3, 2, 2, 2, 306, 9, 3, 2,
	2, 2, 307, 313, 5, 12, 7, 2, 308, 313, 7, 32, 2, 2, 309, 313, 7, 44, 2,
	2, 310, 313, 7, 48, 2, 2, 311, 313, 7, 51, 2, 2, 312, 307, 3, 2, 2, 2,
	312, 308, 3, 2, 2, 2, 312, 309, 3, 2, 2, 2, 312, 310, 3, 2, 2, 2, 312,
	311, 3, 2, 2, 2, 313, 11, 3, 2, 2, 2, 314, 325, 5, 112, 57, 2, 315, 325,
	7, 37, 2, 2, 316, 325, 7, 36, 2, 2, 317, 325, 7, 35, 2, 2, 318, 325, 7,
	40, 2, 2, 319, 325, 7, 3, 2, 2, 320, 325, 7, 20, 2, 2, 321, 325, 7, 41,
	2, 2, 322, 325, 7, 66, 2, 2, 323, 325, 7, 68, 2, 2, 324, 314, 3, 2, 2,
	2, 324, 315, 3, 2, 2, 2, 324, 316, 3, 2, 2, 2, 324, 317, 3, 2, 2, 2, 324,
	318, 3, 2, 2, 2, 324, 319, 3, 2, 2, 2, 324, 320, 3, 2, 2, 2, 324, 321,
	3, 2, 2, 2, 324, 322, 3, 2, 2, 2, 324, 323, 3, 2, 2, 2, 325, 13, 3, 2,
	2, 2, 326, 329, 7, 20, 2, 2, 327, 329, 5, 112, 57, 2, 328, 326, 3, 2, 2,
	2, 328, 327, 3, 2, 2, 2, 329, 15, 3, 2, 2, 2, 330, 331, 7, 11, 2, 2, 331,
	333, 5, 162, 82, 2, 332, 334, 5, 18, 10, 2, 333, 332, 3, 2, 2, 2, 333,
	334, 3, 2, 2, 2, 334, 337, 3, 2, 2, 2, 335, 336, 7, 19, 2, 2, 336, 338,
	5, 238, 120, 2, 337, 335, 3, 2, 2, 2, 337, 338, 3, 2, 2, 2, 338, 341, 3,
	2, 2, 2, 339, 340, 7, 26, 2, 2, 340, 342, 5, 236, 119, 2, 341, 339, 3,
	2, 2, 2, 341, 342, 3, 2, 2, 2, 342, 345, 3, 2, 2, 2, 343, 344, 7, 67, 2,
	2, 344, 346, 5, 236, 119, 2, 345, 343, 3, 2, 2, 2, 345, 346, 3, 2, 2, 2,
	346, 347, 3, 2, 2, 2, 347, 348, 5, 34, 18, 2, 348, 17, 3, 2, 2, 2, 349,
	350, 7, 91, 2, 2, 350, 355, 5, 20, 11, 2, 351, 352, 7, 87, 2, 2, 352, 354,
	5, 20, 11, 2, 353, 351, 3, 2, 2, 2, 354, 357, 3, 2, 2, 2, 355, 353, 3,
	2, 2, 2, 355, 356, 3, 2, 2, 2, 356, 358, 3, 2, 2, 2, 357, 355, 3, 2, 2,
	2, 358, 359, 7, 90, 2, 2, 359, 19, 3, 2, 2, 2, 360, 362, 5, 112, 57, 2,
	361, 360, 3, 2, 2, 2, 362, 365, 3, 2, 2, 2, 363, 361, 3, 2, 2, 2, 363,
	364, 3, 2, 2, 2, 364, 366, 3, 2, 2, 2, 365, 363, 3, 2, 2, 2, 366, 375,
	5, 162, 82, 2, 367, 371, 7, 19, 2, 2, 368, 370, 5, 112, 57, 2, 369, 368,
	3, 2, 2, 2, 370, 373, 3, 2, 2, 2, 371, 369, 3, 2, 2, 2, 371, 372, 3, 2,
	2, 2, 372, 374, 3, 2, 2, 2, 373, 371, 3, 2, 2, 2, 374, 376, 5, 22, 12,
	2, 375, 367, 3, 2, 2, 2, 375, 376, 3, 2, 2, 2, 376, 21, 3, 2, 2, 2, 377,
	382, 5, 238, 120, 2, 378, 379, 7, 108, 2, 2, 379, 381, 5, 238, 120, 2,
	380, 378, 3, 2, 2, 2, 381, 384, 3, 2, 2, 2, 382, 380, 3, 2, 2, 2, 382,
	383, 3, 2, 2, 2, 383, 23, 3, 2, 2, 2, 384, 382, 3, 2, 2, 2, 385, 386, 7,
	18, 2, 2, 386, 389, 5, 162, 82, 2, 387, 388, 7, 26, 2, 2, 388, 390, 5,
	236, 119, 2, 389, 387, 3, 2, 2, 2, 389, 390, 3, 2, 2, 2, 390, 391, 3, 2,
	2, 2, 391, 393, 7, 82, 2, 2, 392, 394, 5, 26, 14, 2, 393, 392, 3, 2, 2,
	2, 393, 394, 3, 2, 2, 2, 394, 396, 3, 2, 2, 2, 395, 397, 7, 87, 2, 2, 396,
	395, 3, 2, 2, 2, 396, 397, 3, 2, 2, 2, 397, 399, 3, 2, 2, 2, 398, 400,
	5, 30, 16, 2, 399, 398, 3, 2, 2, 2, 399, 400, 3, 2, 2, 2, 400, 401, 3,
	2, 2, 2, 401, 402, 7, 83, 2, 2, 402, 25, 3, 2, 2, 2, 403, 408, 5, 28, 15,
	2, 404, 405, 7, 87, 2, 2, 405, 407, 5, 28, 15, 2, 406, 404, 3, 2, 2, 2,
	407, 410, 3, 2, 2, 2, 408, 406, 3, 2, 2, 2, 408, 409, 3, 2, 2, 2, 409,
	27, 3, 2, 2, 2, 410, 408, 3, 2, 2, 2, 411, 413, 5, 112, 57, 2, 412, 411,
	3, 2, 2, 2, 413, 416, 3, 2, 2, 2, 414, 412, 3, 2, 2, 2, 414, 415, 3, 2,
	2, 2, 415, 417, 3, 2, 2, 2, 416, 414, 3, 2, 2, 2, 417, 419, 5, 162, 82,
	2, 418, 420, 5, 248, 125, 2, 419, 418, 3, 2, 2, 2, 419, 420, 3, 2, 2, 2,
	420, 422, 3, 2, 2, 2, 421, 423, 5, 34, 18, 2, 422, 421, 3, 2, 2, 2, 422,
	423, 3, 2, 2, 2, 423, 29, 3, 2, 2, 2, 424, 428, 7, 86, 2, 2, 425, 427,
	5, 38, 20, 2, 426, 425, 3, 2, 2, 2, 427, 430, 3, 2, 2, 2, 428, 426, 3,
	2, 2, 2, 428, 429, 3, 2, 2, 2, 429, 31, 3, 2, 2, 2, 430, 428, 3, 2, 2,
	2, 431, 432, 7, 30, 2, 2, 432, 434, 5, 162, 82, 2, 433, 435, 5, 18, 10,
	2, 434, 433, 3, 2, 2, 2, 434, 435, 3, 2, 2, 2, 435, 438, 3, 2, 2, 2, 436,
	437, 7, 19, 2, 2, 437, 439, 5, 236, 119, 2, 438, 436, 3, 2, 2, 2, 438,
	439, 3, 2, 2, 2, 439, 440, 3, 2, 2, 2, 440, 441, 5, 36, 19, 2, 441, 33,
	3, 2, 2, 2, 442, 446, 7, 82, 2, 2, 443, 445, 5, 38, 20, 2, 444, 443, 3,
	2, 2, 2, 445, 448, 3, 2, 2, 2, 446, 444, 3, 2, 2, 2, 446, 447, 3, 2, 2,
	2, 447, 449, 3, 2, 2, 2, 448, 446, 3, 2, 2, 2, 449, 450, 7, 83, 2, 2, 450,
	35, 3, 2, 2, 2, 451, 455, 7, 82, 2, 2, 452, 454, 5, 56, 29, 2, 453, 452,
	3, 2, 2, 2, 454, 457, 3, 2, 2, 2, 455, 453, 3, 2, 2, 2, 455, 456, 3, 2,
	2, 2, 456, 458, 3, 2, 2, 2, 457, 455, 3, 2, 2, 2, 458, 459, 7, 83, 2, 2,
	459, 37, 3, 2, 2, 2, 460, 473, 7, 86, 2, 2, 461, 463, 7, 40, 2, 2, 462,
	461, 3, 2, 2, 2, 462, 463, 3, 2, 2, 2, 463, 464, 3, 2, 2, 2, 464, 473,
	5, 156, 79, 2, 465, 467, 5, 10, 6, 2, 466, 465, 3, 2, 2, 2, 467, 470, 3,
	2, 2, 2, 468, 466, 3, 2, 2, 2, 468, 469, 3, 2, 2, 2, 469, 471, 3, 2, 2,
	2, 470, 468, 3, 2, 2, 2, 471, 473, 5, 40, 21, 2, 472, 460, 3, 2, 2, 2,
	472, 462, 3, 2, 2, 2, 472, 468, 3, 2, 2, 2, 473, 39, 3, 2, 2, 2, 474, 485,
	5, 42, 22, 2, 475, 485, 5, 48, 25, 2, 476, 485, 5, 54, 28, 2, 477, 485,
	5, 52, 27, 2, 478, 485, 5, 50, 26, 2, 479, 485, 5, 32, 17, 2, 480, 485,
	5, 122, 62, 2, 481, 485, 5, 16, 9, 2, 482, 485, 5, 24, 13, 2, 483, 485,
	5, 146, 74, 2, 484, 474, 3, 2, 2, 2, 484, 475, 3, 2, 2, 2, 484, 476, 3,
	2, 2, 2, 484, 477, 3, 2, 2, 2, 484, 478, 3, 2, 2, 2, 484, 479, 3, 2, 2,
	2, 484, 480, 3, 2, 2, 2, 484, 481, 3, 2, 2, 2, 484, 482, 3, 2, 2, 2, 484,
	483, 3, 2, 2, 2, 485, 41, 3, 2, 2, 2, 486, 487, 5, 46, 24, 2, 487, 488,
	5, 162, 82, 2, 488, 493, 5, 88, 45, 2, 489, 490, 7, 84, 2, 2, 490, 492,
	7, 85, 2, 2, 491, 489, 3, 2, 2, 2, 492, 495, 3, 2, 2, 2, 493, 491, 3, 2,
	2, 2, 493, 494, 3, 2, 2, 2, 494, 498, 3, 2, 2, 2, 495, 493, 3, 2, 2, 2,
	496, 497, 7, 47, 2, 2, 497, 499, 5, 86, 44, 2, 498, 496, 3, 2, 2, 2, 498,
	499, 3, 2, 2, 2, 499, 500, 3, 2, 2, 2, 500, 501, 5, 44, 23, 2, 501, 43,
	3, 2, 2, 2, 502, 505, 5, 156, 79, 2, 503, 505, 7, 86, 2, 2, 504, 502, 3,
	2, 2, 2, 504, 503, 3, 2, 2, 2, 505, 45, 3, 2, 2, 2, 506, 509, 5, 238, 120,
	2, 507, 509, 7, 50, 2, 2, 508, 506, 3, 2, 2, 2, 508, 507, 3, 2, 2, 2, 509,
	47, 3, 2, 2, 2, 510, 511, 5, 18, 10, 2, 511, 512, 5, 42, 22, 2, 512, 49,
	3, 2, 2, 2, 513, 514, 5, 18, 10, 2, 514, 515, 5, 52, 27, 2, 515, 51, 3,
	2, 2, 2, 516, 517, 5, 162, 82, 2, 517, 520, 5, 88, 45, 2, 518, 519, 7,
	47, 2, 2, 519, 521, 5, 86, 44, 2, 520, 518, 3, 2, 2, 2, 520, 521, 3, 2,
	2, 2, 521, 522, 3, 2, 2, 2, 522, 523, 5, 156, 79, 2, 523, 53, 3, 2, 2,
	2, 524, 525, 5, 238, 120, 2, 525, 526, 5, 72, 37, 2, 526, 527, 7, 86, 2,
	2, 527, 55, 3, 2, 2, 2, 528, 530, 5, 10, 6, 2, 529, 528, 3, 2, 2, 2, 530,
	533, 3, 2, 2, 2, 531, 529, 3, 2, 2, 2, 531, 532, 3, 2, 2, 2, 532, 534,
	3, 2, 2, 2, 533, 531, 3, 2, 2, 2, 534, 537, 5, 58, 30, 2, 535, 537, 7,
	86, 2, 2, 536, 531, 3, 2, 2, 2, 536, 535, 3, 2, 2, 2, 537, 57, 3, 2, 2,
	2, 538, 547, 5, 60, 31, 2, 539, 547, 5, 64, 33, 2, 540, 547, 5, 68, 35,
	2, 541, 547, 5, 32, 17, 2, 542, 547, 5, 122, 62, 2, 543, 547, 5, 16, 9,
	2, 544, 547, 5, 24, 13, 2, 545, 547, 5, 146, 74, 2, 546, 538, 3, 2, 2,
	2, 546, 539, 3, 2, 2, 2, 546, 540, 3, 2, 2, 2, 546, 541, 3, 2, 2, 2, 546,
	542, 3, 2, 2, 2, 546, 543, 3, 2, 2, 2, 546, 544, 3, 2, 2, 2, 546, 545,
	3, 2, 2, 2, 547, 59, 3, 2, 2, 2, 548, 549, 5, 238, 120, 2, 549, 554, 5,
	62, 32, 2, 550, 551, 7, 87, 2, 2, 551, 553, 5, 62, 32, 2, 552, 550, 3,
	2, 2, 2, 553, 556, 3, 2, 2, 2, 554, 552, 3, 2, 2, 2, 554, 555, 3, 2, 2,
	2, 555, 557, 3, 2, 2, 2, 556, 554, 3, 2, 2, 2, 557, 558, 7, 86, 2, 2, 558,
	61, 3, 2, 2, 2, 559, 564, 5, 162, 82, 2, 560, 561, 7, 84, 2, 2, 561, 563,
	7, 85, 2, 2, 562, 560, 3, 2, 2, 2, 563, 566, 3, 2, 2, 2, 564, 562, 3, 2,
	2, 2, 564, 565, 3, 2, 2, 2, 565, 567, 3, 2, 2, 2, 566, 564, 3, 2, 2, 2,
	567, 568, 7, 89, 2, 2, 568, 569, 5, 78, 40, 2, 569, 63, 3, 2, 2, 2, 570,
	572, 5, 66, 34, 2, 571, 570, 3, 2, 2, 2, 572, 575, 3, 2, 2, 2, 573, 571,
	3, 2, 2, 2, 573, 574, 3, 2, 2, 2, 574, 576, 3, 2, 2, 2, 575, 573, 3, 2,
	2, 2, 576, 577, 5, 70, 36, 2, 577, 65, 3, 2, 2, 2, 578, 585, 5, 112, 57,
	2, 579, 585, 7, 37, 2, 2, 580, 585, 7, 3, 2, 2, 581, 585, 7, 14, 2, 2,
	582, 585, 7, 40, 2, 2, 583, 585, 7, 41, 2, 2, 584, 578, 3, 2, 2, 2, 584,
	579, 3, 2, 2, 2, 584, 580, 3, 2, 2, 2, 584, 581, 3, 2, 2, 2, 584, 582,
	3, 2, 2, 2, 584, 583, 3, 2, 2, 2, 585, 67, 3, 2, 2, 2, 586, 588, 5, 66,
	34, 2, 587, 586, 3, 2, 2, 2, 588, 591, 3, 2, 2, 2, 589, 587, 3, 2, 2, 2,
	589, 590, 3, 2, 2, 2, 590, 592, 3, 2, 2, 2, 591, 589, 3, 2, 2, 2, 592,
	593, 5, 18, 10, 2, 593, 594, 5, 70, 36, 2, 594, 69, 3, 2, 2, 2, 595, 597,
	5, 112, 57, 2, 596, 595, 3, 2, 2, 2, 597, 600, 3, 2, 2, 2, 598, 596, 3,
	2, 2, 2, 598, 599, 3, 2, 2, 2, 599, 601, 3, 2, 2, 2, 600, 598, 3, 2, 2,
	2, 601, 602, 5, 46, 24, 2, 602, 603, 5, 162, 82, 2, 603, 608, 5, 88, 45,
	2, 604, 605, 7, 84, 2, 2, 605, 607, 7, 85, 2, 2, 606, 604, 3, 2, 2, 2,
	607, 610, 3, 2, 2, 2, 608, 606, 3, 2, 2, 2, 608, 609, 3, 2, 2, 2, 609,
	613, 3, 2, 2, 2, 610, 608, 3, 2, 2, 2, 611, 612, 7, 47, 2, 2, 612, 614,
	5, 86, 44, 2, 613, 611, 3, 2, 2, 2, 613, 614, 3, 2, 2, 2, 614, 615, 3,
	2, 2, 2, 615, 616, 5, 44, 23, 2, 616, 71, 3, 2, 2, 2, 617, 622, 5, 74,
	38, 2, 618, 619, 7, 87, 2, 2, 619, 621, 5, 74, 38, 2, 620, 618, 3, 2, 2,
	2, 621, 624, 3, 2, 2, 2, 622, 620, 3, 2, 2, 2, 622, 623, 3, 2, 2, 2, 623,
	73, 3, 2, 2, 2, 624, 622, 3, 2, 2, 2, 625, 628, 5, 76, 39, 2, 626, 627,
	7, 89, 2, 2, 627, 629, 5, 78, 40, 2, 628, 626, 3, 2, 2, 2, 628, 629, 3,
	2, 2, 2, 629, 75, 3, 2, 2, 2, 630, 635, 5, 162, 82, 2, 631, 632, 7, 84,
	2, 2, 632, 634, 7, 85, 2, 2, 633, 631, 3, 2, 2, 2, 634, 637, 3, 2, 2, 2,
	635, 633, 3, 2, 2, 2, 635, 636, 3, 2, 2, 2, 636, 77, 3, 2, 2, 2, 637, 635,
	3, 2, 2, 2, 638, 641, 5, 80, 41, 2, 639, 641, 5, 196, 99, 2, 640, 638,
	3, 2, 2, 2, 640, 639, 3, 2, 2, 2, 641, 79, 3, 2, 2, 2, 642, 654, 7, 82,
	2, 2, 643, 648, 5, 78, 40, 2, 644, 645, 7, 87, 2, 2, 645, 647, 5, 78, 40,
	2, 646, 644, 3, 2, 2, 2, 647, 650, 3, 2, 2, 2, 648, 646, 3, 2, 2, 2, 648,
	649, 3, 2, 2, 2, 649, 652, 3, 2, 2, 2, 650, 648, 3, 2, 2, 2, 651, 653,
	7, 87, 2, 2, 652, 651, 3, 2, 2, 2, 652, 653, 3, 2, 2, 2, 653, 655, 3, 2,
	2, 2, 654, 643, 3, 2, 2, 2, 654, 655, 3, 2, 2, 2, 655, 656, 3, 2, 2, 2,
	656, 657, 7, 83, 2, 2, 657, 81, 3, 2, 2, 2, 658, 660, 5, 162, 82, 2, 659,
	661, 5, 242, 122, 2, 660, 659, 3, 2, 2, 2, 660, 661, 3, 2, 2, 2, 661, 669,
	3, 2, 2, 2, 662, 663, 7, 88, 2, 2, 663, 665, 5, 162, 82, 2, 664, 666, 5,
	242, 122, 2, 665, 664, 3, 2, 2, 2, 665, 666, 3, 2, 2, 2, 666, 668, 3, 2,
	2, 2, 667, 662, 3, 2, 2, 2, 668, 671, 3, 2, 2, 2, 669, 667, 3, 2, 2, 2,
	669, 670, 3, 2, 2, 2, 670, 83, 3, 2, 2, 2, 671, 669, 3, 2, 2, 2, 672, 685,
	5, 238, 120, 2, 673, 675, 5, 112, 57, 2, 674, 673, 3, 2, 2, 2, 675, 678,
	3, 2, 2, 2, 676, 674, 3, 2, 2, 2, 676, 677, 3, 2, 2, 2, 677, 679, 3, 2,
	2, 2, 678, 676, 3, 2, 2, 2, 679, 682, 7, 94, 2, 2, 680, 681, 9, 2, 2, 2,
	681, 683, 5, 238, 120, 2, 682, 680, 3, 2, 2, 2, 682, 683, 3, 2, 2, 2, 683,
	685, 3, 2, 2, 2, 684, 672, 3, 2, 2, 2, 684, 676, 3, 2, 2, 2, 685, 85, 3,
	2, 2, 2, 686, 691, 5, 102, 52, 2, 687, 688, 7, 87, 2, 2, 688, 690, 5, 102,
	52, 2, 689, 687, 3, 2, 2, 2, 690, 693, 3, 2, 2, 2, 691, 689, 3, 2, 2, 2,
	691, 692, 3, 2, 2, 2, 692, 87, 3, 2, 2, 2, 693, 691, 3, 2, 2, 2, 694, 706,
	7, 80, 2, 2, 695, 697, 5, 90, 46, 2, 696, 695, 3, 2, 2, 2, 696, 697, 3,
	2, 2, 2, 697, 707, 3, 2, 2, 2, 698, 701, 5, 90, 46, 2, 699, 700, 7, 87,
	2, 2, 700, 702, 5, 92, 47, 2, 701, 699, 3, 2, 2, 2, 701, 702, 3, 2, 2,
	2, 702, 707, 3, 2, 2, 2, 703, 705, 5, 92, 47, 2, 704, 703, 3, 2, 2, 2,
	704, 705, 3, 2, 2, 2, 705, 707, 3, 2, 2, 2, 706, 696, 3, 2, 2, 2, 706,
	698, 3, 2, 2, 2, 706, 704, 3, 2, 2, 2, 707, 708, 3, 2, 2, 2, 708, 709,
	7, 81, 2, 2, 709, 89, 3, 2, 2, 2, 710, 716, 5, 238, 120, 2, 711, 712, 5,
	162, 82, 2, 712, 713, 7, 88, 2, 2, 713, 715, 3, 2, 2, 2, 714, 711, 3, 2,
	2, 2, 715, 718, 3, 2, 2, 2, 716, 714, 3, 2, 2, 2, 716, 717, 3, 2, 2, 2,
	717, 719, 3, 2, 2, 2, 718, 716, 3, 2, 2, 2, 719, 720, 7, 45, 2, 2, 720,
	91, 3, 2, 2, 2, 721, 726, 5, 94, 48, 2, 722, 723, 7, 87, 2, 2, 723, 725,
	5, 94, 48, 2, 724, 722, 3, 2, 2, 2, 725, 728, 3, 2, 2, 2, 726, 724, 3,
	2, 2, 2, 726, 727, 3, 2, 2, 2, 727, 731, 3, 2, 2, 2, 728, 726, 3, 2, 2,
	2, 729, 730, 7, 87, 2, 2, 730, 732, 5, 96, 49, 2, 731, 729, 3, 2, 2, 2,
	731, 732, 3, 2, 2, 2, 732, 735, 3, 2, 2, 2, 733, 735, 5, 96, 49, 2, 734,
	721, 3, 2, 2, 2, 734, 733, 3, 2, 2, 2, 735, 93, 3, 2, 2, 2, 736, 738, 5,
	14, 8, 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, 5, 238, 120, 2, 743, 744, 5, 76, 39, 2, 744, 95, 3, 2, 2, 2, 745,
	747, 5, 14, 8, 2, 746, 745, 3, 2, 2, 2, 747, 750, 3, 2, 2, 2, 748, 746,
	3, 2, 2, 2, 748, 749, 3, 2, 2, 2, 749, 751, 3, 2, 2, 2, 750, 748, 3, 2,
	2, 2, 751, 755, 5, 238, 120, 2, 752, 754, 5, 112, 57, 2, 753, 752, 3, 2,
	2, 2, 754, 757, 3, 2, 2, 2, 755, 753, 3, 2, 2, 2, 755, 756, 3, 2, 2, 2,
	756, 758, 3, 2, 2, 2, 757, 755, 3, 2, 2, 2, 758, 759, 7, 126, 2, 2, 759,
	760, 5, 76, 39, 2, 760, 97, 3, 2, 2, 2, 761, 766, 5, 100, 51, 2, 762, 763,
	7, 87, 2, 2, 763, 765, 5, 100, 51, 2, 764, 762, 3, 2, 2, 2, 765, 768, 3,
	2, 2, 2, 766, 764, 3, 2, 2, 2, 766, 767, 3, 2, 2, 2, 767, 99, 3, 2, 2,
	2, 768, 766, 3, 2, 2, 2, 769, 771, 5, 14, 8, 2, 770, 769, 3, 2, 2, 2, 771,
	774, 3, 2, 2, 2, 772, 770, 3, 2, 2, 2, 772, 773, 3, 2, 2, 2, 773, 775,
	3, 2, 2, 2, 774, 772, 3, 2, 2, 2, 775, 776, 7, 63, 2, 2, 776, 777, 5, 162,
	82, 2, 777, 101, 3, 2, 2, 2, 778, 783, 5, 162, 82, 2, 779, 780, 7, 88,
	2, 2, 780, 782, 5, 162, 82, 2, 781, 779, 3, 2, 2, 2, 782, 785, 3, 2, 2,
	2, 783, 781, 3, 2, 2, 2, 783, 784, 3, 2, 2, 2, 784, 103, 3, 2, 2, 2, 785,
	783, 3, 2, 2, 2, 786, 794, 5, 106, 54, 2, 787, 794, 5, 108, 55, 2, 788,
	794, 7, 76, 2, 2, 789, 794, 7, 77, 2, 2, 790, 794, 7, 75, 2, 2, 791, 794,
	7, 79, 2, 2, 792, 794, 7, 78, 2, 2, 793, 786, 3, 2, 2, 2, 793, 787, 3,
	2, 2, 2, 793, 788, 3, 2, 2, 2, 793, 789, 3, 2, 2, 2, 793, 790, 3, 2, 2,
	2, 793, 791, 3, 2, 2, 2, 793, 792, 3, 2, 2, 2, 794, 105, 3, 2, 2, 2, 795,
	796, 9, 3, 2, 2, 796, 107, 3, 2, 2, 2, 797, 798, 9, 4, 2, 2, 798, 109,
	3, 2, 2, 2, 799, 800, 5, 162, 82, 2, 800, 801, 7, 88, 2, 2, 801, 803, 3,
	2, 2, 2, 802, 799, 3, 2, 2, 2, 803, 806, 3, 2, 2, 2, 804, 802, 3, 2, 2,
	2, 804, 805, 3, 2, 2, 2, 805, 807, 3, 2, 2, 2, 806, 804, 3, 2, 2, 2, 807,
	808, 7, 125, 2, 2, 808, 809, 5, 162, 82, 2, 809, 111, 3, 2, 2, 2, 810,
	811, 7, 125, 2, 2, 811, 814, 5, 102, 52, 2, 812, 814, 5, 110, 56, 2, 813,
	810, 3, 2, 2, 2, 813, 812, 3, 2, 2, 2, 814, 821, 3, 2, 2, 2, 815, 818,
	7, 80, 2, 2, 816, 819, 5, 114, 58, 2, 817, 819, 5, 118, 60, 2, 818, 816,
	3, 2, 2, 2, 818, 817, 3, 2, 2, 2, 818, 819, 3, 2, 2, 2, 819, 820, 3, 2,
	2, 2, 820, 822, 7, 81, 2, 2, 821, 815, 3, 2, 2, 2, 821, 822, 3, 2, 2, 2,
	822, 113, 3, 2, 2, 2, 823, 828, 5, 116, 59, 2, 824, 825, 7, 87, 2, 2, 825,
	827, 5, 116, 59, 2, 826, 824, 3, 2, 2, 2, 827, 830, 3, 2, 2, 2, 828, 826,
	3, 2, 2, 2, 828, 829, 3, 2, 2, 2, 829, 115, 3, 2, 2, 2, 830, 828, 3, 2,
	2, 2, 831, 832, 5, 162, 82, 2, 832, 833, 7, 89, 2, 2, 833, 834, 5, 118,
	60, 2, 834, 117, 3, 2, 2, 2, 835, 839, 5, 196, 99, 2, 836, 839, 5, 112,
	57, 2, 837, 839, 5, 120, 61, 2, 838, 835, 3, 2, 2, 2, 838, 836, 3, 2, 2,
	2, 838, 837, 3, 2, 2, 2, 839, 119, 3, 2, 2, 2, 840, 849, 7, 82, 2, 2, 841,
	846, 5, 118, 60, 2, 842, 843, 7, 87, 2, 2, 843, 845, 5, 118, 60, 2, 844,
	842, 3, 2, 2, 2, 845, 848, 3, 2, 2, 2, 846, 844, 3, 2, 2, 2, 846, 847,
	3, 2, 2, 2, 847, 850, 3, 2, 2, 2, 848, 846, 3, 2, 2, 2, 849, 841, 3, 2,
	2, 2, 849, 850, 3, 2, 2, 2, 850, 852, 3, 2, 2, 2, 851, 853, 7, 87, 2, 2,
	852, 851, 3, 2, 2, 2, 852, 853, 3, 2, 2, 2, 853, 854, 3, 2, 2, 2, 854,
	855, 7, 83, 2, 2, 855, 121, 3, 2, 2, 2, 856, 857, 7, 125, 2, 2, 857, 858,
	7, 30, 2, 2, 858, 859, 5, 162, 82, 2, 859, 860, 5, 124, 63, 2, 860, 123,
	3, 2, 2, 2, 861, 865, 7, 82, 2, 2, 862, 864, 5, 126, 64, 2, 863, 862, 3,
	2, 2, 2, 864, 867, 3, 2, 2, 2, 865, 863, 3, 2, 2, 2, 865, 866, 3, 2, 2,
	2, 866, 868, 3, 2, 2, 2, 867, 865, 3, 2, 2, 2, 868, 869, 7, 83, 2, 2, 869,
	125, 3, 2, 2, 2, 870, 872, 5, 10, 6, 2, 871, 870, 3, 2, 2, 2, 872, 875,
	3, 2, 2, 2, 873, 871, 3, 2, 2, 2, 873, 874, 3, 2, 2, 2, 874, 876, 3, 2,
	2, 2, 875, 873, 3, 2, 2, 2, 876, 879, 5, 128, 65, 2, 877, 879, 7, 86, 2,
	2, 878, 873, 3, 2, 2, 2, 878, 877, 3, 2, 2, 2, 879, 127, 3, 2, 2, 2, 880,
	881, 5, 238, 120, 2, 881, 882, 5, 130, 66, 2, 882, 883, 7, 86, 2, 2, 883,
	905, 3, 2, 2, 2, 884, 886, 5, 16, 9, 2, 885, 887, 7, 86, 2, 2, 886, 885,
	3, 2, 2, 2, 886, 887, 3, 2, 2, 2, 887, 905, 3, 2, 2, 2, 888, 890, 5, 32,
	17, 2, 889, 891, 7, 86, 2, 2, 890, 889, 3, 2, 2, 2, 890, 891, 3, 2, 2,
	2, 891, 905, 3, 2, 2, 2, 892, 894, 5, 24, 13, 2, 893, 895, 7, 86, 2, 2,
	894, 893, 3, 2, 2, 2, 894, 895, 3, 2, 2, 2, 895, 905, 3, 2, 2, 2, 896,
	898, 5, 122, 62, 2, 897, 899, 7, 86, 2, 2, 898, 897, 3, 2, 2, 2, 898, 899,
	3, 2, 2, 2, 899, 905, 3, 2, 2, 2, 900, 902, 5, 146, 74, 2, 901, 903, 7,
	86, 2, 2, 902, 901, 3, 2, 2, 2, 902, 903, 3, 2, 2, 2, 903, 905, 3, 2, 2,
	2, 904, 880, 3, 2, 2, 2, 904, 884, 3, 2, 2, 2, 904, 888, 3, 2, 2, 2, 904,
	892, 3, 2, 2, 2, 904, 896, 3, 2, 2, 2, 904, 900, 3, 2, 2, 2, 905, 129,
	3, 2, 2, 2, 906, 909, 5, 132, 67, 2, 907, 909, 5, 134, 68, 2, 908, 906,
	3, 2, 2, 2, 908, 907, 3, 2, 2, 2, 909, 131, 3, 2, 2, 2, 910, 911, 5, 162,
	82, 2, 911, 912, 7, 80, 2, 2, 912, 914, 7, 81, 2, 2, 913, 915, 5, 136,
	69, 2, 914, 913, 3, 2, 2, 2, 914, 915, 3, 2, 2, 2, 915, 133, 3, 2, 2, 2,
	916, 917, 5, 72, 37, 2, 917, 135, 3, 2, 2, 2, 918, 919, 7, 14, 2, 2, 919,
	920, 5, 118, 60, 2, 920, 137, 3, 2, 2, 2, 921, 923, 7, 54, 2, 2, 922, 921,
	3, 2, 2, 2, 922, 923, 3, 2, 2, 2, 923, 924, 3, 2, 2, 2, 924, 925, 7, 53,
	2, 2, 925, 926, 5, 102, 52, 2, 926, 927, 5, 140, 71, 2, 927, 139, 3, 2,
	2, 2, 928, 932, 7, 82, 2, 2, 929, 931, 5, 142, 72, 2, 930, 929, 3, 2, 2,
	2, 931, 934, 3, 2, 2, 2, 932, 930, 3, 2, 2, 2, 932, 933, 3, 2, 2, 2, 933,
	935, 3, 2, 2, 2, 934, 932, 3, 2, 2, 2, 935, 936, 7, 83, 2, 2, 936, 141,
	3, 2, 2, 2, 937, 941, 7, 55, 2, 2, 938, 940, 5, 144, 73, 2, 939, 938, 3,
	2, 2, 2, 940, 943, 3, 2, 2, 2, 941, 939, 3, 2, 2, 2, 941, 942, 3, 2, 2,
	2, 942, 944, 3, 2, 2, 2, 943, 941, 3, 2, 2, 2, 944, 945, 5, 102, 52, 2,
	945, 946, 7, 86, 2, 2, 946, 974, 3, 2, 2, 2, 947, 948, 7, 56, 2, 2, 948,
	951, 5, 102, 52, 2, 949, 950, 7, 58, 2, 2, 950, 952, 5, 102, 52, 2, 951,
	949, 3, 2, 2, 2, 951, 952, 3, 2, 2, 2, 952, 953, 3, 2, 2, 2, 953, 954,
	7, 86, 2, 2, 954, 974, 3, 2, 2, 2, 955, 956, 7, 57, 2, 2, 956, 959, 5,
	102, 52, 2, 957, 958, 7, 58, 2, 2, 958, 960, 5, 102, 52, 2, 959, 957, 3,
	2, 2, 2, 959, 960, 3, 2, 2, 2, 960, 961, 3, 2, 2, 2, 961, 962, 7, 86, 2,
	2, 962, 974, 3, 2, 2, 2, 963, 964, 7, 59, 2, 2, 964, 965, 5, 102, 52, 2,
	965, 966, 7, 86, 2, 2, 966, 974, 3, 2, 2, 2, 967, 968, 7, 60, 2, 2, 968,
	969, 5, 102, 52, 2, 969, 970, 7, 61, 2, 2, 970, 971, 5, 102, 52, 2, 971,
	972, 7, 86, 2, 2, 972, 974, 3, 2, 2, 2, 973, 937, 3, 2, 2, 2, 973, 947,
	3, 2, 2, 2, 973, 955, 3, 2, 2, 2, 973, 963, 3, 2, 2, 2, 973, 967, 3, 2,
	2, 2, 974, 143, 3, 2, 2, 2, 975, 976, 9, 5, 2, 2, 976, 145, 3, 2, 2, 2,
	977, 978, 7, 65, 2, 2, 978, 980, 5, 162, 82, 2, 979, 981, 5, 18, 10, 2,
	980, 979, 3, 2, 2, 2, 980, 981, 3, 2, 2, 2, 981, 982, 3, 2, 2, 2, 982,
	985, 5, 148, 75, 2, 983, 984, 7, 26, 2, 2, 984, 986, 5, 236, 119, 2, 985,
	983, 3, 2, 2, 2, 985, 986, 3, 2, 2, 2, 986, 987, 3, 2, 2, 2, 987, 988,
	5, 154, 78, 2, 988, 147, 3, 2, 2, 2, 989, 991, 7, 80, 2, 2, 990, 992, 5,
	150, 76, 2, 991, 990, 3, 2, 2, 2, 991, 992, 3, 2, 2, 2, 992, 993, 3, 2,
	2, 2, 993, 994, 7, 81, 2, 2, 994, 149, 3, 2, 2, 2, 995, 1000, 5, 152, 77,
	2, 996, 997, 7, 87, 2, 2, 997, 999, 5, 152, 77, 2, 998, 996, 3, 2, 2, 2,
	999, 1002, 3, 2, 2, 2, 1000, 998, 3, 2, 2, 2, 1000, 1001, 3, 2, 2, 2, 1001,
	151, 3, 2, 2, 2, 1002, 1000, 3, 2, 2, 2, 1003, 1004, 5, 238, 120, 2, 1004,
	1005, 5, 162, 82, 2, 1005, 153, 3, 2, 2, 2, 1006, 1010, 7, 82, 2, 2, 1007,
	1009, 5, 38, 20, 2, 1008, 1007, 3, 2, 2, 2, 1009, 1012, 3, 2, 2, 2, 1010,
	1008, 3, 2, 2, 2, 1010, 1011, 3, 2, 2, 2, 1011, 1013, 3, 2, 2, 2, 1012,
	1010, 3, 2, 2, 2, 1013, 1014, 7, 83, 2, 2, 1014, 155, 3, 2, 2, 2, 1015,
	1019, 7, 82, 2, 2, 1016, 1018, 5, 158, 80, 2, 1017, 1016, 3, 2, 2, 2, 1018,
	1021, 3, 2, 2, 2, 1019, 1017, 3, 2, 2, 2, 1019, 1020, 3, 2, 2, 2, 1020,
	1022, 3, 2, 2, 2, 1021, 1019, 3, 2, 2, 2, 1022, 1023, 7, 83, 2, 2, 1023,
	157, 3, 2, 2, 2, 1024, 1025, 5, 160, 81, 2, 1025, 1026, 7, 86, 2, 2, 1026,
	1030, 3, 2, 2, 2, 1027, 1030, 5, 166, 84, 2, 1028, 1030, 5, 164, 83, 2,
	1029, 1024, 3, 2, 2, 2, 1029, 1027, 3, 2, 2, 2, 1029, 1028, 3, 2, 2, 2,
	1030, 159, 3, 2, 2, 2, 1031, 1033, 5, 14, 8, 2, 1032, 1031, 3, 2, 2, 2,
	1033, 1036, 3, 2, 2, 2, 1034, 1032, 3, 2, 2, 2, 1034, 1035, 3, 2, 2, 2,
	1035, 1045, 3, 2, 2, 2, 1036, 1034, 3, 2, 2, 2, 1037, 1038, 5, 238, 120,
	2, 1038, 1039, 5, 72, 37, 2, 1039, 1046, 3, 2, 2, 2, 1040, 1041, 7, 63,
	2, 2, 1041, 1042, 5, 162, 82, 2, 1042, 1043, 7, 89, 2, 2, 1043, 1044, 5,
	196, 99, 2, 1044, 1046, 3, 2, 2, 2, 1045, 1037, 3, 2, 2, 2, 1045, 1040,
	3, 2, 2, 2, 1046, 161, 3, 2, 2, 2, 1047, 1048, 9, 6, 2, 2, 1048, 163, 3,
	2, 2, 2, 1049, 1051, 5, 12, 7, 2, 1050, 1049, 3, 2, 2, 2, 1051, 1054, 3,
	2, 2, 2, 1052, 1050, 3, 2, 2, 2, 1052, 1053, 3, 2, 2, 2, 1053, 1058, 3,
	2, 2, 2, 1054, 1052, 3, 2, 2, 2, 1055, 1059, 5, 16, 9, 2, 1056, 1059, 5,
	32, 17, 2, 1057, 1059, 5, 146, 74, 2, 1058, 1055, 3, 2, 2, 2, 1058, 1056,
	3, 2, 2, 2, 1058, 1057, 3, 2, 2, 2, 1059, 1062, 3, 2, 2, 2, 1060, 1062,
	7, 86, 2, 2, 1061, 1052, 3, 2, 2, 2, 1061, 1060, 3, 2, 2, 2, 1062, 165,
	3, 2, 2, 2, 1063, 1177, 5, 156, 79, 2, 1064, 1065, 7, 4, 2, 2, 1065, 1068,
	5, 196, 99, 2, 1066, 1067, 7, 95, 2, 2, 1067, 1069, 5, 196, 99, 2, 1068,
	1066, 3, 2, 2, 2, 1068, 1069, 3, 2, 2, 2, 1069, 1070, 3, 2, 2, 2, 1070,
	1071, 7, 86, 2, 2, 1071, 1177, 3, 2, 2, 2, 1072, 1073, 7, 24, 2, 2, 1073,
	1074, 5, 190, 96, 2, 1074, 1077, 5, 166, 84, 2, 1075, 1076, 7, 17, 2, 2,
	1076, 1078, 5, 166, 84, 2, 1077, 1075, 3, 2, 2, 2, 1077, 1078, 3, 2, 2,
	2, 1078, 1177, 3, 2, 2, 2, 1079, 1080, 7, 23, 2, 2, 1080, 1081, 7, 80,
	2, 2, 1081, 1082, 5, 184, 93, 2, 1082, 1083, 7, 81, 2, 2, 1083, 1084, 5,
	166, 84, 2, 1084, 1177, 3, 2, 2, 2, 1085, 1086, 7, 52, 2, 2, 1086, 1087,
	5, 190, 96, 2, 1087, 1088, 5, 166, 84, 2, 1088, 1177, 3, 2, 2, 2, 1089,
	1090, 7, 15, 2, 2, 1090, 1091, 5, 166, 84, 2, 1091, 1092, 7, 52, 2, 2,
	1092, 1093, 5, 190, 96, 2, 1093, 1094, 7, 86, 2, 2, 1094, 1177, 3, 2, 2,
	2, 1095, 1096, 7, 49, 2, 2, 1096, 1106, 5, 156, 79, 2, 1097, 1099, 5, 168,
	85, 2, 1098, 1097, 3, 2, 2, 2, 1099, 1100, 3, 2, 2, 2, 1100, 1098, 3, 2,
	2, 2, 1100, 1101, 3, 2, 2, 2, 1101, 1103, 3, 2, 2, 2, 1102, 1104, 5, 172,
	87, 2, 1103, 1102, 3, 2, 2, 2, 1103, 1104, 3, 2, 2, 2, 1104, 1107, 3, 2,
	2, 2, 1105, 1107, 5, 172, 87, 2, 1106, 1098, 3, 2, 2, 2, 1106, 1105, 3,
	2, 2, 2, 1107, 1177, 3, 2, 2, 2, 1108, 1109, 7, 49, 2, 2, 1109, 1110, 5,
	174, 88, 2, 1110, 1114, 5, 156, 79, 2, 1111, 1113, 5, 168, 85, 2, 1112,
	1111, 3, 2, 2, 2, 1113, 1116, 3, 2, 2, 2, 1114, 1112, 3, 2, 2, 2, 1114,
	1115, 3, 2, 2, 2, 1115, 1118, 3, 2, 2, 2, 1116, 1114, 3, 2, 2, 2, 1117,
	1119, 5, 172, 87, 2, 1118, 1117, 3, 2, 2, 2, 1118, 1119, 3, 2, 2, 2, 1119,
	1177, 3, 2, 2, 2, 1120, 1121, 7, 43, 2, 2, 1121, 1122, 5, 190, 96, 2, 1122,
	1126, 7, 82, 2, 2, 1123, 1125, 5, 180, 91, 2, 1124, 1123, 3, 2, 2, 2, 1125,
	1128, 3, 2, 2, 2, 1126, 1124, 3, 2, 2, 2, 1126, 1127, 3, 2, 2, 2, 1127,
	1132, 3, 2, 2, 2, 1128, 1126, 3, 2, 2, 2, 1129, 1131, 5, 182, 92, 2, 1130,
	1129, 3, 2, 2, 2, 1131, 1134, 3, 2, 2, 2, 1132, 1130, 3, 2, 2, 2, 1132,
	1133, 3, 2, 2, 2, 1133, 1135, 3, 2, 2, 2, 1134, 1132, 3, 2, 2, 2, 1135,
	1136, 7, 83, 2, 2, 1136, 1177, 3, 2, 2, 2, 1137, 1138, 7, 44, 2, 2, 1138,
	1139, 5, 190, 96, 2, 1139, 1140, 5, 156, 79, 2, 1140, 1177, 3, 2, 2, 2,
	1141, 1143, 7, 38, 2, 2, 1142, 1144, 5, 196, 99, 2, 1143, 1142, 3, 2, 2,
	2, 1143, 1144, 3, 2, 2, 2, 1144, 1145, 3, 2, 2, 2, 1145, 1177, 7, 86, 2,
	2, 1146, 1147, 7, 46, 2, 2, 1147, 1148, 5, 196, 99, 2, 1148, 1149, 7, 86,
	2, 2, 1149, 1177, 3, 2, 2, 2, 1150, 1152, 7, 6, 2, 2, 1151, 1153, 5, 162,
	82, 2, 1152, 1151, 3, 2, 2, 2, 1152, 1153, 3, 2, 2, 2, 1153, 1154, 3, 2,
	2, 2, 1154, 1177, 7, 86, 2, 2, 1155, 1157, 7, 13, 2, 2, 1156, 1158, 5,
	162, 82, 2, 1157, 1156, 3, 2, 2, 2, 1157, 1158, 3, 2, 2, 2, 1158, 1159,
	3, 2, 2, 2, 1159, 1177, 7, 86, 2, 2, 1160, 1161, 7, 64, 2, 2, 1161, 1162,
	5, 196, 99, 2, 1162, 1163, 7, 86, 2, 2, 1163, 1177, 3, 2, 2, 2, 1164, 1177,
	7, 86, 2, 2, 1165, 1166, 5, 196, 99, 2, 1166, 1167, 7, 86, 2, 2, 1167,
	1177, 3, 2, 2, 2, 1168, 1170, 5, 208, 105, 2, 1169, 1171, 7, 86, 2, 2,
	1170, 1169, 3, 2, 2, 2, 1170, 1171, 3, 2, 2, 2, 1171, 1177, 3, 2, 2, 2,
	1172, 1173, 5, 162, 82, 2, 1173, 1174, 7, 95, 2, 2, 1174, 1175, 5, 166,
	84, 2, 1175, 1177, 3, 2, 2, 2, 1176, 1063, 3, 2, 2, 2, 1176, 1064, 3, 2,
	2, 2, 1176, 1072, 3, 2, 2, 2, 1176, 1079, 3, 2, 2, 2, 1176, 1085, 3, 2,
	2, 2, 1176, 1089, 3, 2, 2, 2, 1176, 1095, 3, 2, 2, 2, 1176, 1108, 3, 2,
	2, 2, 1176, 1120, 3, 2, 2, 2, 1176, 1137, 3, 2, 2, 2, 1176, 1141, 3, 2,
	2, 2, 1176, 1146, 3, 2, 2, 2, 1176, 1150, 3, 2, 2, 2, 1176, 1155, 3, 2,
	2, 2, 1176, 1160, 3, 2, 2, 2, 1176, 1164, 3, 2, 2, 2, 1176, 1165, 3, 2,
	2, 2, 1176, 1168, 3, 2, 2, 2, 1176, 1172, 3, 2, 2, 2, 1177, 167, 3, 2,
	2, 2, 1178, 1179, 7, 9, 2, 2, 1179, 1183, 7, 80, 2, 2, 1180, 1182, 5, 14,
	8, 2, 1181, 1180, 3, 2, 2, 2, 1182, 1185, 3, 2, 2, 2, 1183, 1181, 3, 2,
	2, 2, 1183, 1184, 3, 2, 2, 2, 1184, 1186, 3, 2, 2, 2, 1185, 1183, 3, 2,
	2, 2, 1186, 1187, 5, 170, 86, 2, 1187, 1188, 5, 162, 82, 2, 1188, 1189,
	7, 81, 2, 2, 1189, 1190, 5, 156, 79, 2, 1190, 169, 3, 2, 2, 2, 1191, 1196,
	5, 102, 52, 2, 1192, 1193, 7, 109, 2, 2, 1193, 1195, 5, 102, 52, 2, 1194,
	1192, 3, 2, 2, 2, 1195, 1198, 3, 2, 2, 2, 1196, 1194, 3, 2, 2, 2, 1196,
	1197, 3, 2, 2, 2, 1197, 171, 3, 2, 2, 2, 1198, 1196, 3, 2, 2, 2, 1199,
	1200, 7, 21, 2, 2, 1200, 1201, 5, 156, 79, 2, 1201, 173, 3, 2, 2, 2, 1202,
	1203, 7, 80, 2, 2, 1203, 1205, 5, 176, 89, 2, 1204, 1206, 7, 86, 2, 2,
	1205, 1204, 3, 2, 2, 2, 1205, 1206, 3, 2, 2, 2, 1206, 1207, 3, 2, 2, 2,
	1207, 1208, 7, 81, 2, 2, 1208, 175, 3, 2, 2, 2, 1209, 1214, 5, 178, 90,
	2, 1210, 1211, 7, 86, 2, 2, 1211, 1213, 5, 178, 90, 2, 1212, 1210, 3, 2,
	2, 2, 1213, 1216, 3, 2, 2, 2, 1214, 1212, 3, 2, 2, 2, 1214, 1215, 3, 2,
	2, 2, 1215, 177, 3, 2, 2, 2, 1216, 1214, 3, 2, 2, 2, 1217, 1219, 5, 14,
	8, 2, 1218, 1217, 3, 2, 2, 2, 1219, 1222, 3, 2, 2, 2, 1220, 1218, 3, 2,
	2, 2, 1220, 1221, 3, 2, 2, 2, 1221, 1228, 3, 2, 2, 2, 1222, 1220, 3, 2,
	2, 2, 1223, 1224, 5, 82, 42, 2, 1224, 1225, 5, 76, 39, 2, 1225, 1229, 3,
	2, 2, 2, 1226, 1227, 7, 63, 2, 2, 1227, 1229, 5, 162, 82, 2, 1228, 1223,
	3, 2, 2, 2, 1228, 1226, 3, 2, 2, 2, 1229, 1230, 3, 2, 2, 2, 1230, 1231,
	7, 89, 2, 2, 1231, 1232, 5, 196, 99, 2, 1232, 1235, 3, 2, 2, 2, 1233, 1235,
	5, 162, 82, 2, 1234, 1220, 3, 2, 2, 2, 1234, 1233, 3, 2, 2, 2, 1235, 179,
	3, 2, 2, 2, 1236, 1238, 5, 182, 92, 2, 1237, 1236, 3, 2, 2, 2, 1238, 1239,
	3, 2, 2, 2, 1239, 1237, 3, 2, 2, 2, 1239, 1240, 3, 2, 2, 2, 1240, 1242,
	3, 2, 2, 2, 1241, 1243, 5, 158, 80, 2, 1242, 1241, 3, 2, 2, 2, 1243, 1244,
	3, 2, 2, 2, 1244, 1242, 3, 2, 2, 2, 1244, 1245, 3, 2, 2, 2, 1245, 181,
	3, 2, 2, 2, 1246, 1252, 7, 8, 2, 2, 1247, 1253, 5, 196, 99, 2, 1248, 1253,
	7, 130, 2, 2, 1249, 1250, 5, 238, 120, 2, 1250, 1251, 5, 162, 82, 2, 1251,
	1253, 3, 2, 2, 2, 1252, 1247, 3, 2, 2, 2, 1252, 1248, 3, 2, 2, 2, 1252,
	1249, 3, 2, 2, 2, 1253, 1254, 3, 2, 2, 2, 1254, 1258, 7, 95, 2, 2, 1255,
	1256, 7, 14, 2, 2, 1256, 1258, 7, 95, 2, 2, 1257, 1246, 3, 2, 2, 2, 1257,
	1255, 3, 2, 2, 2, 1258, 183, 3, 2, 2, 2, 1259, 1272, 5, 188, 95, 2, 1260,
	1262, 5, 186, 94, 2, 1261, 1260, 3, 2, 2, 2, 1261, 1262, 3, 2, 2, 2, 1262,
	1263, 3, 2, 2, 2, 1263, 1265, 7, 86, 2, 2, 1264, 1266, 5, 196, 99, 2, 1265,
	1264, 3, 2, 2, 2, 1265, 1266, 3, 2, 2, 2, 1266, 1267, 3, 2, 2, 2, 1267,
	1269, 7, 86, 2, 2, 1268, 1270, 5, 192, 97, 2, 1269, 1268, 3, 2, 2, 2, 1269,
	1270, 3, 2, 2, 2, 1270, 1272, 3, 2, 2, 2, 1271, 1259, 3, 2, 2, 2, 1271,
	1261, 3, 2, 2, 2, 1272, 185, 3, 2, 2, 2, 1273, 1276, 5, 160, 81, 2, 1274,
	1276, 5, 192, 97, 2, 1275, 1273, 3, 2, 2, 2, 1275, 1274, 3, 2, 2, 2, 1276,
	187, 3, 2, 2, 2, 1277, 1279, 5, 14, 8, 2, 1278, 1277, 3, 2, 2, 2, 1279,
	1282, 3, 2, 2, 2, 1280, 1278, 3, 2, 2, 2, 1280, 1281, 3, 2, 2, 2, 1281,
	1285, 3, 2, 2, 2, 1282, 1280, 3, 2, 2, 2, 1283, 1286, 5, 238, 120, 2, 1284,
	1286, 7, 63, 2, 2, 1285, 1283, 3, 2, 2, 2, 1285, 1284, 3, 2, 2, 2, 1286,
	1287, 3, 2, 2, 2, 1287, 1288, 5, 76, 39, 2, 1288, 1289, 7, 95, 2, 2, 1289,
	1290, 5, 196, 99, 2, 1290, 189, 3, 2, 2, 2, 1291, 1292, 7, 80, 2, 2, 1292,
	1293, 5, 196, 99, 2, 1293, 1294, 7, 81, 2, 2, 1294, 191, 3, 2, 2, 2, 1295,
	1300, 5, 196, 99, 2, 1296, 1297, 7, 87, 2, 2, 1297, 1299, 5, 196, 99, 2,
	1298, 1296, 3, 2, 2, 2, 1299, 1302, 3, 2, 2, 2, 1300, 1298, 3, 2, 2, 2,
	1300, 1301, 3, 2, 2, 2, 1301, 193, 3, 2, 2, 2, 1302, 1300, 3, 2, 2, 2,
	1303, 1304, 5, 162, 82, 2, 1304, 1306, 7, 80, 2, 2, 1305, 1307, 5, 192,
	97, 2, 1306, 1305, 3, 2, 2, 2, 1306, 1307, 3, 2, 2, 2, 1307, 1308, 3, 2,
	2, 2, 1308, 1309, 7, 81, 2, 2, 1309, 1323, 3, 2, 2, 2, 1310, 1311, 7, 45,
	2, 2, 1311, 1313, 7, 80, 2, 2, 1312, 1314, 5, 192, 97, 2, 1313, 1312, 3,
	2, 2, 2, 1313, 1314, 3, 2, 2, 2, 1314, 1315, 3, 2, 2, 2, 1315, 1323, 7,
	81, 2, 2, 1316, 1317, 7, 42, 2, 2, 1317, 1319, 7, 80, 2, 2, 1318, 1320,
	5, 192, 97, 2, 1319, 1318, 3, 2, 2, 2, 1319, 1320, 3, 2, 2, 2, 1320, 1321,
	3, 2, 2, 2, 1321, 1323, 7, 81, 2, 2, 1322, 1303, 3, 2, 2, 2, 1322, 1310,
	3, 2, 2, 2, 1322, 1316, 3, 2, 2, 2, 1323, 195, 3, 2, 2, 2, 1324, 1325,
	8, 99, 1, 2, 1325, 1370, 5, 206, 104, 2, 1326, 1370, 5, 194, 98, 2, 1327,
	1328, 7, 33, 2, 2, 1328, 1370, 5, 218, 110, 2, 1329, 1333, 7, 80, 2, 2,
	1330, 1332, 5, 112, 57, 2, 1331, 1330, 3, 2, 2, 2, 1332, 1335, 3, 2, 2,
	2, 1333, 1331, 3, 2, 2, 2, 1333, 1334, 3, 2, 2, 2, 1334, 1336, 3, 2, 2,
	2, 1335, 1333, 3, 2, 2, 2, 1336, 1341, 5, 238, 120, 2, 1337, 1338, 7, 108,
	2, 2, 1338, 1340, 5, 238, 120, 2, 1339, 1337, 3, 2, 2, 2, 1340, 1343, 3,
	2, 2, 2, 1341, 1339, 3, 2, 2, 2, 1341, 1342, 3, 2, 2, 2, 1342, 1344, 3,
	2, 2, 2, 1343, 1341, 3, 2, 2, 2, 1344, 1345, 7, 81, 2, 2, 1345, 1346, 5,
	196, 99, 24, 1346, 1370, 3, 2, 2, 2, 1347, 1348, 9, 7, 2, 2, 1348, 1370,
	5, 196, 99, 22, 1349, 1350, 9, 8, 2, 2, 1350, 1370, 5, 196, 99, 21, 1351,
	1370, 5, 200, 101, 2, 1352, 1370, 5, 208, 105, 2, 1353, 1354, 5, 238, 120,
	2, 1354, 1360, 7, 124, 2, 2, 1355, 1357, 5, 242, 122, 2, 1356, 1355, 3,
	2, 2, 2, 1356, 1357, 3, 2, 2, 2, 1357, 1358, 3, 2, 2, 2, 1358, 1361, 5,
	162, 82, 2, 1359, 1361, 7, 33, 2, 2, 1360, 1356, 3, 2, 2, 2, 1360, 1359,
	3, 2, 2, 2, 1361, 1370, 3, 2, 2, 2, 1362, 1363, 5, 216, 109, 2, 1363, 1365,
	7, 124, 2, 2, 1364, 1366, 5, 242, 122, 2, 1365, 1364, 3, 2, 2, 2, 1365,
	1366, 3, 2, 2, 2, 1366, 1367, 3, 2, 2, 2, 1367, 1368, 7, 33, 2, 2, 1368,
	1370, 3, 2, 2, 2, 1369, 1324, 3, 2, 2, 2, 1369, 1326, 3, 2, 2, 2, 1369,
	1327, 3, 2, 2, 2, 1369, 1329, 3, 2, 2, 2, 1369, 1347, 3, 2, 2, 2, 1369,
	1349, 3, 2, 2, 2, 1369, 1351, 3, 2, 2, 2, 1369, 1352, 3, 2, 2, 2, 1369,
	1353, 3, 2, 2, 2, 1369, 1362, 3, 2, 2, 2, 1370, 1454, 3, 2, 2, 2, 1371,
	1372, 12, 20, 2, 2, 1372, 1373, 9, 9, 2, 2, 1373, 1453, 5, 196, 99, 21,
	1374, 1375, 12, 19, 2, 2, 1375, 1376, 9, 10, 2, 2, 1376, 1453, 5, 196,
	99, 20, 1377, 1385, 12, 18, 2, 2, 1378, 1379, 7, 91, 2, 2, 1379, 1386,
	7, 91, 2, 2, 1380, 1381, 7, 90, 2, 2, 1381, 1382, 7, 90, 2, 2, 1382, 1386,
	7, 90, 2, 2, 1383, 1384, 7, 90, 2, 2, 1384, 1386, 7, 90, 2, 2, 1385, 1378,
	3, 2, 2, 2, 1385, 1380, 3, 2, 2, 2, 1385, 1383, 3, 2, 2, 2, 1386, 1387,
	3, 2, 2, 2, 1387, 1453, 5, 196, 99, 19, 1388, 1389, 12, 17, 2, 2, 1389,
	1390, 9, 11, 2, 2, 1390, 1453, 5, 196, 99, 18, 1391, 1392, 12, 15, 2, 2,
	1392, 1393, 9, 12, 2, 2, 1393, 1453, 5, 196, 99, 16, 1394, 1395, 12, 14,
	2, 2, 1395, 1396, 7, 108, 2, 2, 1396, 1453, 5, 196, 99, 15, 1397, 1398,
	12, 13, 2, 2, 1398, 1399, 7, 110, 2, 2, 1399, 1453, 5, 196, 99, 14, 1400,
	1401, 12, 12, 2, 2, 1401, 1402, 7, 109, 2, 2, 1402, 1453, 5, 196, 99, 13,
	1403, 1404, 12, 11, 2, 2, 1404, 1405, 7, 100, 2, 2, 1405, 1453, 5, 196,
	99, 12, 1406, 1407, 12, 10, 2, 2, 1407, 1408, 7, 101, 2, 2, 1408, 1453,
	5, 196, 99, 11, 1409, 1410, 12, 9, 2, 2, 1410, 1411, 7, 94, 2, 2, 1411,
	1412, 5, 196, 99, 2, 1412, 1413, 7, 95, 2, 2, 1413, 1414, 5, 196, 99, 9,
	1414, 1453, 3, 2, 2, 2, 1415, 1416, 12, 8, 2, 2, 1416, 1417, 9, 13, 2,
	2, 1417, 1453, 5, 196, 99, 8, 1418, 1419, 12, 28, 2, 2, 1419, 1431, 7,
	88, 2, 2, 1420, 1432, 5, 162, 82, 2, 1421, 1432, 5, 194, 98, 2, 1422, 1432,
	7, 45, 2, 2, 1423, 1425, 7, 33, 2, 2, 1424, 1426, 5, 234, 118, 2, 1425,
	1424, 3, 2, 2, 2, 1425, 1426, 3, 2, 2, 2, 1426, 1427, 3, 2, 2, 2, 1427,
	1432, 5, 222, 112, 2, 1428, 1429, 7, 42, 2, 2, 1429, 1432, 5, 244, 123,
	2, 1430, 1432, 5, 228, 115, 2, 1431, 1420, 3, 2, 2, 2, 1431, 1421, 3, 2,
	2, 2, 1431, 1422, 3, 2, 2, 2, 1431, 1423, 3, 2, 2, 2, 1431, 1428, 3, 2,
	2, 2, 1431, 1430, 3, 2, 2, 2, 1432, 1453, 3, 2, 2, 2, 1433, 1434, 12, 27,
	2, 2, 1434, 1435, 7, 84, 2, 2, 1435, 1436, 5, 196, 99, 2, 1436, 1437, 7,
	85, 2, 2, 1437, 1453, 3, 2, 2, 2, 1438, 1439, 12, 23, 2, 2, 1439, 1453,
	9, 14, 2, 2, 1440, 1441, 12, 16, 2, 2, 1441, 1444, 7, 28, 2, 2, 1442, 1445,
	5, 238, 120, 2, 1443, 1445, 5, 198, 100, 2, 1444, 1442, 3, 2, 2, 2, 1444,
	1443, 3, 2, 2, 2, 1445, 1453, 3, 2, 2, 2, 1446, 1447, 12, 5, 2, 2, 1447,
	1449, 7, 124, 2, 2, 1448, 1450, 5, 242, 122, 2, 1449, 1448, 3, 2, 2, 2,
	1449, 1450, 3, 2, 2, 2, 1450, 1451, 3, 2, 2, 2, 1451, 1453, 5, 162, 82,
	2, 1452, 1371, 3, 2, 2, 2, 1452, 1374, 3, 2, 2, 2, 1452, 1377, 3, 2, 2,
	2, 1452, 1388, 3, 2, 2, 2, 1452, 1391, 3, 2, 2, 2, 1452, 1394, 3, 2, 2,
	2, 1452, 1397, 3, 2, 2, 2, 1452, 1400, 3, 2, 2, 2, 1452, 1403, 3, 2, 2,
	2, 1452, 1406, 3, 2, 2, 2, 1452, 1409, 3, 2, 2, 2, 1452, 1415, 3, 2, 2,
	2, 1452, 1418, 3, 2, 2, 2, 1452, 1433, 3, 2, 2, 2, 1452, 1438, 3, 2, 2,
	2, 1452, 1440, 3, 2, 2, 2, 1452, 1446, 3, 2, 2, 2, 1453, 1456, 3, 2, 2,
	2, 1454, 1452, 3, 2, 2, 2, 1454, 1455, 3, 2, 2, 2, 1455, 197, 3, 2, 2,
	2, 1456, 1454, 3, 2, 2, 2, 1457, 1459, 5, 14, 8, 2, 1458, 1457, 3, 2, 2,
	2, 1459, 1462, 3, 2, 2, 2, 1460, 1458, 3, 2, 2, 2, 1460, 1461, 3, 2, 2,
	2, 1461, 1463, 3, 2, 2, 2, 1462, 1460, 3, 2, 2, 2, 1463, 1467, 5, 238,
	120, 2, 1464, 1466, 5, 112, 57, 2, 1465, 1464, 3, 2, 2, 2, 1466, 1469,
	3, 2, 2, 2, 1467, 1465, 3, 2, 2, 2, 1467, 1468, 3, 2, 2, 2, 1468, 1470,
	3, 2, 2, 2, 1469, 1467, 3, 2, 2, 2, 1470, 1471, 5, 162, 82, 2, 1471, 199,
	3, 2, 2, 2, 1472, 1473, 5, 202, 102, 2, 1473, 1474, 7, 123, 2, 2, 1474,
	1475, 5, 204, 103, 2, 1475, 201, 3, 2, 2, 2, 1476, 1499, 5, 162, 82, 2,
	1477, 1479, 7, 80, 2, 2, 1478, 1480, 5, 92, 47, 2, 1479, 1478, 3, 2, 2,
	2, 1479, 1480, 3, 2, 2, 2, 1480, 1481, 3, 2, 2, 2, 1481, 1499, 7, 81, 2,
	2, 1482, 1483, 7, 80, 2, 2, 1483, 1488, 5, 162, 82, 2, 1484, 1485, 7, 87,
	2, 2, 1485, 1487, 5, 162, 82, 2, 1486, 1484, 3, 2, 2, 2, 1487, 1490, 3,
	2, 2, 2, 1488, 1486, 3, 2, 2, 2, 1488, 1489, 3, 2, 2, 2, 1489, 1491, 3,
	2, 2, 2, 1490, 1488, 3, 2, 2, 2, 1491, 1492, 7, 81, 2, 2, 1492, 1499, 3,
	2, 2, 2, 1493, 1495, 7, 80, 2, 2, 1494, 1496, 5, 98, 50, 2, 1495, 1494,
	3, 2, 2, 2, 1495, 1496, 3, 2, 2, 2, 1496, 1497, 3, 2, 2, 2, 1497, 1499,
	7, 81, 2, 2, 1498, 1476, 3, 2, 2, 2, 1498, 1477, 3, 2, 2, 2, 1498, 1482,
	3, 2, 2, 2, 1498, 1493, 3, 2, 2, 2, 1499, 203, 3, 2, 2, 2, 1500, 1503,
	5, 196, 99, 2, 1501, 1503, 5, 156, 79, 2, 1502, 1500, 3, 2, 2, 2, 1502,
	1501, 3, 2, 2, 2, 1503, 205, 3, 2, 2, 2, 1504, 1505, 7, 80, 2, 2, 1505,
	1506, 5, 196, 99, 2, 1506, 1507, 7, 81, 2, 2, 1507, 1523, 3, 2, 2, 2, 1508,
	1523, 7, 45, 2, 2, 1509, 1523, 7, 42, 2, 2, 1510, 1523, 5, 104, 53, 2,
	1511, 1523, 5, 162, 82, 2, 1512, 1513, 5, 46, 24, 2, 1513, 1514, 7, 88,
	2, 2, 1514, 1515, 7, 11, 2, 2, 1515, 1523, 3, 2, 2, 2, 1516, 1520, 5, 234,
	118, 2, 1517, 1521, 5, 246, 124, 2, 1518, 1519, 7, 45, 2, 2, 1519, 1521,
	5, 248, 125, 2, 1520, 1517, 3, 2, 2, 2, 1520, 1518, 3, 2, 2, 2, 1521, 1523,
	3, 2, 2, 2, 1522, 1504, 3, 2, 2, 2, 1522, 1508, 3, 2, 2, 2, 1522, 1509,
	3, 2, 2, 2, 1522, 1510, 3, 2, 2, 2, 1522, 1511, 3, 2, 2, 2, 1522, 1512,
	3, 2, 2, 2, 1522, 1516, 3, 2, 2, 2, 1523, 207, 3, 2, 2, 2, 1524, 1525,
	7, 43, 2, 2, 1525, 1526, 5, 190, 96, 2, 1526, 1530, 7, 82, 2, 2, 1527,
	1529, 5, 210, 106, 2, 1528, 1527, 3, 2, 2, 2, 1529, 1532, 3, 2, 2, 2, 1530,
	1528, 3, 2, 2, 2, 1530, 1531, 3, 2, 2, 2, 1531, 1533, 3, 2, 2, 2, 1532,
	1530, 3, 2, 2, 2, 1533, 1534, 7, 83, 2, 2, 1534, 209, 3, 2, 2, 2, 1535,
	1539, 7, 8, 2, 2, 1536, 1540, 5, 192, 97, 2, 1537, 1540, 7, 79, 2, 2, 1538,
	1540, 5, 212, 107, 2, 1539, 1536, 3, 2, 2, 2, 1539, 1537, 3, 2, 2, 2, 1539,
	1538, 3, 2, 2, 2, 1540, 1541, 3, 2, 2, 2, 1541, 1542, 9, 15, 2, 2, 1542,
	1547, 5, 214, 108, 2, 1543, 1544, 7, 14, 2, 2, 1544, 1545, 9, 15, 2, 2,
	1545, 1547, 5, 214, 108, 2, 1546, 1535, 3, 2, 2, 2, 1546, 1543, 3, 2, 2,
	2, 1547, 211, 3, 2, 2, 2, 1548, 1549, 8, 107, 1, 2, 1549, 1550, 7, 80,
	2, 2, 1550, 1551, 5, 212, 107, 2, 1551, 1552, 7, 81, 2, 2, 1552, 1575,
	3, 2, 2, 2, 1553, 1555, 5, 14, 8, 2, 1554, 1553, 3, 2, 2, 2, 1555, 1558,
	3, 2, 2, 2, 1556, 1554, 3, 2, 2, 2, 1556, 1557, 3, 2, 2, 2, 1557, 1559,
	3, 2, 2, 2, 1558, 1556, 3, 2, 2, 2, 1559, 1563, 5, 238, 120, 2, 1560, 1562,
	5, 112, 57, 2, 1561, 1560, 3, 2, 2, 2, 1562, 1565, 3, 2, 2, 2, 1563, 1561,
	3, 2, 2, 2, 1563, 1564, 3, 2, 2, 2, 1564, 1566, 3, 2, 2, 2, 1565, 1563,
	3, 2, 2, 2, 1566, 1571, 5, 162, 82, 2, 1567, 1568, 7, 100, 2, 2, 1568,
	1570, 5, 196, 99, 2, 1569, 1567, 3, 2, 2, 2, 1570, 1573, 3, 2, 2, 2, 1571,
	1569, 3, 2, 2, 2, 1571, 1572, 3, 2, 2, 2, 1572, 1575, 3, 2, 2, 2, 1573,
	1571, 3, 2, 2, 2, 1574, 1548, 3, 2, 2, 2, 1574, 1556, 3, 2, 2, 2, 1575,
	1581, 3, 2, 2, 2, 1576, 1577, 12, 3, 2, 2, 1577, 1578, 7, 100, 2, 2, 1578,
	1580, 5, 196, 99, 2, 1579, 1576, 3, 2, 2, 2, 1580, 1583, 3, 2, 2, 2, 1581,
	1579, 3, 2, 2, 2, 1581, 1582, 3, 2, 2, 2, 1582, 213, 3, 2, 2, 2, 1583,
	1581, 3, 2, 2, 2, 1584, 1592, 5, 156, 79, 2, 1585, 1587, 5, 158, 80, 2,
	1586, 1585, 3, 2, 2, 2, 1587, 1590, 3, 2, 2, 2, 1588, 1586, 3, 2, 2, 2,
	1588, 1589, 3, 2, 2, 2, 1589, 1592, 3, 2, 2, 2, 1590, 1588, 3, 2, 2, 2,
	1591, 1584, 3, 2, 2, 2, 1591, 1588, 3, 2, 2, 2, 1592, 215, 3, 2, 2, 2,
	1593, 1594, 5, 82, 42, 2, 1594, 1595, 7, 88, 2, 2, 1595, 1597, 3, 2, 2,
	2, 1596, 1593, 3, 2, 2, 2, 1596, 1597, 3, 2, 2, 2, 1597, 1601, 3, 2, 2,
	2, 1598, 1600, 5, 112, 57, 2, 1599, 1598, 3, 2, 2, 2, 1600, 1603, 3, 2,
	2, 2, 1601, 1599, 3, 2, 2, 2, 1601, 1602, 3, 2, 2, 2, 1602, 1604, 3, 2,
	2, 2, 1603, 1601, 3, 2, 2, 2, 1604, 1606, 5, 162, 82, 2, 1605, 1607, 5,
	242, 122, 2, 1606, 1605, 3, 2, 2, 2, 1606, 1607, 3, 2, 2, 2, 1607, 217,
	3, 2, 2, 2, 1608, 1609, 5, 234, 118, 2, 1609, 1610, 5, 220, 111, 2, 1610,
	1611, 5, 226, 114, 2, 1611, 1618, 3, 2, 2, 2, 1612, 1615, 5, 220, 111,
	2, 1613, 1616, 5, 224, 113, 2, 1614, 1616, 5, 226, 114, 2, 1615, 1613,
	3, 2, 2, 2, 1615, 1614, 3, 2, 2, 2, 1616, 1618, 3, 2, 2, 2, 1617, 1608,
	3, 2, 2, 2, 1617, 1612, 3, 2, 2, 2, 1618, 219, 3, 2, 2, 2, 1619, 1621,
	5, 162, 82, 2, 1620, 1622, 5, 230, 116, 2, 1621, 1620, 3, 2, 2, 2, 1621,
	1622, 3, 2, 2, 2, 1622, 1630, 3, 2, 2, 2, 1623, 1624, 7, 88, 2, 2, 1624,
	1626, 5, 162, 82, 2, 1625, 1627, 5, 230, 116, 2, 1626, 1625, 3, 2, 2, 2,
	1626, 1627, 3, 2, 2, 2, 1627, 1629, 3, 2, 2, 2, 1628, 1623, 3, 2, 2, 2,
	1629, 1632, 3, 2, 2, 2, 1630, 1628, 3, 2, 2, 2, 1630, 1631, 3, 2, 2, 2,
	1631, 1635, 3, 2, 2, 2, 1632, 1630, 3, 2, 2, 2, 1633, 1635, 5, 240, 121,
	2, 1634, 1619, 3, 2, 2, 2, 1634, 1633, 3, 2, 2, 2, 1635, 221, 3, 2, 2,
	2, 1636, 1638, 5, 162, 82, 2, 1637, 1639, 5, 232, 117, 2, 1638, 1637, 3,
	2, 2, 2, 1638, 1639, 3, 2, 2, 2, 1639, 1640, 3, 2, 2, 2, 1640, 1641, 5,
	226, 114, 2, 1641, 223, 3, 2, 2, 2, 1642, 1670, 7, 84, 2, 2, 1643, 1648,
	7, 85, 2, 2, 1644, 1645, 7, 84, 2, 2, 1645, 1647, 7, 85, 2, 2, 1646, 1644,
	3, 2, 2, 2, 1647, 1650, 3, 2, 2, 2, 1648, 1646, 3, 2, 2, 2, 1648, 1649,
	3, 2, 2, 2, 1649, 1651, 3, 2, 2, 2, 1650, 1648, 3, 2, 2, 2, 1651, 1671,
	5, 80, 41, 2, 1652, 1653, 5, 196, 99, 2, 1653, 1660, 7, 85, 2, 2, 1654,
	1655, 7, 84, 2, 2, 1655, 1656, 5, 196, 99, 2, 1656, 1657, 7, 85, 2, 2,
	1657, 1659, 3, 2, 2, 2, 1658, 1654, 3, 2, 2, 2, 1659, 1662, 3, 2, 2, 2,
	1660, 1658, 3, 2, 2, 2, 1660, 1661, 3, 2, 2, 2, 1661, 1667, 3, 2, 2, 2,
	1662, 1660, 3, 2, 2, 2, 1663, 1664, 7, 84, 2, 2, 1664, 1666, 7, 85, 2,
	2, 1665, 1663, 3, 2, 2, 2, 1666, 1669, 3, 2, 2, 2, 1667, 1665, 3, 2, 2,
	2, 1667, 1668, 3, 2, 2, 2, 1668, 1671, 3, 2, 2, 2, 1669, 1667, 3, 2, 2,
	2, 1670, 1643, 3, 2, 2, 2, 1670, 1652, 3, 2, 2, 2, 1671, 225, 3, 2, 2,
	2, 1672, 1674, 5, 248, 125, 2, 1673, 1675, 5, 34, 18, 2, 1674, 1673, 3,
	2, 2, 2, 1674, 1675, 3, 2, 2, 2, 1675, 227, 3, 2, 2, 2, 1676, 1677, 5,
	234, 118, 2, 1677, 1678, 5, 246, 124, 2, 1678, 229, 3, 2, 2, 2, 1679, 1680,
	7, 91, 2, 2, 1680, 1683, 7, 90, 2, 2, 1681, 1683, 5, 242, 122, 2, 1682,
	1679, 3, 2, 2, 2, 1682, 1681, 3, 2, 2, 2, 1683, 231, 3, 2, 2, 2, 1684,
	1685, 7, 91, 2, 2, 1685, 1688, 7, 90, 2, 2, 1686, 1688, 5, 234, 118, 2,
	1687, 1684, 3, 2, 2, 2, 1687, 1686, 3, 2, 2, 2, 1688, 233, 3, 2, 2, 2,
	1689, 1690, 7, 91, 2, 2, 1690, 1691, 5, 236, 119, 2, 1691, 1692, 7, 90,
	2, 2, 1692, 235, 3, 2, 2, 2, 1693, 1698, 5, 238, 120, 2, 1694, 1695, 7,
	87, 2, 2, 1695, 1697, 5, 238, 120, 2, 1696, 1694, 3, 2, 2, 2, 1697, 1700,
	3, 2, 2, 2, 1698, 1696, 3, 2, 2, 2, 1698, 1699, 3, 2, 2, 2, 1699, 237,
	3, 2, 2, 2, 1700, 1698, 3, 2, 2, 2, 1701, 1703, 5, 112, 57, 2, 1702, 1701,
	3, 2, 2, 2, 1703, 1706, 3, 2, 2, 2, 1704, 1702, 3, 2, 2, 2, 1704, 1705,
	3, 2, 2, 2, 1705, 1709, 3, 2, 2, 2, 1706, 1704, 3, 2, 2, 2, 1707, 1710,
	5, 82, 42, 2, 1708, 1710, 5, 240, 121, 2, 1709, 1707, 3, 2, 2, 2, 1709,
	1708, 3, 2, 2, 2, 1710, 1721, 3, 2, 2, 2, 1711, 1713, 5, 112, 57, 2, 1712,
	1711, 3, 2, 2, 2, 1713, 1716, 3, 2, 2, 2, 1714, 1712, 3, 2, 2, 2, 1714,
	1715, 3, 2, 2, 2, 1715, 1717, 3, 2, 2, 2, 1716, 1714, 3, 2, 2, 2, 1717,
	1718, 7, 84, 2, 2, 1718, 1720, 7, 85, 2, 2, 1719, 1714, 3, 2, 2, 2, 1720,
	1723, 3, 2, 2, 2, 1721, 1719, 3, 2, 2, 2, 1721, 1722, 3, 2, 2, 2, 1722,
	239, 3, 2, 2, 2, 1723, 1721, 3, 2, 2, 2, 1724, 1725, 9, 16, 2, 2, 1725,
	241, 3, 2, 2, 2, 1726, 1727, 7, 91, 2, 2, 1727, 1732, 5, 84, 43, 2, 1728,
	1729, 7, 87, 2, 2, 1729, 1731, 5, 84, 43, 2, 1730, 1728, 3, 2, 2, 2, 1731,
	1734, 3, 2, 2, 2, 1732, 1730, 3, 2, 2, 2, 1732, 1733, 3, 2, 2, 2, 1733,
	1735, 3, 2, 2, 2, 1734, 1732, 3, 2, 2, 2, 1735, 1736, 7, 90, 2, 2, 1736,
	243, 3, 2, 2, 2, 1737, 1747, 5, 248, 125, 2, 1738, 1740, 7, 88, 2, 2, 1739,
	1741, 5, 242, 122, 2, 1740, 1739, 3, 2, 2, 2, 1740, 1741, 3, 2, 2, 2, 1741,
	1742, 3, 2, 2, 2, 1742, 1744, 5, 162, 82, 2, 1743, 1745, 5, 248, 125, 2,
	1744, 1743, 3, 2, 2, 2, 1744, 1745, 3, 2, 2, 2, 1745, 1747, 3, 2, 2, 2,
	1746, 1737, 3, 2, 2, 2, 1746, 1738, 3, 2, 2, 2, 1747, 245, 3, 2, 2, 2,
	1748, 1749, 7, 42, 2, 2, 1749, 1754, 5, 244, 123, 2, 1750, 1751, 5, 162,
	82, 2, 1751, 1752, 5, 248, 125, 2, 1752, 1754, 3, 2, 2, 2, 1753, 1748,
	3, 2, 2, 2, 1753, 1750, 3, 2, 2, 2, 1754, 247, 3, 2, 2, 2, 1755, 1757,
	7, 80, 2, 2, 1756, 1758, 5, 192, 97, 2, 1757, 1756, 3, 2, 2, 2, 1757, 1758,
	3, 2, 2, 2, 1758, 1759, 3, 2, 2, 2, 1759, 1760, 7, 81, 2, 2, 1760, 249,
	3, 2, 2, 2, 221, 251, 256, 262, 268, 273, 282, 287, 294, 302, 305, 312,
	324, 328, 333, 337, 341, 345, 355, 363, 371, 375, 382, 389, 393, 396, 399,
	408, 414, 419, 422, 428, 434, 438, 446, 455, 462, 468, 472, 484, 493, 498,
	504, 508, 520, 531, 536, 546, 554, 564, 573, 584, 589, 598, 608, 613, 622,
	628, 635, 640, 648, 652, 654, 660, 665, 669, 676, 682, 684, 691, 696, 701,
	704, 706, 716, 726, 731, 734, 739, 748, 755, 766, 772, 783, 793, 804, 813,
	818, 821, 828, 838, 846, 849, 852, 865, 873, 878, 886, 890, 894, 898, 902,
	904, 908, 914, 922, 932, 941, 951, 959, 973, 980, 985, 991, 1000, 1010,
	1019, 1029, 1034, 1045, 1052, 1058, 1061, 1068, 1077, 1100, 1103, 1106,
	1114, 1118, 1126, 1132, 1143, 1152, 1157, 1170, 1176, 1183, 1196, 1205,
	1214, 1220, 1228, 1234, 1239, 1244, 1252, 1257, 1261, 1265, 1269, 1271,
	1275, 1280, 1285, 1300, 1306, 1313, 1319, 1322, 1333, 1341, 1356, 1360,
	1365, 1369, 1385, 1425, 1431, 1444, 1449, 1452, 1454, 1460, 1467, 1479,
	1488, 1495, 1498, 1502, 1520, 1522, 1530, 1539, 1546, 1556, 1563, 1571,
	1574, 1581, 1588, 1591, 1596, 1601, 1606, 1615, 1617, 1621, 1626, 1630,
	1634, 1638, 1648, 1660, 1667, 1670, 1674, 1682, 1687, 1698, 1704, 1709,
	1714, 1721, 1732, 1740, 1744, 1746, 1753, 1757,
}
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'", "'module'",
	"'open'", "'requires'", "'exports'", "'opens'", "'to'", "'uses'", "'provides'",
	"'with'", "'transitive'", "'var'", "'yield'", "'record'", "'sealed'", "'permits'",
	"'non-sealed'", "", "", "", "", "", "", "", "", "", "", "'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", "MODULE", "OPEN", "REQUIRES", "EXPORTS",
	"OPENS", "TO", "USES", "PROVIDES", "WITH", "TRANSITIVE", "VAR", "YIELD",
	"RECORD", "SEALED", "PERMITS", "NON_SEALED", "DECIMAL_LITERAL", "HEX_LITERAL",
	"OCT_LITERAL", "BINARY_LITERAL", "FLOAT_LITERAL", "HEX_FLOAT_LITERAL",
	"BOOL_LITERAL", "CHAR_LITERAL", "STRING_LITERAL", "TEXT_BLOCK", "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",
	"interfaceCommonBodyDeclaration", "variableDeclarators", "variableDeclarator",
	"variableDeclaratorId", "variableInitializer", "arrayInitializer", "classOrInterfaceType",
	"typeArgument", "qualifiedNameList", "formalParameters", "receiverParameter",
	"formalParameterList", "formalParameter", "lastFormalParameter", "lambdaLVTIList",
	"lambdaLVTIParameter", "qualifiedName", "literal", "integerLiteral", "floatLiteral",
	"altAnnotationQualifiedName", "annotation", "elementValuePairs", "elementValuePair",
	"elementValue", "elementValueArrayInitializer", "annotationTypeDeclaration",
	"annotationTypeBody", "annotationTypeElementDeclaration", "annotationTypeElementRest",
	"annotationMethodOrConstantRest", "annotationMethodRest", "annotationConstantRest",
	"defaultValue", "moduleDeclaration", "moduleBody", "moduleDirective", "requiresModifier",
	"recordDeclaration", "recordHeader", "recordComponentList", "recordComponent",
	"recordBody", "block", "blockStatement", "localVariableDeclaration", "identifier",
	"localTypeDeclaration", "statement", "catchClause", "catchType", "finallyBlock",
	"resourceSpecification", "resources", "resource", "switchBlockStatementGroup",
	"switchLabel", "forControl", "forInit", "enhancedForControl", "parExpression",
	"expressionList", "methodCall", "expression", "pattern", "lambdaExpression",
	"lambdaParameters", "lambdaBody", "primary", "switchExpression", "switchLabeledRule",
	"guardedPattern", "switchRuleOutcome", "classType", "creator", "createdName",
	"innerCreator", "arrayCreatorRest", "classCreatorRest", "explicitGenericInvocation",
	"typeArgumentsOrDiamond", "nonWildcardTypeArgumentsOrDiamond", "nonWildcardTypeArguments",
	"typeList", "typeType", "primitiveType", "typeArguments", "superSuffix",
	"explicitGenericInvocationSuffix", "arguments",
}

type JavaParser struct {
	*antlr.BaseParser
}

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

	this.Interpreter = antlr.NewParserATNSimulator(this, deserializedATN, decisionToDFA, antlr.NewPredictionContextCache())
	this.RuleNames = ruleNames
	this.LiteralNames = literalNames
	this.SymbolicNames = symbolicNames
	this.GrammarFileName = "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
	JavaParserMODULE            = 51
	JavaParserOPEN              = 52
	JavaParserREQUIRES          = 53
	JavaParserEXPORTS           = 54
	JavaParserOPENS             = 55
	JavaParserTO                = 56
	JavaParserUSES              = 57
	JavaParserPROVIDES          = 58
	JavaParserWITH              = 59
	JavaParserTRANSITIVE        = 60
	JavaParserVAR               = 61
	JavaParserYIELD             = 62
	JavaParserRECORD            = 63
	JavaParserSEALED            = 64
	JavaParserPERMITS           = 65
	JavaParserNON_SEALED        = 66
	JavaParserDECIMAL_LITERAL   = 67
	JavaParserHEX_LITERAL       = 68
	JavaParserOCT_LITERAL       = 69
	JavaParserBINARY_LITERAL    = 70
	JavaParserFLOAT_LITERAL     = 71
	JavaParserHEX_FLOAT_LITERAL = 72
	JavaParserBOOL_LITERAL      = 73
	JavaParserCHAR_LITERAL      = 74
	JavaParserSTRING_LITERAL    = 75
	JavaParserTEXT_BLOCK        = 76
	JavaParserNULL_LITERAL      = 77
	JavaParserLPAREN            = 78
	JavaParserRPAREN            = 79
	JavaParserLBRACE            = 80
	JavaParserRBRACE            = 81
	JavaParserLBRACK            = 82
	JavaParserRBRACK            = 83
	JavaParserSEMI              = 84
	JavaParserCOMMA             = 85
	JavaParserDOT               = 86
	JavaParserASSIGN            = 87
	JavaParserGT                = 88
	JavaParserLT                = 89
	JavaParserBANG              = 90
	JavaParserTILDE             = 91
	JavaParserQUESTION          = 92
	JavaParserCOLON             = 93
	JavaParserEQUAL             = 94
	JavaParserLE                = 95
	JavaParserGE                = 96
	JavaParserNOTEQUAL          = 97
	JavaParserAND               = 98
	JavaParserOR                = 99
	JavaParserINC               = 100
	JavaParserDEC               = 101
	JavaParserADD               = 102
	JavaParserSUB               = 103
	JavaParserMUL               = 104
	JavaParserDIV               = 105
	JavaParserBITAND            = 106
	JavaParserBITOR             = 107
	JavaParserCARET             = 108
	JavaParserMOD               = 109
	JavaParserADD_ASSIGN        = 110
	JavaParserSUB_ASSIGN        = 111
	JavaParserMUL_ASSIGN        = 112
	JavaParserDIV_ASSIGN        = 113
	JavaParserAND_ASSIGN        = 114
	JavaParserOR_ASSIGN         = 115
	JavaParserXOR_ASSIGN        = 116
	JavaParserMOD_ASSIGN        = 117
	JavaParserLSHIFT_ASSIGN     = 118
	JavaParserRSHIFT_ASSIGN     = 119
	JavaParserURSHIFT_ASSIGN    = 120
	JavaParserARROW             = 121
	JavaParserCOLONCOLON        = 122
	JavaParserAT                = 123
	JavaParserELLIPSIS          = 124
	JavaParserWS                = 125
	JavaParserCOMMENT           = 126
	JavaParserLINE_COMMENT      = 127
	JavaParserIDENTIFIER        = 128
)

// 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_interfaceCommonBodyDeclaration    = 34
	JavaParserRULE_variableDeclarators               = 35
	JavaParserRULE_variableDeclarator                = 36
	JavaParserRULE_variableDeclaratorId              = 37
	JavaParserRULE_variableInitializer               = 38
	JavaParserRULE_arrayInitializer                  = 39
	JavaParserRULE_classOrInterfaceType              = 40
	JavaParserRULE_typeArgument                      = 41
	JavaParserRULE_qualifiedNameList                 = 42
	JavaParserRULE_formalParameters                  = 43
	JavaParserRULE_receiverParameter                 = 44
	JavaParserRULE_formalParameterList               = 45
	JavaParserRULE_formalParameter                   = 46
	JavaParserRULE_lastFormalParameter               = 47
	JavaParserRULE_lambdaLVTIList                    = 48
	JavaParserRULE_lambdaLVTIParameter               = 49
	JavaParserRULE_qualifiedName                     = 50
	JavaParserRULE_literal                           = 51
	JavaParserRULE_integerLiteral                    = 52
	JavaParserRULE_floatLiteral                      = 53
	JavaParserRULE_altAnnotationQualifiedName        = 54
	JavaParserRULE_annotation                        = 55
	JavaParserRULE_elementValuePairs                 = 56
	JavaParserRULE_elementValuePair                  = 57
	JavaParserRULE_elementValue                      = 58
	JavaParserRULE_elementValueArrayInitializer      = 59
	JavaParserRULE_annotationTypeDeclaration         = 60
	JavaParserRULE_annotationTypeBody                = 61
	JavaParserRULE_annotationTypeElementDeclaration  = 62
	JavaParserRULE_annotationTypeElementRest         = 63
	JavaParserRULE_annotationMethodOrConstantRest    = 64
	JavaParserRULE_annotationMethodRest              = 65
	JavaParserRULE_annotationConstantRest            = 66
	JavaParserRULE_defaultValue                      = 67
	JavaParserRULE_moduleDeclaration                 = 68
	JavaParserRULE_moduleBody                        = 69
	JavaParserRULE_moduleDirective                   = 70
	JavaParserRULE_requiresModifier                  = 71
	JavaParserRULE_recordDeclaration                 = 72
	JavaParserRULE_recordHeader                      = 73
	JavaParserRULE_recordComponentList               = 74
	JavaParserRULE_recordComponent                   = 75
	JavaParserRULE_recordBody                        = 76
	JavaParserRULE_block                             = 77
	JavaParserRULE_blockStatement                    = 78
	JavaParserRULE_localVariableDeclaration          = 79
	JavaParserRULE_identifier                        = 80
	JavaParserRULE_localTypeDeclaration              = 81
	JavaParserRULE_statement                         = 82
	JavaParserRULE_catchClause                       = 83
	JavaParserRULE_catchType                         = 84
	JavaParserRULE_finallyBlock                      = 85
	JavaParserRULE_resourceSpecification             = 86
	JavaParserRULE_resources                         = 87
	JavaParserRULE_resource                          = 88
	JavaParserRULE_switchBlockStatementGroup         = 89
	JavaParserRULE_switchLabel                       = 90
	JavaParserRULE_forControl                        = 91
	JavaParserRULE_forInit                           = 92
	JavaParserRULE_enhancedForControl                = 93
	JavaParserRULE_parExpression                     = 94
	JavaParserRULE_expressionList                    = 95
	JavaParserRULE_methodCall                        = 96
	JavaParserRULE_expression                        = 97
	JavaParserRULE_pattern                           = 98
	JavaParserRULE_lambdaExpression                  = 99
	JavaParserRULE_lambdaParameters                  = 100
	JavaParserRULE_lambdaBody                        = 101
	JavaParserRULE_primary                           = 102
	JavaParserRULE_switchExpression                  = 103
	JavaParserRULE_switchLabeledRule                 = 104
	JavaParserRULE_guardedPattern                    = 105
	JavaParserRULE_switchRuleOutcome                 = 106
	JavaParserRULE_classType                         = 107
	JavaParserRULE_creator                           = 108
	JavaParserRULE_createdName                       = 109
	JavaParserRULE_innerCreator                      = 110
	JavaParserRULE_arrayCreatorRest                  = 111
	JavaParserRULE_classCreatorRest                  = 112
	JavaParserRULE_explicitGenericInvocation         = 113
	JavaParserRULE_typeArgumentsOrDiamond            = 114
	JavaParserRULE_nonWildcardTypeArgumentsOrDiamond = 115
	JavaParserRULE_nonWildcardTypeArguments          = 116
	JavaParserRULE_typeList                          = 117
	JavaParserRULE_typeType                          = 118
	JavaParserRULE_primitiveType                     = 119
	JavaParserRULE_typeArguments                     = 120
	JavaParserRULE_superSuffix                       = 121
	JavaParserRULE_explicitGenericInvocationSuffix   = 122
	JavaParserRULE_arguments                         = 123
)

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

	if t == nil {
		return nil
	}

	return t.(IModuleDeclarationContext)
}

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

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) {
	this := p
	_ = this

	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.SetState(266)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 3, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(249)
		p.GetErrorHandler().Sync(p)

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

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

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

			p.SetState(256)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		p.SetState(260)
		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))|(1<<(JavaParserMODULE-33))|(1<<(JavaParserOPEN-33))|(1<<(JavaParserREQUIRES-33))|(1<<(JavaParserEXPORTS-33))|(1<<(JavaParserOPENS-33))|(1<<(JavaParserTO-33))|(1<<(JavaParserUSES-33))|(1<<(JavaParserPROVIDES-33))|(1<<(JavaParserWITH-33))|(1<<(JavaParserTRANSITIVE-33))|(1<<(JavaParserVAR-33))|(1<<(JavaParserYIELD-33))|(1<<(JavaParserRECORD-33))|(1<<(JavaParserSEALED-33)))) != 0) || (((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(JavaParserPERMITS-65))|(1<<(JavaParserNON_SEALED-65))|(1<<(JavaParserSEMI-65)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
			{
				p.SetState(257)
				p.TypeDeclaration()
			}

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(263)
			p.ModuleDeclaration()
		}
		{
			p.SetState(264)
			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) {
	this := p
	_ = this

	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(271)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la-51)&-(0x1f+1)) == 0 && ((1<<uint((_la-51)))&((1<<(JavaParserMODULE-51))|(1<<(JavaParserOPEN-51))|(1<<(JavaParserREQUIRES-51))|(1<<(JavaParserEXPORTS-51))|(1<<(JavaParserOPENS-51))|(1<<(JavaParserTO-51))|(1<<(JavaParserUSES-51))|(1<<(JavaParserPROVIDES-51))|(1<<(JavaParserWITH-51))|(1<<(JavaParserTRANSITIVE-51))|(1<<(JavaParserVAR-51))|(1<<(JavaParserYIELD-51))|(1<<(JavaParserRECORD-51))|(1<<(JavaParserSEALED-51))|(1<<(JavaParserPERMITS-51)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(268)
			p.Annotation()
		}

		p.SetState(273)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(274)
		p.Match(JavaParserPACKAGE)
	}
	{
		p.SetState(275)
		p.QualifiedName()
	}
	{
		p.SetState(276)
		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) {
	this := p
	_ = this

	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(278)
		p.Match(JavaParserIMPORT)
	}
	p.SetState(280)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

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

	}
	{
		p.SetState(282)
		p.QualifiedName()
	}
	p.SetState(285)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserDOT {
		{
			p.SetState(283)
			p.Match(JavaParserDOT)
		}
		{
			p.SetState(284)
			p.Match(JavaParserMUL)
		}

	}
	{
		p.SetState(287)
		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) RecordDeclaration() IRecordDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRecordDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRecordDeclarationContext)
}

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) {
	this := p
	_ = this

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

	switch p.GetTokenStream().LA(1) {
	case JavaParserABSTRACT, JavaParserCLASS, JavaParserENUM, JavaParserFINAL, JavaParserINTERFACE, JavaParserPRIVATE, JavaParserPROTECTED, JavaParserPUBLIC, JavaParserSTATIC, JavaParserSTRICTFP, JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserNON_SEALED, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(292)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext())

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

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

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

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

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

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

		case JavaParserRECORD:
			{
				p.SetState(299)
				p.RecordDeclaration()
			}

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

	case JavaParserSEMI:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(302)
			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) {
	this := p
	_ = this

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

	switch p.GetTokenStream().LA(1) {
	case JavaParserABSTRACT, JavaParserFINAL, JavaParserPRIVATE, JavaParserPROTECTED, JavaParserPUBLIC, JavaParserSTATIC, JavaParserSTRICTFP, JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserNON_SEALED, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(305)
			p.ClassOrInterfaceModifier()
		}

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

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

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

	case JavaParserVOLATILE:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(309)
			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) SEALED() antlr.TerminalNode {
	return s.GetToken(JavaParserSEALED, 0)
}

func (s *ClassOrInterfaceModifierContext) NON_SEALED() antlr.TerminalNode {
	return s.GetToken(JavaParserNON_SEALED, 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) {
	this := p
	_ = this

	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(322)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 11, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(312)
			p.Annotation()
		}

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

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

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

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

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

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

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

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(320)
			p.Match(JavaParserSEALED)
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(321)
			p.Match(JavaParserNON_SEALED)
		}

	}

	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) {
	this := p
	_ = this

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

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

	case JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(325)
			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() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) AllTypeList() []ITypeListContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeListContext)(nil)).Elem())
	var tst = make([]ITypeListContext, len(ts))

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeListContext)
}

func (s *ClassDeclarationContext) PERMITS() antlr.TerminalNode {
	return s.GetToken(JavaParserPERMITS, 0)
}

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) {
	this := p
	_ = this

	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(328)
		p.Match(JavaParserCLASS)
	}
	{
		p.SetState(329)
		p.Identifier()
	}
	p.SetState(331)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

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

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

	if _la == JavaParserEXTENDS {
		{
			p.SetState(333)
			p.Match(JavaParserEXTENDS)
		}
		{
			p.SetState(334)
			p.TypeType()
		}

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

	if _la == JavaParserIMPLEMENTS {
		{
			p.SetState(337)
			p.Match(JavaParserIMPLEMENTS)
		}
		{
			p.SetState(338)
			p.TypeList()
		}

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

	if _la == JavaParserPERMITS {
		{
			p.SetState(341)
			p.Match(JavaParserPERMITS)
		}
		{
			p.SetState(342)
			p.TypeList()
		}

	}
	{
		p.SetState(345)
		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) {
	this := p
	_ = this

	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(347)
		p.Match(JavaParserLT)
	}
	{
		p.SetState(348)
		p.TypeParameter()
	}
	p.SetState(353)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(349)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(350)
			p.TypeParameter()
		}

		p.SetState(355)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(356)
		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() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	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)
			}
		}
	}()

	var _alt int

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

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

		}
		p.SetState(363)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 18, p.GetParserRuleContext())
	}
	{
		p.SetState(364)
		p.Identifier()
	}
	p.SetState(373)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserEXTENDS {
		{
			p.SetState(365)
			p.Match(JavaParserEXTENDS)
		}
		p.SetState(369)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 19, p.GetParserRuleContext())

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

			}
			p.SetState(371)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 19, p.GetParserRuleContext())
		}
		{
			p.SetState(372)
			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) {
	this := p
	_ = this

	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(375)
		p.TypeType()
	}
	p.SetState(380)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserBITAND {
		{
			p.SetState(376)
			p.Match(JavaParserBITAND)
		}
		{
			p.SetState(377)
			p.TypeType()
		}

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

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	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(383)
		p.Match(JavaParserENUM)
	}
	{
		p.SetState(384)
		p.Identifier()
	}
	p.SetState(387)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserIMPLEMENTS {
		{
			p.SetState(385)
			p.Match(JavaParserIMPLEMENTS)
		}
		{
			p.SetState(386)
			p.TypeList()
		}

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

	if (((_la-51)&-(0x1f+1)) == 0 && ((1<<uint((_la-51)))&((1<<(JavaParserMODULE-51))|(1<<(JavaParserOPEN-51))|(1<<(JavaParserREQUIRES-51))|(1<<(JavaParserEXPORTS-51))|(1<<(JavaParserOPENS-51))|(1<<(JavaParserTO-51))|(1<<(JavaParserUSES-51))|(1<<(JavaParserPROVIDES-51))|(1<<(JavaParserWITH-51))|(1<<(JavaParserTRANSITIVE-51))|(1<<(JavaParserVAR-51))|(1<<(JavaParserYIELD-51))|(1<<(JavaParserRECORD-51))|(1<<(JavaParserSEALED-51))|(1<<(JavaParserPERMITS-51)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(390)
			p.EnumConstants()
		}

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

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

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

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

	}
	{
		p.SetState(399)
		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) {
	this := p
	_ = this

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

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

		}
		p.SetState(408)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 26, 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() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	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)
			}
		}
	}()

	var _alt int

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

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

		}
		p.SetState(414)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 27, p.GetParserRuleContext())
	}
	{
		p.SetState(415)
		p.Identifier()
	}
	p.SetState(417)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

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

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

	if _la == JavaParserLBRACE {
		{
			p.SetState(419)
			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) {
	this := p
	_ = this

	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(422)
		p.Match(JavaParserSEMI)
	}
	p.SetState(426)
	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<<(JavaParserMODULE-33))|(1<<(JavaParserOPEN-33))|(1<<(JavaParserREQUIRES-33))|(1<<(JavaParserEXPORTS-33))|(1<<(JavaParserOPENS-33))|(1<<(JavaParserTO-33))|(1<<(JavaParserUSES-33))|(1<<(JavaParserPROVIDES-33))|(1<<(JavaParserWITH-33))|(1<<(JavaParserTRANSITIVE-33))|(1<<(JavaParserVAR-33))|(1<<(JavaParserYIELD-33))|(1<<(JavaParserRECORD-33))|(1<<(JavaParserSEALED-33)))) != 0) || (((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(JavaParserPERMITS-65))|(1<<(JavaParserNON_SEALED-65))|(1<<(JavaParserLBRACE-65))|(1<<(JavaParserSEMI-65))|(1<<(JavaParserLT-65)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(423)
			p.ClassBodyDeclaration()
		}

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

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	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(429)
		p.Match(JavaParserINTERFACE)
	}
	{
		p.SetState(430)
		p.Identifier()
	}
	p.SetState(432)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

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

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

	if _la == JavaParserEXTENDS {
		{
			p.SetState(434)
			p.Match(JavaParserEXTENDS)
		}
		{
			p.SetState(435)
			p.TypeList()
		}

	}
	{
		p.SetState(438)
		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) {
	this := p
	_ = this

	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(440)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(444)
	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<<(JavaParserMODULE-33))|(1<<(JavaParserOPEN-33))|(1<<(JavaParserREQUIRES-33))|(1<<(JavaParserEXPORTS-33))|(1<<(JavaParserOPENS-33))|(1<<(JavaParserTO-33))|(1<<(JavaParserUSES-33))|(1<<(JavaParserPROVIDES-33))|(1<<(JavaParserWITH-33))|(1<<(JavaParserTRANSITIVE-33))|(1<<(JavaParserVAR-33))|(1<<(JavaParserYIELD-33))|(1<<(JavaParserRECORD-33))|(1<<(JavaParserSEALED-33)))) != 0) || (((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(JavaParserPERMITS-65))|(1<<(JavaParserNON_SEALED-65))|(1<<(JavaParserLBRACE-65))|(1<<(JavaParserSEMI-65))|(1<<(JavaParserLT-65)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(441)
			p.ClassBodyDeclaration()
		}

		p.SetState(446)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(447)
		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) {
	this := p
	_ = this

	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(449)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(453)
	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))|(1<<(JavaParserMODULE-33))|(1<<(JavaParserOPEN-33))|(1<<(JavaParserREQUIRES-33))|(1<<(JavaParserEXPORTS-33))|(1<<(JavaParserOPENS-33))|(1<<(JavaParserTO-33))|(1<<(JavaParserUSES-33))|(1<<(JavaParserPROVIDES-33))|(1<<(JavaParserWITH-33))|(1<<(JavaParserTRANSITIVE-33))|(1<<(JavaParserVAR-33))|(1<<(JavaParserYIELD-33))|(1<<(JavaParserRECORD-33))|(1<<(JavaParserSEALED-33)))) != 0) || (((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(JavaParserPERMITS-65))|(1<<(JavaParserNON_SEALED-65))|(1<<(JavaParserSEMI-65))|(1<<(JavaParserLT-65)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(450)
			p.InterfaceBodyDeclaration()
		}

		p.SetState(455)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(456)
		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) {
	this := p
	_ = this

	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(470)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 37, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(458)
			p.Match(JavaParserSEMI)
		}

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

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

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

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

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

			}
			p.SetState(468)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 36, p.GetParserRuleContext())
		}
		{
			p.SetState(469)
			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) RecordDeclaration() IRecordDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRecordDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRecordDeclarationContext)
}

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) {
	this := p
	_ = this

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

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

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

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

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

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

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

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

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

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(481)
			p.RecordDeclaration()
		}

	}

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

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	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(484)
		p.TypeTypeOrVoid()
	}
	{
		p.SetState(485)
		p.Identifier()
	}
	{
		p.SetState(486)
		p.FormalParameters()
	}
	p.SetState(491)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserLBRACK {
		{
			p.SetState(487)
			p.Match(JavaParserLBRACK)
		}
		{
			p.SetState(488)
			p.Match(JavaParserRBRACK)
		}

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

	if _la == JavaParserTHROWS {
		{
			p.SetState(494)
			p.Match(JavaParserTHROWS)
		}
		{
			p.SetState(495)
			p.QualifiedNameList()
		}

	}
	{
		p.SetState(498)
		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) {
	this := p
	_ = this

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

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

	case JavaParserSEMI:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(501)
			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) {
	this := p
	_ = this

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

	switch p.GetTokenStream().LA(1) {
	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserSHORT, JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(504)
			p.TypeType()
		}

	case JavaParserVOID:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(505)
			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) {
	this := p
	_ = this

	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(508)
		p.TypeParameters()
	}
	{
		p.SetState(509)
		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) {
	this := p
	_ = this

	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(511)
		p.TypeParameters()
	}
	{
		p.SetState(512)
		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() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	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(514)
		p.Identifier()
	}
	{
		p.SetState(515)
		p.FormalParameters()
	}
	p.SetState(518)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserTHROWS {
		{
			p.SetState(516)
			p.Match(JavaParserTHROWS)
		}
		{
			p.SetState(517)
			p.QualifiedNameList()
		}

	}
	{
		p.SetState(520)

		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) {
	this := p
	_ = this

	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(522)
		p.TypeType()
	}
	{
		p.SetState(523)
		p.VariableDeclarators()
	}
	{
		p.SetState(524)
		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) {
	this := p
	_ = this

	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(534)
	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, JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserNON_SEALED, JavaParserLT, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(529)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 44, p.GetParserRuleContext())

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

			}
			p.SetState(531)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 44, p.GetParserRuleContext())
		}
		{
			p.SetState(532)
			p.InterfaceMemberDeclaration()
		}

	case JavaParserSEMI:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(533)
			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) RecordDeclaration() IRecordDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRecordDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRecordDeclarationContext)
}

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) {
	this := p
	_ = this

	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(544)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 46, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(536)
			p.ConstDeclaration()
		}

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

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

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

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

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

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

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(543)
			p.RecordDeclaration()
		}

	}

	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) {
	this := p
	_ = this

	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(546)
		p.TypeType()
	}
	{
		p.SetState(547)
		p.ConstantDeclarator()
	}
	p.SetState(552)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(548)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(549)
			p.ConstantDeclarator()
		}

		p.SetState(554)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(555)
		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() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	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(557)
		p.Identifier()
	}
	p.SetState(562)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserLBRACK {
		{
			p.SetState(558)
			p.Match(JavaParserLBRACK)
		}
		{
			p.SetState(559)
			p.Match(JavaParserRBRACK)
		}

		p.SetState(564)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(565)
		p.Match(JavaParserASSIGN)
	}
	{
		p.SetState(566)
		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) InterfaceCommonBodyDeclaration() IInterfaceCommonBodyDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceCommonBodyDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceCommonBodyDeclarationContext)
}

func (s *InterfaceMethodDeclarationContext) AllInterfaceMethodModifier() []IInterfaceMethodModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInterfaceMethodModifierContext)(nil)).Elem())
	var tst = make([]IInterfaceMethodModifierContext, len(ts))

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

	return tst
}

func (s *InterfaceMethodDeclarationContext) InterfaceMethodModifier(i int) IInterfaceMethodModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceMethodModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInterfaceMethodModifierContext)
}

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

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

func (s *InterfaceMethodDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(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) {
	this := p
	_ = this

	localctx = NewInterfaceMethodDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 62, JavaParserRULE_interfaceMethodDeclaration)

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

	defer func() {
		if err := recover(); err != 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(571)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 49, p.GetParserRuleContext())

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

		}
		p.SetState(573)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 49, p.GetParserRuleContext())
	}
	{
		p.SetState(574)
		p.InterfaceCommonBodyDeclaration()
	}

	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) {
	this := p
	_ = this

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

	switch p.GetTokenStream().LA(1) {
	case JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(576)
			p.Annotation()
		}

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

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

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

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

	case JavaParserSTRICTFP:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(581)
			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) InterfaceCommonBodyDeclaration() IInterfaceCommonBodyDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInterfaceCommonBodyDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInterfaceCommonBodyDeclarationContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IInterfaceMethodModifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewGenericInterfaceMethodDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, JavaParserRULE_genericInterfaceMethodDeclaration)
	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(587)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserABSTRACT || _la == JavaParserDEFAULT || (((_la-35)&-(0x1f+1)) == 0 && ((1<<uint((_la-35)))&((1<<(JavaParserPUBLIC-35))|(1<<(JavaParserSTATIC-35))|(1<<(JavaParserSTRICTFP-35))|(1<<(JavaParserMODULE-35))|(1<<(JavaParserOPEN-35))|(1<<(JavaParserREQUIRES-35))|(1<<(JavaParserEXPORTS-35))|(1<<(JavaParserOPENS-35))|(1<<(JavaParserTO-35))|(1<<(JavaParserUSES-35))|(1<<(JavaParserPROVIDES-35))|(1<<(JavaParserWITH-35))|(1<<(JavaParserTRANSITIVE-35))|(1<<(JavaParserVAR-35))|(1<<(JavaParserYIELD-35))|(1<<(JavaParserRECORD-35))|(1<<(JavaParserSEALED-35))|(1<<(JavaParserPERMITS-35)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(584)
			p.InterfaceMethodModifier()
		}

		p.SetState(589)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(590)
		p.TypeParameters()
	}
	{
		p.SetState(591)
		p.InterfaceCommonBodyDeclaration()
	}

	return localctx
}

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

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

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

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

func NewEmptyInterfaceCommonBodyDeclarationContext() *InterfaceCommonBodyDeclarationContext {
	var p = new(InterfaceCommonBodyDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_interfaceCommonBodyDeclaration
	return p
}

func (*InterfaceCommonBodyDeclarationContext) IsInterfaceCommonBodyDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_interfaceCommonBodyDeclaration

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(ITypeTypeOrVoidContext)
}

func (s *InterfaceCommonBodyDeclarationContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IFormalParametersContext)
}

func (s *InterfaceCommonBodyDeclarationContext) MethodBody() IMethodBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodBodyContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

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

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

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

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

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

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

	if t == nil {
		return nil
	}

	return t.(IQualifiedNameListContext)
}

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

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

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

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

func (p *JavaParser) InterfaceCommonBodyDeclaration() (localctx IInterfaceCommonBodyDeclarationContext) {
	this := p
	_ = this

	localctx = NewInterfaceCommonBodyDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, JavaParserRULE_interfaceCommonBodyDeclaration)
	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(596)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 52, p.GetParserRuleContext())

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

		}
		p.SetState(598)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 52, p.GetParserRuleContext())
	}
	{
		p.SetState(599)
		p.TypeTypeOrVoid()
	}
	{
		p.SetState(600)
		p.Identifier()
	}
	{
		p.SetState(601)
		p.FormalParameters()
	}
	p.SetState(606)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserLBRACK {
		{
			p.SetState(602)
			p.Match(JavaParserLBRACK)
		}
		{
			p.SetState(603)
			p.Match(JavaParserRBRACK)
		}

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

	if _la == JavaParserTHROWS {
		{
			p.SetState(609)
			p.Match(JavaParserTHROWS)
		}
		{
			p.SetState(610)
			p.QualifiedNameList()
		}

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

	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) {
	this := p
	_ = this

	localctx = NewVariableDeclaratorsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, 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(615)
		p.VariableDeclarator()
	}
	p.SetState(620)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(616)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(617)
			p.VariableDeclarator()
		}

		p.SetState(622)
		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) {
	this := p
	_ = this

	localctx = NewVariableDeclaratorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, 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(623)
		p.VariableDeclaratorId()
	}
	p.SetState(626)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserASSIGN {
		{
			p.SetState(624)
			p.Match(JavaParserASSIGN)
		}
		{
			p.SetState(625)
			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() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewVariableDeclaratorIdContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, 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(628)
		p.Identifier()
	}
	p.SetState(633)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserLBRACK {
		{
			p.SetState(629)
			p.Match(JavaParserLBRACK)
		}
		{
			p.SetState(630)
			p.Match(JavaParserRBRACK)
		}

		p.SetState(635)
		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) {
	this := p
	_ = this

	localctx = NewVariableInitializerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 76, 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(638)
	p.GetErrorHandler().Sync(p)

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

	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserNEW, JavaParserSHORT, JavaParserSUPER, JavaParserSWITCH, JavaParserTHIS, JavaParserVOID, JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserDECIMAL_LITERAL, JavaParserHEX_LITERAL, JavaParserOCT_LITERAL, JavaParserBINARY_LITERAL, JavaParserFLOAT_LITERAL, JavaParserHEX_FLOAT_LITERAL, JavaParserBOOL_LITERAL, JavaParserCHAR_LITERAL, JavaParserSTRING_LITERAL, JavaParserTEXT_BLOCK, JavaParserNULL_LITERAL, JavaParserLPAREN, JavaParserLT, JavaParserBANG, JavaParserTILDE, JavaParserINC, JavaParserDEC, JavaParserADD, JavaParserSUB, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(637)
			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) {
	this := p
	_ = this

	localctx = NewArrayInitializerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, 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(640)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(652)
	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<<(JavaParserSWITCH-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserMODULE-37))|(1<<(JavaParserOPEN-37))|(1<<(JavaParserREQUIRES-37))|(1<<(JavaParserEXPORTS-37))|(1<<(JavaParserOPENS-37))|(1<<(JavaParserTO-37))|(1<<(JavaParserUSES-37))|(1<<(JavaParserPROVIDES-37))|(1<<(JavaParserWITH-37))|(1<<(JavaParserTRANSITIVE-37))|(1<<(JavaParserVAR-37))|(1<<(JavaParserYIELD-37))|(1<<(JavaParserRECORD-37))|(1<<(JavaParserSEALED-37))|(1<<(JavaParserPERMITS-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(JavaParserOCT_LITERAL-69))|(1<<(JavaParserBINARY_LITERAL-69))|(1<<(JavaParserFLOAT_LITERAL-69))|(1<<(JavaParserHEX_FLOAT_LITERAL-69))|(1<<(JavaParserBOOL_LITERAL-69))|(1<<(JavaParserCHAR_LITERAL-69))|(1<<(JavaParserSTRING_LITERAL-69))|(1<<(JavaParserTEXT_BLOCK-69))|(1<<(JavaParserNULL_LITERAL-69))|(1<<(JavaParserLPAREN-69))|(1<<(JavaParserLBRACE-69))|(1<<(JavaParserLT-69))|(1<<(JavaParserBANG-69))|(1<<(JavaParserTILDE-69))|(1<<(JavaParserINC-69)))) != 0) || (((_la-101)&-(0x1f+1)) == 0 && ((1<<uint((_la-101)))&((1<<(JavaParserDEC-101))|(1<<(JavaParserADD-101))|(1<<(JavaParserSUB-101))|(1<<(JavaParserAT-101))|(1<<(JavaParserIDENTIFIER-101)))) != 0) {
		{
			p.SetState(641)
			p.VariableInitializer()
		}
		p.SetState(646)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 59, p.GetParserRuleContext())

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

			}
			p.SetState(648)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 59, p.GetParserRuleContext())
		}
		p.SetState(650)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

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

		}

	}
	{
		p.SetState(654)
		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() []IIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIdentifierContext)(nil)).Elem())
	var tst = make([]IIdentifierContext, len(ts))

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewClassOrInterfaceTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, 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(656)
		p.Identifier()
	}
	p.SetState(658)
	p.GetErrorHandler().Sync(p)

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

	}
	p.SetState(667)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 64, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(660)
				p.Match(JavaParserDOT)
			}
			{
				p.SetState(661)
				p.Identifier()
			}
			p.SetState(663)
			p.GetErrorHandler().Sync(p)

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

			}

		}
		p.SetState(669)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 64, 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) 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 *TypeArgumentContext) Annotation(i int) IAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnnotationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

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) {
	this := p
	_ = this

	localctx = NewTypeArgumentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, 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(682)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 67, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(670)
			p.TypeType()
		}

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

		for (((_la-51)&-(0x1f+1)) == 0 && ((1<<uint((_la-51)))&((1<<(JavaParserMODULE-51))|(1<<(JavaParserOPEN-51))|(1<<(JavaParserREQUIRES-51))|(1<<(JavaParserEXPORTS-51))|(1<<(JavaParserOPENS-51))|(1<<(JavaParserTO-51))|(1<<(JavaParserUSES-51))|(1<<(JavaParserPROVIDES-51))|(1<<(JavaParserWITH-51))|(1<<(JavaParserTRANSITIVE-51))|(1<<(JavaParserVAR-51))|(1<<(JavaParserYIELD-51))|(1<<(JavaParserRECORD-51))|(1<<(JavaParserSEALED-51))|(1<<(JavaParserPERMITS-51)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
			{
				p.SetState(671)
				p.Annotation()
			}

			p.SetState(676)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(677)
			p.Match(JavaParserQUESTION)
		}
		p.SetState(680)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

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

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

		}

	}

	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) {
	this := p
	_ = this

	localctx = NewQualifiedNameListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 84, 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(684)
		p.QualifiedName()
	}
	p.SetState(689)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(685)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(686)
			p.QualifiedName()
		}

		p.SetState(691)
		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) ReceiverParameter() IReceiverParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReceiverParameterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReceiverParameterContext)
}

func (s *FormalParametersContext) COMMA() antlr.TerminalNode {
	return s.GetToken(JavaParserCOMMA, 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) {
	this := p
	_ = this

	localctx = NewFormalParametersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, 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(692)
		p.Match(JavaParserLPAREN)
	}
	p.SetState(704)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 72, p.GetParserRuleContext()) {
	case 1:
		p.SetState(694)
		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))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(JavaParserSHORT-37))|(1<<(JavaParserMODULE-37))|(1<<(JavaParserOPEN-37))|(1<<(JavaParserREQUIRES-37))|(1<<(JavaParserEXPORTS-37))|(1<<(JavaParserOPENS-37))|(1<<(JavaParserTO-37))|(1<<(JavaParserUSES-37))|(1<<(JavaParserPROVIDES-37))|(1<<(JavaParserWITH-37))|(1<<(JavaParserTRANSITIVE-37))|(1<<(JavaParserVAR-37))|(1<<(JavaParserYIELD-37))|(1<<(JavaParserRECORD-37))|(1<<(JavaParserSEALED-37))|(1<<(JavaParserPERMITS-37)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
			{
				p.SetState(693)
				p.ReceiverParameter()
			}

		}

	case 2:
		{
			p.SetState(696)
			p.ReceiverParameter()
		}
		p.SetState(699)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserCOMMA {
			{
				p.SetState(697)
				p.Match(JavaParserCOMMA)
			}
			{
				p.SetState(698)
				p.FormalParameterList()
			}

		}

	case 3:
		p.SetState(702)
		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-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(JavaParserSHORT-37))|(1<<(JavaParserMODULE-37))|(1<<(JavaParserOPEN-37))|(1<<(JavaParserREQUIRES-37))|(1<<(JavaParserEXPORTS-37))|(1<<(JavaParserOPENS-37))|(1<<(JavaParserTO-37))|(1<<(JavaParserUSES-37))|(1<<(JavaParserPROVIDES-37))|(1<<(JavaParserWITH-37))|(1<<(JavaParserTRANSITIVE-37))|(1<<(JavaParserVAR-37))|(1<<(JavaParserYIELD-37))|(1<<(JavaParserRECORD-37))|(1<<(JavaParserSEALED-37))|(1<<(JavaParserPERMITS-37)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
			{
				p.SetState(701)
				p.FormalParameterList()
			}

		}

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

	return localctx
}

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

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

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

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

func NewEmptyReceiverParameterContext() *ReceiverParameterContext {
	var p = new(ReceiverParameterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_receiverParameter
	return p
}

func (*ReceiverParameterContext) IsReceiverParameterContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_receiverParameter

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *ReceiverParameterContext) THIS() antlr.TerminalNode {
	return s.GetToken(JavaParserTHIS, 0)
}

func (s *ReceiverParameterContext) AllIdentifier() []IIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIdentifierContext)(nil)).Elem())
	var tst = make([]IIdentifierContext, len(ts))

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

	return tst
}

func (s *ReceiverParameterContext) Identifier(i int) IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

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

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

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

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

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

func (p *JavaParser) ReceiverParameter() (localctx IReceiverParameterContext) {
	this := p
	_ = this

	localctx = NewReceiverParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, JavaParserRULE_receiverParameter)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(708)
		p.TypeType()
	}
	p.SetState(714)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la-51)&-(0x1f+1)) == 0 && ((1<<uint((_la-51)))&((1<<(JavaParserMODULE-51))|(1<<(JavaParserOPEN-51))|(1<<(JavaParserREQUIRES-51))|(1<<(JavaParserEXPORTS-51))|(1<<(JavaParserOPENS-51))|(1<<(JavaParserTO-51))|(1<<(JavaParserUSES-51))|(1<<(JavaParserPROVIDES-51))|(1<<(JavaParserWITH-51))|(1<<(JavaParserTRANSITIVE-51))|(1<<(JavaParserVAR-51))|(1<<(JavaParserYIELD-51))|(1<<(JavaParserRECORD-51))|(1<<(JavaParserSEALED-51))|(1<<(JavaParserPERMITS-51)))) != 0) || _la == JavaParserIDENTIFIER {
		{
			p.SetState(709)
			p.Identifier()
		}
		{
			p.SetState(710)
			p.Match(JavaParserDOT)
		}

		p.SetState(716)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(717)
		p.Match(JavaParserTHIS)
	}

	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) {
	this := p
	_ = this

	localctx = NewFormalParameterListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, 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(732)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 76, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(719)
			p.FormalParameter()
		}
		p.SetState(724)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 74, p.GetParserRuleContext())

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

			}
			p.SetState(726)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 74, p.GetParserRuleContext())
		}
		p.SetState(729)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserCOMMA {
			{
				p.SetState(727)
				p.Match(JavaParserCOMMA)
			}
			{
				p.SetState(728)
				p.LastFormalParameter()
			}

		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(731)
			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) {
	this := p
	_ = this

	localctx = NewFormalParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, 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(737)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 77, p.GetParserRuleContext())

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

		}
		p.SetState(739)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 77, p.GetParserRuleContext())
	}
	{
		p.SetState(740)
		p.TypeType()
	}
	{
		p.SetState(741)
		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) AllAnnotation() []IAnnotationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAnnotationContext)(nil)).Elem())
	var tst = make([]IAnnotationContext, len(ts))

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *LastFormalParameterContext) 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) {
	this := p
	_ = this

	localctx = NewLastFormalParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, JavaParserRULE_lastFormalParameter)
	var _la int

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

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

	var _alt int

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

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

		}
		p.SetState(748)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 78, p.GetParserRuleContext())
	}
	{
		p.SetState(749)
		p.TypeType()
	}
	p.SetState(753)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la-51)&-(0x1f+1)) == 0 && ((1<<uint((_la-51)))&((1<<(JavaParserMODULE-51))|(1<<(JavaParserOPEN-51))|(1<<(JavaParserREQUIRES-51))|(1<<(JavaParserEXPORTS-51))|(1<<(JavaParserOPENS-51))|(1<<(JavaParserTO-51))|(1<<(JavaParserUSES-51))|(1<<(JavaParserPROVIDES-51))|(1<<(JavaParserWITH-51))|(1<<(JavaParserTRANSITIVE-51))|(1<<(JavaParserVAR-51))|(1<<(JavaParserYIELD-51))|(1<<(JavaParserRECORD-51))|(1<<(JavaParserSEALED-51))|(1<<(JavaParserPERMITS-51)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(750)
			p.Annotation()
		}

		p.SetState(755)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(756)
		p.Match(JavaParserELLIPSIS)
	}
	{
		p.SetState(757)
		p.VariableDeclaratorId()
	}

	return localctx
}

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

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

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

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

func NewEmptyLambdaLVTIListContext() *LambdaLVTIListContext {
	var p = new(LambdaLVTIListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_lambdaLVTIList
	return p
}

func (*LambdaLVTIListContext) IsLambdaLVTIListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_lambdaLVTIList

	return p
}

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

func (s *LambdaLVTIListContext) AllLambdaLVTIParameter() []ILambdaLVTIParameterContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ILambdaLVTIParameterContext)(nil)).Elem())
	var tst = make([]ILambdaLVTIParameterContext, len(ts))

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

	return tst
}

func (s *LambdaLVTIListContext) LambdaLVTIParameter(i int) ILambdaLVTIParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILambdaLVTIParameterContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ILambdaLVTIParameterContext)
}

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

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

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

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

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

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

func (p *JavaParser) LambdaLVTIList() (localctx ILambdaLVTIListContext) {
	this := p
	_ = this

	localctx = NewLambdaLVTIListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 96, JavaParserRULE_lambdaLVTIList)
	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(759)
		p.LambdaLVTIParameter()
	}
	p.SetState(764)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(760)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(761)
			p.LambdaLVTIParameter()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyLambdaLVTIParameterContext() *LambdaLVTIParameterContext {
	var p = new(LambdaLVTIParameterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_lambdaLVTIParameter
	return p
}

func (*LambdaLVTIParameterContext) IsLambdaLVTIParameterContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_lambdaLVTIParameter

	return p
}

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

func (s *LambdaLVTIParameterContext) VAR() antlr.TerminalNode {
	return s.GetToken(JavaParserVAR, 0)
}

func (s *LambdaLVTIParameterContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IVariableModifierContext)
}

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

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

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

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

func (p *JavaParser) LambdaLVTIParameter() (localctx ILambdaLVTIParameterContext) {
	this := p
	_ = this

	localctx = NewLambdaLVTIParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 98, JavaParserRULE_lambdaLVTIParameter)

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

	defer func() {
		if err := recover(); err != 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(770)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 81, p.GetParserRuleContext())

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

		}
		p.SetState(772)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 81, p.GetParserRuleContext())
	}
	{
		p.SetState(773)
		p.Match(JavaParserVAR)
	}
	{
		p.SetState(774)
		p.Identifier()
	}

	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() []IIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIdentifierContext)(nil)).Elem())
	var tst = make([]IIdentifierContext, len(ts))

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

	return tst
}

func (s *QualifiedNameContext) Identifier(i int) IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewQualifiedNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, 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(776)
		p.Identifier()
	}
	p.SetState(781)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 82, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(777)
				p.Match(JavaParserDOT)
			}
			{
				p.SetState(778)
				p.Identifier()
			}

		}
		p.SetState(783)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 82, 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) TEXT_BLOCK() antlr.TerminalNode {
	return s.GetToken(JavaParserTEXT_BLOCK, 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) {
	this := p
	_ = this

	localctx = NewLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, 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(791)
	p.GetErrorHandler().Sync(p)

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

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

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

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

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

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

	case JavaParserTEXT_BLOCK:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(790)
			p.Match(JavaParserTEXT_BLOCK)
		}

	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) {
	this := p
	_ = this

	localctx = NewIntegerLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 104, 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(793)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-67)&-(0x1f+1)) == 0 && ((1<<uint((_la-67)))&((1<<(JavaParserDECIMAL_LITERAL-67))|(1<<(JavaParserHEX_LITERAL-67))|(1<<(JavaParserOCT_LITERAL-67))|(1<<(JavaParserBINARY_LITERAL-67)))) != 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) {
	this := p
	_ = this

	localctx = NewFloatLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, 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(795)
		_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
}

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

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

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

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

func NewEmptyAltAnnotationQualifiedNameContext() *AltAnnotationQualifiedNameContext {
	var p = new(AltAnnotationQualifiedNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_altAnnotationQualifiedName
	return p
}

func (*AltAnnotationQualifiedNameContext) IsAltAnnotationQualifiedNameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_altAnnotationQualifiedName

	return p
}

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

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

func (s *AltAnnotationQualifiedNameContext) AllIdentifier() []IIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIdentifierContext)(nil)).Elem())
	var tst = make([]IIdentifierContext, len(ts))

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

	return tst
}

func (s *AltAnnotationQualifiedNameContext) Identifier(i int) IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

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

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

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

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

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

func (p *JavaParser) AltAnnotationQualifiedName() (localctx IAltAnnotationQualifiedNameContext) {
	this := p
	_ = this

	localctx = NewAltAnnotationQualifiedNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, JavaParserRULE_altAnnotationQualifiedName)
	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(802)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la-51)&-(0x1f+1)) == 0 && ((1<<uint((_la-51)))&((1<<(JavaParserMODULE-51))|(1<<(JavaParserOPEN-51))|(1<<(JavaParserREQUIRES-51))|(1<<(JavaParserEXPORTS-51))|(1<<(JavaParserOPENS-51))|(1<<(JavaParserTO-51))|(1<<(JavaParserUSES-51))|(1<<(JavaParserPROVIDES-51))|(1<<(JavaParserWITH-51))|(1<<(JavaParserTRANSITIVE-51))|(1<<(JavaParserVAR-51))|(1<<(JavaParserYIELD-51))|(1<<(JavaParserRECORD-51))|(1<<(JavaParserSEALED-51))|(1<<(JavaParserPERMITS-51)))) != 0) || _la == JavaParserIDENTIFIER {
		{
			p.SetState(797)
			p.Identifier()
		}
		{
			p.SetState(798)
			p.Match(JavaParserDOT)
		}

		p.SetState(804)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(805)
		p.Match(JavaParserAT)
	}
	{
		p.SetState(806)
		p.Identifier()
	}

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

	if t == nil {
		return nil
	}

	return t.(IAltAnnotationQualifiedNameContext)
}

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) {
	this := p
	_ = this

	localctx = NewAnnotationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, 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(811)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 85, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(808)
			p.Match(JavaParserAT)
		}
		{
			p.SetState(809)
			p.QualifiedName()
		}

	case 2:
		{
			p.SetState(810)
			p.AltAnnotationQualifiedName()
		}

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

	if _la == JavaParserLPAREN {
		{
			p.SetState(813)
			p.Match(JavaParserLPAREN)
		}
		p.SetState(816)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 86, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(814)
				p.ElementValuePairs()
			}

		} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 86, p.GetParserRuleContext()) == 2 {
			{
				p.SetState(815)
				p.ElementValue()
			}

		}
		{
			p.SetState(818)
			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) {
	this := p
	_ = this

	localctx = NewElementValuePairsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 112, 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(821)
		p.ElementValuePair()
	}
	p.SetState(826)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(822)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(823)
			p.ElementValuePair()
		}

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

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewElementValuePairContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 114, 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(829)
		p.Identifier()
	}
	{
		p.SetState(830)
		p.Match(JavaParserASSIGN)
	}
	{
		p.SetState(831)
		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) {
	this := p
	_ = this

	localctx = NewElementValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, 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(836)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 89, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(833)
			p.expression(0)
		}

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

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(835)
			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) {
	this := p
	_ = this

	localctx = NewElementValueArrayInitializerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, 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(838)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(847)
	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<<(JavaParserSWITCH-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserMODULE-37))|(1<<(JavaParserOPEN-37))|(1<<(JavaParserREQUIRES-37))|(1<<(JavaParserEXPORTS-37))|(1<<(JavaParserOPENS-37))|(1<<(JavaParserTO-37))|(1<<(JavaParserUSES-37))|(1<<(JavaParserPROVIDES-37))|(1<<(JavaParserWITH-37))|(1<<(JavaParserTRANSITIVE-37))|(1<<(JavaParserVAR-37))|(1<<(JavaParserYIELD-37))|(1<<(JavaParserRECORD-37))|(1<<(JavaParserSEALED-37))|(1<<(JavaParserPERMITS-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(JavaParserOCT_LITERAL-69))|(1<<(JavaParserBINARY_LITERAL-69))|(1<<(JavaParserFLOAT_LITERAL-69))|(1<<(JavaParserHEX_FLOAT_LITERAL-69))|(1<<(JavaParserBOOL_LITERAL-69))|(1<<(JavaParserCHAR_LITERAL-69))|(1<<(JavaParserSTRING_LITERAL-69))|(1<<(JavaParserTEXT_BLOCK-69))|(1<<(JavaParserNULL_LITERAL-69))|(1<<(JavaParserLPAREN-69))|(1<<(JavaParserLBRACE-69))|(1<<(JavaParserLT-69))|(1<<(JavaParserBANG-69))|(1<<(JavaParserTILDE-69))|(1<<(JavaParserINC-69)))) != 0) || (((_la-101)&-(0x1f+1)) == 0 && ((1<<uint((_la-101)))&((1<<(JavaParserDEC-101))|(1<<(JavaParserADD-101))|(1<<(JavaParserSUB-101))|(1<<(JavaParserAT-101))|(1<<(JavaParserIDENTIFIER-101)))) != 0) {
		{
			p.SetState(839)
			p.ElementValue()
		}
		p.SetState(844)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 90, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(840)
					p.Match(JavaParserCOMMA)
				}
				{
					p.SetState(841)
					p.ElementValue()
				}

			}
			p.SetState(846)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 90, p.GetParserRuleContext())
		}

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

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

	}
	{
		p.SetState(852)
		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() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewAnnotationTypeDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, 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(854)
		p.Match(JavaParserAT)
	}
	{
		p.SetState(855)
		p.Match(JavaParserINTERFACE)
	}
	{
		p.SetState(856)
		p.Identifier()
	}
	{
		p.SetState(857)
		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) {
	this := p
	_ = this

	localctx = NewAnnotationTypeBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 122, 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(859)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(863)
	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))|(1<<(JavaParserMODULE-33))|(1<<(JavaParserOPEN-33))|(1<<(JavaParserREQUIRES-33))|(1<<(JavaParserEXPORTS-33))|(1<<(JavaParserOPENS-33))|(1<<(JavaParserTO-33))|(1<<(JavaParserUSES-33))|(1<<(JavaParserPROVIDES-33))|(1<<(JavaParserWITH-33))|(1<<(JavaParserTRANSITIVE-33))|(1<<(JavaParserVAR-33))|(1<<(JavaParserYIELD-33))|(1<<(JavaParserRECORD-33))|(1<<(JavaParserSEALED-33)))) != 0) || (((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(JavaParserPERMITS-65))|(1<<(JavaParserNON_SEALED-65))|(1<<(JavaParserSEMI-65)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(860)
			p.AnnotationTypeElementDeclaration()
		}

		p.SetState(865)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(866)
		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) {
	this := p
	_ = this

	localctx = NewAnnotationTypeElementDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 124, 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(876)
	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, JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserNON_SEALED, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(871)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 94, p.GetParserRuleContext())

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

			}
			p.SetState(873)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 94, p.GetParserRuleContext())
		}
		{
			p.SetState(874)
			p.AnnotationTypeElementRest()
		}

	case JavaParserSEMI:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(875)
			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) RecordDeclaration() IRecordDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRecordDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRecordDeclarationContext)
}

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) {
	this := p
	_ = this

	localctx = NewAnnotationTypeElementRestContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 126, 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(902)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 101, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(878)
			p.TypeType()
		}
		{
			p.SetState(879)
			p.AnnotationMethodOrConstantRest()
		}
		{
			p.SetState(880)
			p.Match(JavaParserSEMI)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(882)
			p.ClassDeclaration()
		}
		p.SetState(884)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 96, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(883)
				p.Match(JavaParserSEMI)
			}

		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(886)
			p.InterfaceDeclaration()
		}
		p.SetState(888)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 97, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(887)
				p.Match(JavaParserSEMI)
			}

		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(890)
			p.EnumDeclaration()
		}
		p.SetState(892)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 98, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(891)
				p.Match(JavaParserSEMI)
			}

		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(894)
			p.AnnotationTypeDeclaration()
		}
		p.SetState(896)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 99, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(895)
				p.Match(JavaParserSEMI)
			}

		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(898)
			p.RecordDeclaration()
		}
		p.SetState(900)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 100, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(899)
				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) {
	this := p
	_ = this

	localctx = NewAnnotationMethodOrConstantRestContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 128, 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(906)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 102, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(904)
			p.AnnotationMethodRest()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(905)
			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() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewAnnotationMethodRestContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 130, 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(908)
		p.Identifier()
	}
	{
		p.SetState(909)
		p.Match(JavaParserLPAREN)
	}
	{
		p.SetState(910)
		p.Match(JavaParserRPAREN)
	}
	p.SetState(912)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserDEFAULT {
		{
			p.SetState(911)
			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) {
	this := p
	_ = this

	localctx = NewAnnotationConstantRestContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 132, 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(914)
		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) {
	this := p
	_ = this

	localctx = NewDefaultValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 134, 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(916)
		p.Match(JavaParserDEFAULT)
	}
	{
		p.SetState(917)
		p.ElementValue()
	}

	return localctx
}

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

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

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

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

func NewEmptyModuleDeclarationContext() *ModuleDeclarationContext {
	var p = new(ModuleDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_moduleDeclaration
	return p
}

func (*ModuleDeclarationContext) IsModuleDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_moduleDeclaration

	return p
}

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

func (s *ModuleDeclarationContext) MODULE() antlr.TerminalNode {
	return s.GetToken(JavaParserMODULE, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IQualifiedNameContext)
}

func (s *ModuleDeclarationContext) ModuleBody() IModuleBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModuleBodyContext)
}

func (s *ModuleDeclarationContext) OPEN() antlr.TerminalNode {
	return s.GetToken(JavaParserOPEN, 0)
}

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

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

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

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

func (p *JavaParser) ModuleDeclaration() (localctx IModuleDeclarationContext) {
	this := p
	_ = this

	localctx = NewModuleDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 136, JavaParserRULE_moduleDeclaration)
	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(920)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserOPEN {
		{
			p.SetState(919)
			p.Match(JavaParserOPEN)
		}

	}
	{
		p.SetState(922)
		p.Match(JavaParserMODULE)
	}
	{
		p.SetState(923)
		p.QualifiedName()
	}
	{
		p.SetState(924)
		p.ModuleBody()
	}

	return localctx
}

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

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

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

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

func NewEmptyModuleBodyContext() *ModuleBodyContext {
	var p = new(ModuleBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_moduleBody
	return p
}

func (*ModuleBodyContext) IsModuleBodyContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_moduleBody

	return p
}

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

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

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

func (s *ModuleBodyContext) AllModuleDirective() []IModuleDirectiveContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IModuleDirectiveContext)(nil)).Elem())
	var tst = make([]IModuleDirectiveContext, len(ts))

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

	return tst
}

func (s *ModuleBodyContext) ModuleDirective(i int) IModuleDirectiveContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModuleDirectiveContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IModuleDirectiveContext)
}

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

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

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

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

func (p *JavaParser) ModuleBody() (localctx IModuleBodyContext) {
	this := p
	_ = this

	localctx = NewModuleBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 138, JavaParserRULE_moduleBody)
	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(926)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(930)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ((_la-53)&-(0x1f+1)) == 0 && ((1<<uint((_la-53)))&((1<<(JavaParserREQUIRES-53))|(1<<(JavaParserEXPORTS-53))|(1<<(JavaParserOPENS-53))|(1<<(JavaParserUSES-53))|(1<<(JavaParserPROVIDES-53)))) != 0 {
		{
			p.SetState(927)
			p.ModuleDirective()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyModuleDirectiveContext() *ModuleDirectiveContext {
	var p = new(ModuleDirectiveContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_moduleDirective
	return p
}

func (*ModuleDirectiveContext) IsModuleDirectiveContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_moduleDirective

	return p
}

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

func (s *ModuleDirectiveContext) REQUIRES() antlr.TerminalNode {
	return s.GetToken(JavaParserREQUIRES, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IQualifiedNameContext)
}

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

func (s *ModuleDirectiveContext) AllRequiresModifier() []IRequiresModifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IRequiresModifierContext)(nil)).Elem())
	var tst = make([]IRequiresModifierContext, len(ts))

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

	return tst
}

func (s *ModuleDirectiveContext) RequiresModifier(i int) IRequiresModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRequiresModifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IRequiresModifierContext)
}

func (s *ModuleDirectiveContext) EXPORTS() antlr.TerminalNode {
	return s.GetToken(JavaParserEXPORTS, 0)
}

func (s *ModuleDirectiveContext) TO() antlr.TerminalNode {
	return s.GetToken(JavaParserTO, 0)
}

func (s *ModuleDirectiveContext) OPENS() antlr.TerminalNode {
	return s.GetToken(JavaParserOPENS, 0)
}

func (s *ModuleDirectiveContext) USES() antlr.TerminalNode {
	return s.GetToken(JavaParserUSES, 0)
}

func (s *ModuleDirectiveContext) PROVIDES() antlr.TerminalNode {
	return s.GetToken(JavaParserPROVIDES, 0)
}

func (s *ModuleDirectiveContext) WITH() antlr.TerminalNode {
	return s.GetToken(JavaParserWITH, 0)
}

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

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

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

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

func (p *JavaParser) ModuleDirective() (localctx IModuleDirectiveContext) {
	this := p
	_ = this

	localctx = NewModuleDirectiveContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 140, JavaParserRULE_moduleDirective)
	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(971)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserREQUIRES:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(935)
			p.Match(JavaParserREQUIRES)
		}
		p.SetState(939)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 106, p.GetParserRuleContext())

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

			}
			p.SetState(941)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 106, p.GetParserRuleContext())
		}
		{
			p.SetState(942)
			p.QualifiedName()
		}
		{
			p.SetState(943)
			p.Match(JavaParserSEMI)
		}

	case JavaParserEXPORTS:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(945)
			p.Match(JavaParserEXPORTS)
		}
		{
			p.SetState(946)
			p.QualifiedName()
		}
		p.SetState(949)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserTO {
			{
				p.SetState(947)
				p.Match(JavaParserTO)
			}
			{
				p.SetState(948)
				p.QualifiedName()
			}

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

	case JavaParserOPENS:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(953)
			p.Match(JavaParserOPENS)
		}
		{
			p.SetState(954)
			p.QualifiedName()
		}
		p.SetState(957)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserTO {
			{
				p.SetState(955)
				p.Match(JavaParserTO)
			}
			{
				p.SetState(956)
				p.QualifiedName()
			}

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

	case JavaParserUSES:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(961)
			p.Match(JavaParserUSES)
		}
		{
			p.SetState(962)
			p.QualifiedName()
		}
		{
			p.SetState(963)
			p.Match(JavaParserSEMI)
		}

	case JavaParserPROVIDES:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(965)
			p.Match(JavaParserPROVIDES)
		}
		{
			p.SetState(966)
			p.QualifiedName()
		}
		{
			p.SetState(967)
			p.Match(JavaParserWITH)
		}
		{
			p.SetState(968)
			p.QualifiedName()
		}
		{
			p.SetState(969)
			p.Match(JavaParserSEMI)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyRequiresModifierContext() *RequiresModifierContext {
	var p = new(RequiresModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_requiresModifier
	return p
}

func (*RequiresModifierContext) IsRequiresModifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_requiresModifier

	return p
}

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

func (s *RequiresModifierContext) TRANSITIVE() antlr.TerminalNode {
	return s.GetToken(JavaParserTRANSITIVE, 0)
}

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

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

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

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

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

func (p *JavaParser) RequiresModifier() (localctx IRequiresModifierContext) {
	this := p
	_ = this

	localctx = NewRequiresModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 142, JavaParserRULE_requiresModifier)
	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(973)
		_la = p.GetTokenStream().LA(1)

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

	return localctx
}

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

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

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

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

func NewEmptyRecordDeclarationContext() *RecordDeclarationContext {
	var p = new(RecordDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_recordDeclaration
	return p
}

func (*RecordDeclarationContext) IsRecordDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_recordDeclaration

	return p
}

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

func (s *RecordDeclarationContext) RECORD() antlr.TerminalNode {
	return s.GetToken(JavaParserRECORD, 0)
}

func (s *RecordDeclarationContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *RecordDeclarationContext) RecordHeader() IRecordHeaderContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRecordHeaderContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRecordHeaderContext)
}

func (s *RecordDeclarationContext) RecordBody() IRecordBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRecordBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRecordBodyContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

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

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

	if t == nil {
		return nil
	}

	return t.(ITypeListContext)
}

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

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

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

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

func (p *JavaParser) RecordDeclaration() (localctx IRecordDeclarationContext) {
	this := p
	_ = this

	localctx = NewRecordDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 144, JavaParserRULE_recordDeclaration)
	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.Match(JavaParserRECORD)
	}
	{
		p.SetState(976)
		p.Identifier()
	}
	p.SetState(978)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

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

	}
	{
		p.SetState(980)
		p.RecordHeader()
	}
	p.SetState(983)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserIMPLEMENTS {
		{
			p.SetState(981)
			p.Match(JavaParserIMPLEMENTS)
		}
		{
			p.SetState(982)
			p.TypeList()
		}

	}
	{
		p.SetState(985)
		p.RecordBody()
	}

	return localctx
}

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

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

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

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

func NewEmptyRecordHeaderContext() *RecordHeaderContext {
	var p = new(RecordHeaderContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_recordHeader
	return p
}

func (*RecordHeaderContext) IsRecordHeaderContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_recordHeader

	return p
}

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

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

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

func (s *RecordHeaderContext) RecordComponentList() IRecordComponentListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRecordComponentListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRecordComponentListContext)
}

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

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

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

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

func (p *JavaParser) RecordHeader() (localctx IRecordHeaderContext) {
	this := p
	_ = this

	localctx = NewRecordHeaderContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 146, JavaParserRULE_recordHeader)
	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(987)
		p.Match(JavaParserLPAREN)
	}
	p.SetState(989)
	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))) != 0) || (((_la-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(JavaParserSHORT-37))|(1<<(JavaParserMODULE-37))|(1<<(JavaParserOPEN-37))|(1<<(JavaParserREQUIRES-37))|(1<<(JavaParserEXPORTS-37))|(1<<(JavaParserOPENS-37))|(1<<(JavaParserTO-37))|(1<<(JavaParserUSES-37))|(1<<(JavaParserPROVIDES-37))|(1<<(JavaParserWITH-37))|(1<<(JavaParserTRANSITIVE-37))|(1<<(JavaParserVAR-37))|(1<<(JavaParserYIELD-37))|(1<<(JavaParserRECORD-37))|(1<<(JavaParserSEALED-37))|(1<<(JavaParserPERMITS-37)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(988)
			p.RecordComponentList()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyRecordComponentListContext() *RecordComponentListContext {
	var p = new(RecordComponentListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_recordComponentList
	return p
}

func (*RecordComponentListContext) IsRecordComponentListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_recordComponentList

	return p
}

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

func (s *RecordComponentListContext) AllRecordComponent() []IRecordComponentContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IRecordComponentContext)(nil)).Elem())
	var tst = make([]IRecordComponentContext, len(ts))

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

	return tst
}

func (s *RecordComponentListContext) RecordComponent(i int) IRecordComponentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRecordComponentContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IRecordComponentContext)
}

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

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

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

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

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

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

func (p *JavaParser) RecordComponentList() (localctx IRecordComponentListContext) {
	this := p
	_ = this

	localctx = NewRecordComponentListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 148, JavaParserRULE_recordComponentList)
	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(993)
		p.RecordComponent()
	}
	p.SetState(998)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(994)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(995)
			p.RecordComponent()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyRecordComponentContext() *RecordComponentContext {
	var p = new(RecordComponentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_recordComponent
	return p
}

func (*RecordComponentContext) IsRecordComponentContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_recordComponent

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *RecordComponentContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

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

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

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

func (p *JavaParser) RecordComponent() (localctx IRecordComponentContext) {
	this := p
	_ = this

	localctx = NewRecordComponentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 150, JavaParserRULE_recordComponent)

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

	defer func() {
		if err := recover(); err != nil {
			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(1001)
		p.TypeType()
	}
	{
		p.SetState(1002)
		p.Identifier()
	}

	return localctx
}

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

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

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

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

func NewEmptyRecordBodyContext() *RecordBodyContext {
	var p = new(RecordBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_recordBody
	return p
}

func (*RecordBodyContext) IsRecordBodyContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_recordBody

	return p
}

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

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

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

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

	if t == nil {
		return nil
	}

	return t.(IClassBodyDeclarationContext)
}

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

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

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

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

func (p *JavaParser) RecordBody() (localctx IRecordBodyContext) {
	this := p
	_ = this

	localctx = NewRecordBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 152, JavaParserRULE_recordBody)
	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(1004)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(1008)
	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<<(JavaParserMODULE-33))|(1<<(JavaParserOPEN-33))|(1<<(JavaParserREQUIRES-33))|(1<<(JavaParserEXPORTS-33))|(1<<(JavaParserOPENS-33))|(1<<(JavaParserTO-33))|(1<<(JavaParserUSES-33))|(1<<(JavaParserPROVIDES-33))|(1<<(JavaParserWITH-33))|(1<<(JavaParserTRANSITIVE-33))|(1<<(JavaParserVAR-33))|(1<<(JavaParserYIELD-33))|(1<<(JavaParserRECORD-33))|(1<<(JavaParserSEALED-33)))) != 0) || (((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(JavaParserPERMITS-65))|(1<<(JavaParserNON_SEALED-65))|(1<<(JavaParserLBRACE-65))|(1<<(JavaParserSEMI-65))|(1<<(JavaParserLT-65)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
		{
			p.SetState(1005)
			p.ClassBodyDeclaration()
		}

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

	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) {
	this := p
	_ = this

	localctx = NewBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 154, 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(1013)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(1017)
	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<<(JavaParserMODULE-33))|(1<<(JavaParserOPEN-33))|(1<<(JavaParserREQUIRES-33))|(1<<(JavaParserEXPORTS-33))|(1<<(JavaParserOPENS-33))|(1<<(JavaParserTO-33))|(1<<(JavaParserUSES-33))|(1<<(JavaParserPROVIDES-33))|(1<<(JavaParserWITH-33))|(1<<(JavaParserTRANSITIVE-33))|(1<<(JavaParserVAR-33))|(1<<(JavaParserYIELD-33))|(1<<(JavaParserRECORD-33))|(1<<(JavaParserSEALED-33)))) != 0) || (((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(JavaParserPERMITS-65))|(1<<(JavaParserNON_SEALED-65))|(1<<(JavaParserDECIMAL_LITERAL-65))|(1<<(JavaParserHEX_LITERAL-65))|(1<<(JavaParserOCT_LITERAL-65))|(1<<(JavaParserBINARY_LITERAL-65))|(1<<(JavaParserFLOAT_LITERAL-65))|(1<<(JavaParserHEX_FLOAT_LITERAL-65))|(1<<(JavaParserBOOL_LITERAL-65))|(1<<(JavaParserCHAR_LITERAL-65))|(1<<(JavaParserSTRING_LITERAL-65))|(1<<(JavaParserTEXT_BLOCK-65))|(1<<(JavaParserNULL_LITERAL-65))|(1<<(JavaParserLPAREN-65))|(1<<(JavaParserLBRACE-65))|(1<<(JavaParserSEMI-65))|(1<<(JavaParserLT-65))|(1<<(JavaParserBANG-65))|(1<<(JavaParserTILDE-65)))) != 0) || (((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(JavaParserINC-100))|(1<<(JavaParserDEC-100))|(1<<(JavaParserADD-100))|(1<<(JavaParserSUB-100))|(1<<(JavaParserAT-100))|(1<<(JavaParserIDENTIFIER-100)))) != 0) {
		{
			p.SetState(1014)
			p.BlockStatement()
		}

		p.SetState(1019)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1020)
		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) {
	this := p
	_ = this

	localctx = NewBlockStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 156, 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(1027)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 116, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1022)
			p.LocalVariableDeclaration()
		}
		{
			p.SetState(1023)
			p.Match(JavaParserSEMI)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1025)
			p.Statement()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1026)
			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) VAR() antlr.TerminalNode {
	return s.GetToken(JavaParserVAR, 0)
}

func (s *LocalVariableDeclarationContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

func (s *LocalVariableDeclarationContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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) {
	this := p
	_ = this

	localctx = NewLocalVariableDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 158, 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(1032)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 117, p.GetParserRuleContext())

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

		}
		p.SetState(1034)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 117, p.GetParserRuleContext())
	}
	p.SetState(1043)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 118, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1035)
			p.TypeType()
		}
		{
			p.SetState(1036)
			p.VariableDeclarators()
		}

	case 2:
		{
			p.SetState(1038)
			p.Match(JavaParserVAR)
		}
		{
			p.SetState(1039)
			p.Identifier()
		}
		{
			p.SetState(1040)
			p.Match(JavaParserASSIGN)
		}
		{
			p.SetState(1041)
			p.expression(0)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyIdentifierContext() *IdentifierContext {
	var p = new(IdentifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_identifier
	return p
}

func (*IdentifierContext) IsIdentifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_identifier

	return p
}

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

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

func (s *IdentifierContext) MODULE() antlr.TerminalNode {
	return s.GetToken(JavaParserMODULE, 0)
}

func (s *IdentifierContext) OPEN() antlr.TerminalNode {
	return s.GetToken(JavaParserOPEN, 0)
}

func (s *IdentifierContext) REQUIRES() antlr.TerminalNode {
	return s.GetToken(JavaParserREQUIRES, 0)
}

func (s *IdentifierContext) EXPORTS() antlr.TerminalNode {
	return s.GetToken(JavaParserEXPORTS, 0)
}

func (s *IdentifierContext) OPENS() antlr.TerminalNode {
	return s.GetToken(JavaParserOPENS, 0)
}

func (s *IdentifierContext) TO() antlr.TerminalNode {
	return s.GetToken(JavaParserTO, 0)
}

func (s *IdentifierContext) USES() antlr.TerminalNode {
	return s.GetToken(JavaParserUSES, 0)
}

func (s *IdentifierContext) PROVIDES() antlr.TerminalNode {
	return s.GetToken(JavaParserPROVIDES, 0)
}

func (s *IdentifierContext) WITH() antlr.TerminalNode {
	return s.GetToken(JavaParserWITH, 0)
}

func (s *IdentifierContext) TRANSITIVE() antlr.TerminalNode {
	return s.GetToken(JavaParserTRANSITIVE, 0)
}

func (s *IdentifierContext) YIELD() antlr.TerminalNode {
	return s.GetToken(JavaParserYIELD, 0)
}

func (s *IdentifierContext) SEALED() antlr.TerminalNode {
	return s.GetToken(JavaParserSEALED, 0)
}

func (s *IdentifierContext) PERMITS() antlr.TerminalNode {
	return s.GetToken(JavaParserPERMITS, 0)
}

func (s *IdentifierContext) RECORD() antlr.TerminalNode {
	return s.GetToken(JavaParserRECORD, 0)
}

func (s *IdentifierContext) VAR() antlr.TerminalNode {
	return s.GetToken(JavaParserVAR, 0)
}

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

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

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

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

func (p *JavaParser) Identifier() (localctx IIdentifierContext) {
	this := p
	_ = this

	localctx = NewIdentifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 160, JavaParserRULE_identifier)
	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(1045)
		_la = p.GetTokenStream().LA(1)

		if !((((_la-51)&-(0x1f+1)) == 0 && ((1<<uint((_la-51)))&((1<<(JavaParserMODULE-51))|(1<<(JavaParserOPEN-51))|(1<<(JavaParserREQUIRES-51))|(1<<(JavaParserEXPORTS-51))|(1<<(JavaParserOPENS-51))|(1<<(JavaParserTO-51))|(1<<(JavaParserUSES-51))|(1<<(JavaParserPROVIDES-51))|(1<<(JavaParserWITH-51))|(1<<(JavaParserTRANSITIVE-51))|(1<<(JavaParserVAR-51))|(1<<(JavaParserYIELD-51))|(1<<(JavaParserRECORD-51))|(1<<(JavaParserSEALED-51))|(1<<(JavaParserPERMITS-51)))) != 0) || _la == JavaParserIDENTIFIER) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

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

	if t == nil {
		return nil
	}

	return t.(IRecordDeclarationContext)
}

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) {
	this := p
	_ = this

	localctx = NewLocalTypeDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 162, JavaParserRULE_localTypeDeclaration)

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

	defer func() {
		if err := recover(); err != 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(1059)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserABSTRACT, JavaParserCLASS, JavaParserFINAL, JavaParserINTERFACE, JavaParserPRIVATE, JavaParserPROTECTED, JavaParserPUBLIC, JavaParserSTATIC, JavaParserSTRICTFP, JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserNON_SEALED, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(1050)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 119, p.GetParserRuleContext())

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

			}
			p.SetState(1052)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 119, p.GetParserRuleContext())
		}
		p.SetState(1056)
		p.GetErrorHandler().Sync(p)

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

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

		case JavaParserRECORD:
			{
				p.SetState(1055)
				p.RecordDeclaration()
			}

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

	case JavaParserSEMI:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1058)
			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

	// GetBlockLabel returns the blockLabel rule contexts.
	GetBlockLabel() IBlockContext

	// GetStatementExpression returns the statementExpression rule contexts.
	GetStatementExpression() IExpressionContext

	// GetIdentifierLabel returns the identifierLabel rule contexts.
	GetIdentifierLabel() IIdentifierContext

	// SetBlockLabel sets the blockLabel rule contexts.
	SetBlockLabel(IBlockContext)

	// SetStatementExpression sets the statementExpression rule contexts.
	SetStatementExpression(IExpressionContext)

	// SetIdentifierLabel sets the identifierLabel rule contexts.
	SetIdentifierLabel(IIdentifierContext)

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

type StatementContext struct {
	*antlr.BaseParserRuleContext
	parser              antlr.Parser
	blockLabel          IBlockContext
	statementExpression IExpressionContext
	identifierLabel     IIdentifierContext
}

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) GetBlockLabel() IBlockContext { return s.blockLabel }

func (s *StatementContext) GetStatementExpression() IExpressionContext { return s.statementExpression }

func (s *StatementContext) GetIdentifierLabel() IIdentifierContext { return s.identifierLabel }

func (s *StatementContext) SetBlockLabel(v IBlockContext) { s.blockLabel = v }

func (s *StatementContext) SetStatementExpression(v IExpressionContext) { s.statementExpression = v }

func (s *StatementContext) SetIdentifierLabel(v IIdentifierContext) { s.identifierLabel = 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() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

func (s *StatementContext) CONTINUE() antlr.TerminalNode {
	return s.GetToken(JavaParserCONTINUE, 0)
}

func (s *StatementContext) YIELD() antlr.TerminalNode {
	return s.GetToken(JavaParserYIELD, 0)
}

func (s *StatementContext) SwitchExpression() ISwitchExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISwitchExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISwitchExpressionContext)
}

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) {
	this := p
	_ = this

	localctx = NewStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 164, 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(1174)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 135, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1061)

			var _x = p.Block()

			localctx.(*StatementContext).blockLabel = _x
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1062)
			p.Match(JavaParserASSERT)
		}
		{
			p.SetState(1063)
			p.expression(0)
		}
		p.SetState(1066)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserCOLON {
			{
				p.SetState(1064)
				p.Match(JavaParserCOLON)
			}
			{
				p.SetState(1065)
				p.expression(0)
			}

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

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1070)
			p.Match(JavaParserIF)
		}
		{
			p.SetState(1071)
			p.ParExpression()
		}
		{
			p.SetState(1072)
			p.Statement()
		}
		p.SetState(1075)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 123, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1073)
				p.Match(JavaParserELSE)
			}
			{
				p.SetState(1074)
				p.Statement()
			}

		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1077)
			p.Match(JavaParserFOR)
		}
		{
			p.SetState(1078)
			p.Match(JavaParserLPAREN)
		}
		{
			p.SetState(1079)
			p.ForControl()
		}
		{
			p.SetState(1080)
			p.Match(JavaParserRPAREN)
		}
		{
			p.SetState(1081)
			p.Statement()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1083)
			p.Match(JavaParserWHILE)
		}
		{
			p.SetState(1084)
			p.ParExpression()
		}
		{
			p.SetState(1085)
			p.Statement()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1087)
			p.Match(JavaParserDO)
		}
		{
			p.SetState(1088)
			p.Statement()
		}
		{
			p.SetState(1089)
			p.Match(JavaParserWHILE)
		}
		{
			p.SetState(1090)
			p.ParExpression()
		}
		{
			p.SetState(1091)
			p.Match(JavaParserSEMI)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1093)
			p.Match(JavaParserTRY)
		}
		{
			p.SetState(1094)
			p.Block()
		}
		p.SetState(1104)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case JavaParserCATCH:
			p.SetState(1096)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for ok := true; ok; ok = _la == JavaParserCATCH {
				{
					p.SetState(1095)
					p.CatchClause()
				}

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

			if _la == JavaParserFINALLY {
				{
					p.SetState(1100)
					p.FinallyBlock()
				}

			}

		case JavaParserFINALLY:
			{
				p.SetState(1103)
				p.FinallyBlock()
			}

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

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(1106)
			p.Match(JavaParserTRY)
		}
		{
			p.SetState(1107)
			p.ResourceSpecification()
		}
		{
			p.SetState(1108)
			p.Block()
		}
		p.SetState(1112)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == JavaParserCATCH {
			{
				p.SetState(1109)
				p.CatchClause()
			}

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

		if _la == JavaParserFINALLY {
			{
				p.SetState(1115)
				p.FinallyBlock()
			}

		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(1118)
			p.Match(JavaParserSWITCH)
		}
		{
			p.SetState(1119)
			p.ParExpression()
		}
		{
			p.SetState(1120)
			p.Match(JavaParserLBRACE)
		}
		p.SetState(1124)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 129, p.GetParserRuleContext())

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

			}
			p.SetState(1126)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 129, p.GetParserRuleContext())
		}
		p.SetState(1130)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == JavaParserCASE || _la == JavaParserDEFAULT {
			{
				p.SetState(1127)
				p.SwitchLabel()
			}

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

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(1135)
			p.Match(JavaParserSYNCHRONIZED)
		}
		{
			p.SetState(1136)
			p.ParExpression()
		}
		{
			p.SetState(1137)
			p.Block()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(1139)
			p.Match(JavaParserRETURN)
		}
		p.SetState(1141)
		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<<(JavaParserSWITCH-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserMODULE-37))|(1<<(JavaParserOPEN-37))|(1<<(JavaParserREQUIRES-37))|(1<<(JavaParserEXPORTS-37))|(1<<(JavaParserOPENS-37))|(1<<(JavaParserTO-37))|(1<<(JavaParserUSES-37))|(1<<(JavaParserPROVIDES-37))|(1<<(JavaParserWITH-37))|(1<<(JavaParserTRANSITIVE-37))|(1<<(JavaParserVAR-37))|(1<<(JavaParserYIELD-37))|(1<<(JavaParserRECORD-37))|(1<<(JavaParserSEALED-37))|(1<<(JavaParserPERMITS-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(JavaParserOCT_LITERAL-69))|(1<<(JavaParserBINARY_LITERAL-69))|(1<<(JavaParserFLOAT_LITERAL-69))|(1<<(JavaParserHEX_FLOAT_LITERAL-69))|(1<<(JavaParserBOOL_LITERAL-69))|(1<<(JavaParserCHAR_LITERAL-69))|(1<<(JavaParserSTRING_LITERAL-69))|(1<<(JavaParserTEXT_BLOCK-69))|(1<<(JavaParserNULL_LITERAL-69))|(1<<(JavaParserLPAREN-69))|(1<<(JavaParserLT-69))|(1<<(JavaParserBANG-69))|(1<<(JavaParserTILDE-69))|(1<<(JavaParserINC-69)))) != 0) || (((_la-101)&-(0x1f+1)) == 0 && ((1<<uint((_la-101)))&((1<<(JavaParserDEC-101))|(1<<(JavaParserADD-101))|(1<<(JavaParserSUB-101))|(1<<(JavaParserAT-101))|(1<<(JavaParserIDENTIFIER-101)))) != 0) {
			{
				p.SetState(1140)
				p.expression(0)
			}

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

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(1144)
			p.Match(JavaParserTHROW)
		}
		{
			p.SetState(1145)
			p.expression(0)
		}
		{
			p.SetState(1146)
			p.Match(JavaParserSEMI)
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(1148)
			p.Match(JavaParserBREAK)
		}
		p.SetState(1150)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la-51)&-(0x1f+1)) == 0 && ((1<<uint((_la-51)))&((1<<(JavaParserMODULE-51))|(1<<(JavaParserOPEN-51))|(1<<(JavaParserREQUIRES-51))|(1<<(JavaParserEXPORTS-51))|(1<<(JavaParserOPENS-51))|(1<<(JavaParserTO-51))|(1<<(JavaParserUSES-51))|(1<<(JavaParserPROVIDES-51))|(1<<(JavaParserWITH-51))|(1<<(JavaParserTRANSITIVE-51))|(1<<(JavaParserVAR-51))|(1<<(JavaParserYIELD-51))|(1<<(JavaParserRECORD-51))|(1<<(JavaParserSEALED-51))|(1<<(JavaParserPERMITS-51)))) != 0) || _la == JavaParserIDENTIFIER {
			{
				p.SetState(1149)
				p.Identifier()
			}

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

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(1153)
			p.Match(JavaParserCONTINUE)
		}
		p.SetState(1155)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la-51)&-(0x1f+1)) == 0 && ((1<<uint((_la-51)))&((1<<(JavaParserMODULE-51))|(1<<(JavaParserOPEN-51))|(1<<(JavaParserREQUIRES-51))|(1<<(JavaParserEXPORTS-51))|(1<<(JavaParserOPENS-51))|(1<<(JavaParserTO-51))|(1<<(JavaParserUSES-51))|(1<<(JavaParserPROVIDES-51))|(1<<(JavaParserWITH-51))|(1<<(JavaParserTRANSITIVE-51))|(1<<(JavaParserVAR-51))|(1<<(JavaParserYIELD-51))|(1<<(JavaParserRECORD-51))|(1<<(JavaParserSEALED-51))|(1<<(JavaParserPERMITS-51)))) != 0) || _la == JavaParserIDENTIFIER {
			{
				p.SetState(1154)
				p.Identifier()
			}

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

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(1158)
			p.Match(JavaParserYIELD)
		}
		{
			p.SetState(1159)
			p.expression(0)
		}
		{
			p.SetState(1160)
			p.Match(JavaParserSEMI)
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(1162)
			p.Match(JavaParserSEMI)
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(1163)

			var _x = p.expression(0)

			localctx.(*StatementContext).statementExpression = _x
		}
		{
			p.SetState(1164)
			p.Match(JavaParserSEMI)
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(1166)
			p.SwitchExpression()
		}
		p.SetState(1168)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 134, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1167)
				p.Match(JavaParserSEMI)
			}

		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(1170)

			var _x = p.Identifier()

			localctx.(*StatementContext).identifierLabel = _x
		}
		{
			p.SetState(1171)
			p.Match(JavaParserCOLON)
		}
		{
			p.SetState(1172)
			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() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewCatchClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 166, JavaParserRULE_catchClause)

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

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

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1176)
		p.Match(JavaParserCATCH)
	}
	{
		p.SetState(1177)
		p.Match(JavaParserLPAREN)
	}
	p.SetState(1181)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 136, p.GetParserRuleContext())

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

		}
		p.SetState(1183)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 136, p.GetParserRuleContext())
	}
	{
		p.SetState(1184)
		p.CatchType()
	}
	{
		p.SetState(1185)
		p.Identifier()
	}
	{
		p.SetState(1186)
		p.Match(JavaParserRPAREN)
	}
	{
		p.SetState(1187)
		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) {
	this := p
	_ = this

	localctx = NewCatchTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 168, 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(1189)
		p.QualifiedName()
	}
	p.SetState(1194)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserBITOR {
		{
			p.SetState(1190)
			p.Match(JavaParserBITOR)
		}
		{
			p.SetState(1191)
			p.QualifiedName()
		}

		p.SetState(1196)
		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) {
	this := p
	_ = this

	localctx = NewFinallyBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 170, 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(1197)
		p.Match(JavaParserFINALLY)
	}
	{
		p.SetState(1198)
		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) {
	this := p
	_ = this

	localctx = NewResourceSpecificationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 172, 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(1200)
		p.Match(JavaParserLPAREN)
	}
	{
		p.SetState(1201)
		p.Resources()
	}
	p.SetState(1203)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserSEMI {
		{
			p.SetState(1202)
			p.Match(JavaParserSEMI)
		}

	}
	{
		p.SetState(1205)
		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) {
	this := p
	_ = this

	localctx = NewResourcesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 174, 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(1207)
		p.Resource()
	}
	p.SetState(1212)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 139, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1208)
				p.Match(JavaParserSEMI)
			}
			{
				p.SetState(1209)
				p.Resource()
			}

		}
		p.SetState(1214)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 139, 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) 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) 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) VAR() antlr.TerminalNode {
	return s.GetToken(JavaParserVAR, 0)
}

func (s *ResourceContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewResourceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 176, JavaParserRULE_resource)

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

	defer func() {
		if err := recover(); err != 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(1232)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 142, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(1218)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 140, p.GetParserRuleContext())

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

			}
			p.SetState(1220)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 140, p.GetParserRuleContext())
		}
		p.SetState(1226)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 141, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1221)
				p.ClassOrInterfaceType()
			}
			{
				p.SetState(1222)
				p.VariableDeclaratorId()
			}

		case 2:
			{
				p.SetState(1224)
				p.Match(JavaParserVAR)
			}
			{
				p.SetState(1225)
				p.Identifier()
			}

		}
		{
			p.SetState(1228)
			p.Match(JavaParserASSIGN)
		}
		{
			p.SetState(1229)
			p.expression(0)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1231)
			p.Identifier()
		}

	}

	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) {
	this := p
	_ = this

	localctx = NewSwitchBlockStatementGroupContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 178, 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(1235)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == JavaParserCASE || _la == JavaParserDEFAULT {
		{
			p.SetState(1234)
			p.SwitchLabel()
		}

		p.SetState(1237)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	p.SetState(1240)
	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<<(JavaParserMODULE-33))|(1<<(JavaParserOPEN-33))|(1<<(JavaParserREQUIRES-33))|(1<<(JavaParserEXPORTS-33))|(1<<(JavaParserOPENS-33))|(1<<(JavaParserTO-33))|(1<<(JavaParserUSES-33))|(1<<(JavaParserPROVIDES-33))|(1<<(JavaParserWITH-33))|(1<<(JavaParserTRANSITIVE-33))|(1<<(JavaParserVAR-33))|(1<<(JavaParserYIELD-33))|(1<<(JavaParserRECORD-33))|(1<<(JavaParserSEALED-33)))) != 0) || (((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(JavaParserPERMITS-65))|(1<<(JavaParserNON_SEALED-65))|(1<<(JavaParserDECIMAL_LITERAL-65))|(1<<(JavaParserHEX_LITERAL-65))|(1<<(JavaParserOCT_LITERAL-65))|(1<<(JavaParserBINARY_LITERAL-65))|(1<<(JavaParserFLOAT_LITERAL-65))|(1<<(JavaParserHEX_FLOAT_LITERAL-65))|(1<<(JavaParserBOOL_LITERAL-65))|(1<<(JavaParserCHAR_LITERAL-65))|(1<<(JavaParserSTRING_LITERAL-65))|(1<<(JavaParserTEXT_BLOCK-65))|(1<<(JavaParserNULL_LITERAL-65))|(1<<(JavaParserLPAREN-65))|(1<<(JavaParserLBRACE-65))|(1<<(JavaParserSEMI-65))|(1<<(JavaParserLT-65))|(1<<(JavaParserBANG-65))|(1<<(JavaParserTILDE-65)))) != 0) || (((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(JavaParserINC-100))|(1<<(JavaParserDEC-100))|(1<<(JavaParserADD-100))|(1<<(JavaParserSUB-100))|(1<<(JavaParserAT-100))|(1<<(JavaParserIDENTIFIER-100)))) != 0) {
		{
			p.SetState(1239)
			p.BlockStatement()
		}

		p.SetState(1242)
		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

	// GetVarName returns the varName rule contexts.
	GetVarName() IIdentifierContext

	// SetConstantExpression sets the constantExpression rule contexts.
	SetConstantExpression(IExpressionContext)

	// SetVarName sets the varName rule contexts.
	SetVarName(IIdentifierContext)

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

type SwitchLabelContext struct {
	*antlr.BaseParserRuleContext
	parser             antlr.Parser
	constantExpression IExpressionContext
	enumConstantName   antlr.Token
	varName            IIdentifierContext
}

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) GetVarName() IIdentifierContext { return s.varName }

func (s *SwitchLabelContext) SetConstantExpression(v IExpressionContext) { s.constantExpression = v }

func (s *SwitchLabelContext) SetVarName(v IIdentifierContext) { s.varName = 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) TypeType() ITypeTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewSwitchLabelContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 180, 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(1255)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserCASE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1244)
			p.Match(JavaParserCASE)
		}
		p.SetState(1250)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 145, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1245)

				var _x = p.expression(0)

				localctx.(*SwitchLabelContext).constantExpression = _x
			}

		case 2:
			{
				p.SetState(1246)

				var _m = p.Match(JavaParserIDENTIFIER)

				localctx.(*SwitchLabelContext).enumConstantName = _m
			}

		case 3:
			{
				p.SetState(1247)
				p.TypeType()
			}
			{
				p.SetState(1248)

				var _x = p.Identifier()

				localctx.(*SwitchLabelContext).varName = _x
			}

		}
		{
			p.SetState(1252)
			p.Match(JavaParserCOLON)
		}

	case JavaParserDEFAULT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1253)
			p.Match(JavaParserDEFAULT)
		}
		{
			p.SetState(1254)
			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) {
	this := p
	_ = this

	localctx = NewForControlContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 182, 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(1269)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 150, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1257)
			p.EnhancedForControl()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(1259)
		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<<(JavaParserSWITCH-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserMODULE-37))|(1<<(JavaParserOPEN-37))|(1<<(JavaParserREQUIRES-37))|(1<<(JavaParserEXPORTS-37))|(1<<(JavaParserOPENS-37))|(1<<(JavaParserTO-37))|(1<<(JavaParserUSES-37))|(1<<(JavaParserPROVIDES-37))|(1<<(JavaParserWITH-37))|(1<<(JavaParserTRANSITIVE-37))|(1<<(JavaParserVAR-37))|(1<<(JavaParserYIELD-37))|(1<<(JavaParserRECORD-37))|(1<<(JavaParserSEALED-37))|(1<<(JavaParserPERMITS-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(JavaParserOCT_LITERAL-69))|(1<<(JavaParserBINARY_LITERAL-69))|(1<<(JavaParserFLOAT_LITERAL-69))|(1<<(JavaParserHEX_FLOAT_LITERAL-69))|(1<<(JavaParserBOOL_LITERAL-69))|(1<<(JavaParserCHAR_LITERAL-69))|(1<<(JavaParserSTRING_LITERAL-69))|(1<<(JavaParserTEXT_BLOCK-69))|(1<<(JavaParserNULL_LITERAL-69))|(1<<(JavaParserLPAREN-69))|(1<<(JavaParserLT-69))|(1<<(JavaParserBANG-69))|(1<<(JavaParserTILDE-69))|(1<<(JavaParserINC-69)))) != 0) || (((_la-101)&-(0x1f+1)) == 0 && ((1<<uint((_la-101)))&((1<<(JavaParserDEC-101))|(1<<(JavaParserADD-101))|(1<<(JavaParserSUB-101))|(1<<(JavaParserAT-101))|(1<<(JavaParserIDENTIFIER-101)))) != 0) {
			{
				p.SetState(1258)
				p.ForInit()
			}

		}
		{
			p.SetState(1261)
			p.Match(JavaParserSEMI)
		}
		p.SetState(1263)
		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<<(JavaParserSWITCH-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserMODULE-37))|(1<<(JavaParserOPEN-37))|(1<<(JavaParserREQUIRES-37))|(1<<(JavaParserEXPORTS-37))|(1<<(JavaParserOPENS-37))|(1<<(JavaParserTO-37))|(1<<(JavaParserUSES-37))|(1<<(JavaParserPROVIDES-37))|(1<<(JavaParserWITH-37))|(1<<(JavaParserTRANSITIVE-37))|(1<<(JavaParserVAR-37))|(1<<(JavaParserYIELD-37))|(1<<(JavaParserRECORD-37))|(1<<(JavaParserSEALED-37))|(1<<(JavaParserPERMITS-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(JavaParserOCT_LITERAL-69))|(1<<(JavaParserBINARY_LITERAL-69))|(1<<(JavaParserFLOAT_LITERAL-69))|(1<<(JavaParserHEX_FLOAT_LITERAL-69))|(1<<(JavaParserBOOL_LITERAL-69))|(1<<(JavaParserCHAR_LITERAL-69))|(1<<(JavaParserSTRING_LITERAL-69))|(1<<(JavaParserTEXT_BLOCK-69))|(1<<(JavaParserNULL_LITERAL-69))|(1<<(JavaParserLPAREN-69))|(1<<(JavaParserLT-69))|(1<<(JavaParserBANG-69))|(1<<(JavaParserTILDE-69))|(1<<(JavaParserINC-69)))) != 0) || (((_la-101)&-(0x1f+1)) == 0 && ((1<<uint((_la-101)))&((1<<(JavaParserDEC-101))|(1<<(JavaParserADD-101))|(1<<(JavaParserSUB-101))|(1<<(JavaParserAT-101))|(1<<(JavaParserIDENTIFIER-101)))) != 0) {
			{
				p.SetState(1262)
				p.expression(0)
			}

		}
		{
			p.SetState(1265)
			p.Match(JavaParserSEMI)
		}
		p.SetState(1267)
		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<<(JavaParserSWITCH-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserMODULE-37))|(1<<(JavaParserOPEN-37))|(1<<(JavaParserREQUIRES-37))|(1<<(JavaParserEXPORTS-37))|(1<<(JavaParserOPENS-37))|(1<<(JavaParserTO-37))|(1<<(JavaParserUSES-37))|(1<<(JavaParserPROVIDES-37))|(1<<(JavaParserWITH-37))|(1<<(JavaParserTRANSITIVE-37))|(1<<(JavaParserVAR-37))|(1<<(JavaParserYIELD-37))|(1<<(JavaParserRECORD-37))|(1<<(JavaParserSEALED-37))|(1<<(JavaParserPERMITS-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(JavaParserOCT_LITERAL-69))|(1<<(JavaParserBINARY_LITERAL-69))|(1<<(JavaParserFLOAT_LITERAL-69))|(1<<(JavaParserHEX_FLOAT_LITERAL-69))|(1<<(JavaParserBOOL_LITERAL-69))|(1<<(JavaParserCHAR_LITERAL-69))|(1<<(JavaParserSTRING_LITERAL-69))|(1<<(JavaParserTEXT_BLOCK-69))|(1<<(JavaParserNULL_LITERAL-69))|(1<<(JavaParserLPAREN-69))|(1<<(JavaParserLT-69))|(1<<(JavaParserBANG-69))|(1<<(JavaParserTILDE-69))|(1<<(JavaParserINC-69)))) != 0) || (((_la-101)&-(0x1f+1)) == 0 && ((1<<uint((_la-101)))&((1<<(JavaParserDEC-101))|(1<<(JavaParserADD-101))|(1<<(JavaParserSUB-101))|(1<<(JavaParserAT-101))|(1<<(JavaParserIDENTIFIER-101)))) != 0) {
			{
				p.SetState(1266)

				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) {
	this := p
	_ = this

	localctx = NewForInitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 184, 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(1273)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 151, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1271)
			p.LocalVariableDeclaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1272)
			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) 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) TypeType() ITypeTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *EnhancedForControlContext) VAR() antlr.TerminalNode {
	return s.GetToken(JavaParserVAR, 0)
}

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) {
	this := p
	_ = this

	localctx = NewEnhancedForControlContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 186, 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(1278)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 152, p.GetParserRuleContext())

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

		}
		p.SetState(1280)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 152, p.GetParserRuleContext())
	}
	p.SetState(1283)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 153, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1281)
			p.TypeType()
		}

	case 2:
		{
			p.SetState(1282)
			p.Match(JavaParserVAR)
		}

	}
	{
		p.SetState(1285)
		p.VariableDeclaratorId()
	}
	{
		p.SetState(1286)
		p.Match(JavaParserCOLON)
	}
	{
		p.SetState(1287)
		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) {
	this := p
	_ = this

	localctx = NewParExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 188, 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(1289)
		p.Match(JavaParserLPAREN)
	}
	{
		p.SetState(1290)
		p.expression(0)
	}
	{
		p.SetState(1291)
		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) {
	this := p
	_ = this

	localctx = NewExpressionListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 190, 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(1293)
		p.expression(0)
	}
	p.SetState(1298)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(1294)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(1295)
			p.expression(0)
		}

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

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewMethodCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 192, 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(1320)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1301)
			p.Identifier()
		}
		{
			p.SetState(1302)
			p.Match(JavaParserLPAREN)
		}
		p.SetState(1304)
		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<<(JavaParserSWITCH-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserMODULE-37))|(1<<(JavaParserOPEN-37))|(1<<(JavaParserREQUIRES-37))|(1<<(JavaParserEXPORTS-37))|(1<<(JavaParserOPENS-37))|(1<<(JavaParserTO-37))|(1<<(JavaParserUSES-37))|(1<<(JavaParserPROVIDES-37))|(1<<(JavaParserWITH-37))|(1<<(JavaParserTRANSITIVE-37))|(1<<(JavaParserVAR-37))|(1<<(JavaParserYIELD-37))|(1<<(JavaParserRECORD-37))|(1<<(JavaParserSEALED-37))|(1<<(JavaParserPERMITS-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(JavaParserOCT_LITERAL-69))|(1<<(JavaParserBINARY_LITERAL-69))|(1<<(JavaParserFLOAT_LITERAL-69))|(1<<(JavaParserHEX_FLOAT_LITERAL-69))|(1<<(JavaParserBOOL_LITERAL-69))|(1<<(JavaParserCHAR_LITERAL-69))|(1<<(JavaParserSTRING_LITERAL-69))|(1<<(JavaParserTEXT_BLOCK-69))|(1<<(JavaParserNULL_LITERAL-69))|(1<<(JavaParserLPAREN-69))|(1<<(JavaParserLT-69))|(1<<(JavaParserBANG-69))|(1<<(JavaParserTILDE-69))|(1<<(JavaParserINC-69)))) != 0) || (((_la-101)&-(0x1f+1)) == 0 && ((1<<uint((_la-101)))&((1<<(JavaParserDEC-101))|(1<<(JavaParserADD-101))|(1<<(JavaParserSUB-101))|(1<<(JavaParserAT-101))|(1<<(JavaParserIDENTIFIER-101)))) != 0) {
			{
				p.SetState(1303)
				p.ExpressionList()
			}

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

	case JavaParserTHIS:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1308)
			p.Match(JavaParserTHIS)
		}
		{
			p.SetState(1309)
			p.Match(JavaParserLPAREN)
		}
		p.SetState(1311)
		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<<(JavaParserSWITCH-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserMODULE-37))|(1<<(JavaParserOPEN-37))|(1<<(JavaParserREQUIRES-37))|(1<<(JavaParserEXPORTS-37))|(1<<(JavaParserOPENS-37))|(1<<(JavaParserTO-37))|(1<<(JavaParserUSES-37))|(1<<(JavaParserPROVIDES-37))|(1<<(JavaParserWITH-37))|(1<<(JavaParserTRANSITIVE-37))|(1<<(JavaParserVAR-37))|(1<<(JavaParserYIELD-37))|(1<<(JavaParserRECORD-37))|(1<<(JavaParserSEALED-37))|(1<<(JavaParserPERMITS-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(JavaParserOCT_LITERAL-69))|(1<<(JavaParserBINARY_LITERAL-69))|(1<<(JavaParserFLOAT_LITERAL-69))|(1<<(JavaParserHEX_FLOAT_LITERAL-69))|(1<<(JavaParserBOOL_LITERAL-69))|(1<<(JavaParserCHAR_LITERAL-69))|(1<<(JavaParserSTRING_LITERAL-69))|(1<<(JavaParserTEXT_BLOCK-69))|(1<<(JavaParserNULL_LITERAL-69))|(1<<(JavaParserLPAREN-69))|(1<<(JavaParserLT-69))|(1<<(JavaParserBANG-69))|(1<<(JavaParserTILDE-69))|(1<<(JavaParserINC-69)))) != 0) || (((_la-101)&-(0x1f+1)) == 0 && ((1<<uint((_la-101)))&((1<<(JavaParserDEC-101))|(1<<(JavaParserADD-101))|(1<<(JavaParserSUB-101))|(1<<(JavaParserAT-101))|(1<<(JavaParserIDENTIFIER-101)))) != 0) {
			{
				p.SetState(1310)
				p.ExpressionList()
			}

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

	case JavaParserSUPER:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1314)
			p.Match(JavaParserSUPER)
		}
		{
			p.SetState(1315)
			p.Match(JavaParserLPAREN)
		}
		p.SetState(1317)
		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<<(JavaParserSWITCH-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserMODULE-37))|(1<<(JavaParserOPEN-37))|(1<<(JavaParserREQUIRES-37))|(1<<(JavaParserEXPORTS-37))|(1<<(JavaParserOPENS-37))|(1<<(JavaParserTO-37))|(1<<(JavaParserUSES-37))|(1<<(JavaParserPROVIDES-37))|(1<<(JavaParserWITH-37))|(1<<(JavaParserTRANSITIVE-37))|(1<<(JavaParserVAR-37))|(1<<(JavaParserYIELD-37))|(1<<(JavaParserRECORD-37))|(1<<(JavaParserSEALED-37))|(1<<(JavaParserPERMITS-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(JavaParserOCT_LITERAL-69))|(1<<(JavaParserBINARY_LITERAL-69))|(1<<(JavaParserFLOAT_LITERAL-69))|(1<<(JavaParserHEX_FLOAT_LITERAL-69))|(1<<(JavaParserBOOL_LITERAL-69))|(1<<(JavaParserCHAR_LITERAL-69))|(1<<(JavaParserSTRING_LITERAL-69))|(1<<(JavaParserTEXT_BLOCK-69))|(1<<(JavaParserNULL_LITERAL-69))|(1<<(JavaParserLPAREN-69))|(1<<(JavaParserLT-69))|(1<<(JavaParserBANG-69))|(1<<(JavaParserTILDE-69))|(1<<(JavaParserINC-69)))) != 0) || (((_la-101)&-(0x1f+1)) == 0 && ((1<<uint((_la-101)))&((1<<(JavaParserDEC-101))|(1<<(JavaParserADD-101))|(1<<(JavaParserSUB-101))|(1<<(JavaParserAT-101))|(1<<(JavaParserIDENTIFIER-101)))) != 0) {
			{
				p.SetState(1316)
				p.ExpressionList()
			}

		}
		{
			p.SetState(1319)
			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) 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 *ExpressionContext) TypeType(i int) ITypeTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeTypeContext)(nil)).Elem(), i)

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

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

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

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

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

	if t == nil {
		return nil
	}

	return t.(ISwitchExpressionContext)
}

func (s *ExpressionContext) COLONCOLON() antlr.TerminalNode {
	return s.GetToken(JavaParserCOLONCOLON, 0)
}

func (s *ExpressionContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IPatternContext)
}

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) {
	this := p
	_ = this

	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 := 194
	p.EnterRecursionRule(localctx, 194, 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(1367)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 164, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1323)
			p.Primary()
		}

	case 2:
		{
			p.SetState(1324)
			p.MethodCall()
		}

	case 3:
		{
			p.SetState(1325)
			p.Match(JavaParserNEW)
		}
		{
			p.SetState(1326)
			p.Creator()
		}

	case 4:
		{
			p.SetState(1327)
			p.Match(JavaParserLPAREN)
		}
		p.SetState(1331)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 159, p.GetParserRuleContext())

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

			}
			p.SetState(1333)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 159, p.GetParserRuleContext())
		}
		{
			p.SetState(1334)
			p.TypeType()
		}
		p.SetState(1339)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == JavaParserBITAND {
			{
				p.SetState(1335)
				p.Match(JavaParserBITAND)
			}
			{
				p.SetState(1336)
				p.TypeType()
			}

			p.SetState(1341)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1342)
			p.Match(JavaParserRPAREN)
		}
		{
			p.SetState(1343)
			p.expression(22)
		}

	case 5:
		{
			p.SetState(1345)

			var _lt = p.GetTokenStream().LT(1)

			localctx.(*ExpressionContext).prefix = _lt

			_la = p.GetTokenStream().LA(1)

			if !(((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(JavaParserINC-100))|(1<<(JavaParserDEC-100))|(1<<(JavaParserADD-100))|(1<<(JavaParserSUB-100)))) != 0) {
				var _ri = p.GetErrorHandler().RecoverInline(p)

				localctx.(*ExpressionContext).prefix = _ri
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1346)
			p.expression(20)
		}

	case 6:
		{
			p.SetState(1347)

			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(1348)
			p.expression(19)
		}

	case 7:
		{
			p.SetState(1349)
			p.LambdaExpression()
		}

	case 8:
		{
			p.SetState(1350)
			p.SwitchExpression()
		}

	case 9:
		{
			p.SetState(1351)
			p.TypeType()
		}
		{
			p.SetState(1352)
			p.Match(JavaParserCOLONCOLON)
		}
		p.SetState(1358)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserLT, JavaParserIDENTIFIER:
			p.SetState(1354)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == JavaParserLT {
				{
					p.SetState(1353)
					p.TypeArguments()
				}

			}
			{
				p.SetState(1356)
				p.Identifier()
			}

		case JavaParserNEW:
			{
				p.SetState(1357)
				p.Match(JavaParserNEW)
			}

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

	case 10:
		{
			p.SetState(1360)
			p.ClassType()
		}
		{
			p.SetState(1361)
			p.Match(JavaParserCOLONCOLON)
		}
		p.SetState(1363)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserLT {
			{
				p.SetState(1362)
				p.TypeArguments()
			}

		}
		{
			p.SetState(1365)
			p.Match(JavaParserNEW)
		}

	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(1452)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 171, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(1450)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 170, p.GetParserRuleContext()) {
			case 1:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1369)

				if !(p.Precpred(p.GetParserRuleContext(), 18)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 18)", ""))
				}
				{
					p.SetState(1370)

					var _lt = p.GetTokenStream().LT(1)

					localctx.(*ExpressionContext).bop = _lt

					_la = p.GetTokenStream().LA(1)

					if !(((_la-104)&-(0x1f+1)) == 0 && ((1<<uint((_la-104)))&((1<<(JavaParserMUL-104))|(1<<(JavaParserDIV-104))|(1<<(JavaParserMOD-104)))) != 0) {
						var _ri = p.GetErrorHandler().RecoverInline(p)

						localctx.(*ExpressionContext).bop = _ri
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1371)
					p.expression(19)
				}

			case 2:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1372)

				if !(p.Precpred(p.GetParserRuleContext(), 17)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 17)", ""))
				}
				{
					p.SetState(1373)

					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(1374)
					p.expression(18)
				}

			case 3:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1375)

				if !(p.Precpred(p.GetParserRuleContext(), 16)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 16)", ""))
				}
				p.SetState(1383)
				p.GetErrorHandler().Sync(p)
				switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 165, p.GetParserRuleContext()) {
				case 1:
					{
						p.SetState(1376)
						p.Match(JavaParserLT)
					}
					{
						p.SetState(1377)
						p.Match(JavaParserLT)
					}

				case 2:
					{
						p.SetState(1378)
						p.Match(JavaParserGT)
					}
					{
						p.SetState(1379)
						p.Match(JavaParserGT)
					}
					{
						p.SetState(1380)
						p.Match(JavaParserGT)
					}

				case 3:
					{
						p.SetState(1381)
						p.Match(JavaParserGT)
					}
					{
						p.SetState(1382)
						p.Match(JavaParserGT)
					}

				}
				{
					p.SetState(1385)
					p.expression(17)
				}

			case 4:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1386)

				if !(p.Precpred(p.GetParserRuleContext(), 15)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 15)", ""))
				}
				{
					p.SetState(1387)

					var _lt = p.GetTokenStream().LT(1)

					localctx.(*ExpressionContext).bop = _lt

					_la = p.GetTokenStream().LA(1)

					if !(((_la-88)&-(0x1f+1)) == 0 && ((1<<uint((_la-88)))&((1<<(JavaParserGT-88))|(1<<(JavaParserLT-88))|(1<<(JavaParserLE-88))|(1<<(JavaParserGE-88)))) != 0) {
						var _ri = p.GetErrorHandler().RecoverInline(p)

						localctx.(*ExpressionContext).bop = _ri
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1388)
					p.expression(16)
				}

			case 5:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1389)

				if !(p.Precpred(p.GetParserRuleContext(), 13)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 13)", ""))
				}
				{
					p.SetState(1390)

					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(1391)
					p.expression(14)
				}

			case 6:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1392)

				if !(p.Precpred(p.GetParserRuleContext(), 12)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 12)", ""))
				}
				{
					p.SetState(1393)

					var _m = p.Match(JavaParserBITAND)

					localctx.(*ExpressionContext).bop = _m
				}
				{
					p.SetState(1394)
					p.expression(13)
				}

			case 7:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1395)

				if !(p.Precpred(p.GetParserRuleContext(), 11)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 11)", ""))
				}
				{
					p.SetState(1396)

					var _m = p.Match(JavaParserCARET)

					localctx.(*ExpressionContext).bop = _m
				}
				{
					p.SetState(1397)
					p.expression(12)
				}

			case 8:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1398)

				if !(p.Precpred(p.GetParserRuleContext(), 10)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", ""))
				}
				{
					p.SetState(1399)

					var _m = p.Match(JavaParserBITOR)

					localctx.(*ExpressionContext).bop = _m
				}
				{
					p.SetState(1400)
					p.expression(11)
				}

			case 9:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1401)

				if !(p.Precpred(p.GetParserRuleContext(), 9)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", ""))
				}
				{
					p.SetState(1402)

					var _m = p.Match(JavaParserAND)

					localctx.(*ExpressionContext).bop = _m
				}
				{
					p.SetState(1403)
					p.expression(10)
				}

			case 10:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1404)

				if !(p.Precpred(p.GetParserRuleContext(), 8)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", ""))
				}
				{
					p.SetState(1405)

					var _m = p.Match(JavaParserOR)

					localctx.(*ExpressionContext).bop = _m
				}
				{
					p.SetState(1406)
					p.expression(9)
				}

			case 11:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1407)

				if !(p.Precpred(p.GetParserRuleContext(), 7)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", ""))
				}
				{
					p.SetState(1408)

					var _m = p.Match(JavaParserQUESTION)

					localctx.(*ExpressionContext).bop = _m
				}
				{
					p.SetState(1409)
					p.expression(0)
				}
				{
					p.SetState(1410)
					p.Match(JavaParserCOLON)
				}
				{
					p.SetState(1411)
					p.expression(7)
				}

			case 12:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1413)

				if !(p.Precpred(p.GetParserRuleContext(), 6)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", ""))
				}
				{
					p.SetState(1414)

					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<<(JavaParserASSIGN-87))|(1<<(JavaParserADD_ASSIGN-87))|(1<<(JavaParserSUB_ASSIGN-87))|(1<<(JavaParserMUL_ASSIGN-87))|(1<<(JavaParserDIV_ASSIGN-87))|(1<<(JavaParserAND_ASSIGN-87))|(1<<(JavaParserOR_ASSIGN-87))|(1<<(JavaParserXOR_ASSIGN-87))|(1<<(JavaParserMOD_ASSIGN-87))|(1<<(JavaParserLSHIFT_ASSIGN-87)))) != 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(1415)
					p.expression(6)
				}

			case 13:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1416)

				if !(p.Precpred(p.GetParserRuleContext(), 26)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 26)", ""))
				}
				{
					p.SetState(1417)

					var _m = p.Match(JavaParserDOT)

					localctx.(*ExpressionContext).bop = _m
				}
				p.SetState(1429)
				p.GetErrorHandler().Sync(p)
				switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 167, p.GetParserRuleContext()) {
				case 1:
					{
						p.SetState(1418)
						p.Identifier()
					}

				case 2:
					{
						p.SetState(1419)
						p.MethodCall()
					}

				case 3:
					{
						p.SetState(1420)
						p.Match(JavaParserTHIS)
					}

				case 4:
					{
						p.SetState(1421)
						p.Match(JavaParserNEW)
					}
					p.SetState(1423)
					p.GetErrorHandler().Sync(p)
					_la = p.GetTokenStream().LA(1)

					if _la == JavaParserLT {
						{
							p.SetState(1422)
							p.NonWildcardTypeArguments()
						}

					}
					{
						p.SetState(1425)
						p.InnerCreator()
					}

				case 5:
					{
						p.SetState(1426)
						p.Match(JavaParserSUPER)
					}
					{
						p.SetState(1427)
						p.SuperSuffix()
					}

				case 6:
					{
						p.SetState(1428)
						p.ExplicitGenericInvocation()
					}

				}

			case 14:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1431)

				if !(p.Precpred(p.GetParserRuleContext(), 25)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 25)", ""))
				}
				{
					p.SetState(1432)
					p.Match(JavaParserLBRACK)
				}
				{
					p.SetState(1433)
					p.expression(0)
				}
				{
					p.SetState(1434)
					p.Match(JavaParserRBRACK)
				}

			case 15:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1436)

				if !(p.Precpred(p.GetParserRuleContext(), 21)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 21)", ""))
				}
				{
					p.SetState(1437)

					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(1438)

				if !(p.Precpred(p.GetParserRuleContext(), 14)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", ""))
				}
				{
					p.SetState(1439)

					var _m = p.Match(JavaParserINSTANCEOF)

					localctx.(*ExpressionContext).bop = _m
				}
				p.SetState(1442)
				p.GetErrorHandler().Sync(p)
				switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 168, p.GetParserRuleContext()) {
				case 1:
					{
						p.SetState(1440)
						p.TypeType()
					}

				case 2:
					{
						p.SetState(1441)
						p.Pattern()
					}

				}

			case 17:
				localctx = NewExpressionContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, JavaParserRULE_expression)
				p.SetState(1444)

				if !(p.Precpred(p.GetParserRuleContext(), 3)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
				}
				{
					p.SetState(1445)
					p.Match(JavaParserCOLONCOLON)
				}
				p.SetState(1447)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == JavaParserLT {
					{
						p.SetState(1446)
						p.TypeArguments()
					}

				}
				{
					p.SetState(1449)
					p.Identifier()
				}

			}

		}
		p.SetState(1454)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 171, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyPatternContext() *PatternContext {
	var p = new(PatternContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_pattern
	return p
}

func (*PatternContext) IsPatternContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_pattern

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *PatternContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IVariableModifierContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

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

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

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

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

func (p *JavaParser) Pattern() (localctx IPatternContext) {
	this := p
	_ = this

	localctx = NewPatternContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 196, JavaParserRULE_pattern)

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

	defer func() {
		if err := recover(); err != 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(1458)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 172, p.GetParserRuleContext())

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

		}
		p.SetState(1460)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 172, p.GetParserRuleContext())
	}
	{
		p.SetState(1461)
		p.TypeType()
	}
	p.SetState(1465)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 173, p.GetParserRuleContext())

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

		}
		p.SetState(1467)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 173, p.GetParserRuleContext())
	}
	{
		p.SetState(1468)
		p.Identifier()
	}

	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) {
	this := p
	_ = this

	localctx = NewLambdaExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 198, 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(1470)
		p.LambdaParameters()
	}
	{
		p.SetState(1471)
		p.Match(JavaParserARROW)
	}
	{
		p.SetState(1472)
		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() []IIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIdentifierContext)(nil)).Elem())
	var tst = make([]IIdentifierContext, len(ts))

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

	return tst
}

func (s *LambdaParametersContext) Identifier(i int) IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ILambdaLVTIListContext)
}

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) {
	this := p
	_ = this

	localctx = NewLambdaParametersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 200, 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(1496)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 177, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1474)
			p.Identifier()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1475)
			p.Match(JavaParserLPAREN)
		}
		p.SetState(1477)
		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-37)&-(0x1f+1)) == 0 && ((1<<uint((_la-37)))&((1<<(JavaParserSHORT-37))|(1<<(JavaParserMODULE-37))|(1<<(JavaParserOPEN-37))|(1<<(JavaParserREQUIRES-37))|(1<<(JavaParserEXPORTS-37))|(1<<(JavaParserOPENS-37))|(1<<(JavaParserTO-37))|(1<<(JavaParserUSES-37))|(1<<(JavaParserPROVIDES-37))|(1<<(JavaParserWITH-37))|(1<<(JavaParserTRANSITIVE-37))|(1<<(JavaParserVAR-37))|(1<<(JavaParserYIELD-37))|(1<<(JavaParserRECORD-37))|(1<<(JavaParserSEALED-37))|(1<<(JavaParserPERMITS-37)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
			{
				p.SetState(1476)
				p.FormalParameterList()
			}

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

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1480)
			p.Match(JavaParserLPAREN)
		}
		{
			p.SetState(1481)
			p.Identifier()
		}
		p.SetState(1486)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == JavaParserCOMMA {
			{
				p.SetState(1482)
				p.Match(JavaParserCOMMA)
			}
			{
				p.SetState(1483)
				p.Identifier()
			}

			p.SetState(1488)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1489)
			p.Match(JavaParserRPAREN)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1491)
			p.Match(JavaParserLPAREN)
		}
		p.SetState(1493)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserFINAL || (((_la-51)&-(0x1f+1)) == 0 && ((1<<uint((_la-51)))&((1<<(JavaParserMODULE-51))|(1<<(JavaParserOPEN-51))|(1<<(JavaParserREQUIRES-51))|(1<<(JavaParserEXPORTS-51))|(1<<(JavaParserOPENS-51))|(1<<(JavaParserTO-51))|(1<<(JavaParserUSES-51))|(1<<(JavaParserPROVIDES-51))|(1<<(JavaParserWITH-51))|(1<<(JavaParserTRANSITIVE-51))|(1<<(JavaParserVAR-51))|(1<<(JavaParserYIELD-51))|(1<<(JavaParserRECORD-51))|(1<<(JavaParserSEALED-51))|(1<<(JavaParserPERMITS-51)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
			{
				p.SetState(1492)
				p.LambdaLVTIList()
			}

		}
		{
			p.SetState(1495)
			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) {
	this := p
	_ = this

	localctx = NewLambdaBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 202, 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(1500)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserNEW, JavaParserSHORT, JavaParserSUPER, JavaParserSWITCH, JavaParserTHIS, JavaParserVOID, JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserDECIMAL_LITERAL, JavaParserHEX_LITERAL, JavaParserOCT_LITERAL, JavaParserBINARY_LITERAL, JavaParserFLOAT_LITERAL, JavaParserHEX_FLOAT_LITERAL, JavaParserBOOL_LITERAL, JavaParserCHAR_LITERAL, JavaParserSTRING_LITERAL, JavaParserTEXT_BLOCK, JavaParserNULL_LITERAL, JavaParserLPAREN, JavaParserLT, JavaParserBANG, JavaParserTILDE, JavaParserINC, JavaParserDEC, JavaParserADD, JavaParserSUB, JavaParserAT, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1498)
			p.expression(0)
		}

	case JavaParserLBRACE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1499)
			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() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewPrimaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 204, 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(1520)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 180, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1502)
			p.Match(JavaParserLPAREN)
		}
		{
			p.SetState(1503)
			p.expression(0)
		}
		{
			p.SetState(1504)
			p.Match(JavaParserRPAREN)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1506)
			p.Match(JavaParserTHIS)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1507)
			p.Match(JavaParserSUPER)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1508)
			p.Literal()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1509)
			p.Identifier()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1510)
			p.TypeTypeOrVoid()
		}
		{
			p.SetState(1511)
			p.Match(JavaParserDOT)
		}
		{
			p.SetState(1512)
			p.Match(JavaParserCLASS)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1514)
			p.NonWildcardTypeArguments()
		}
		p.SetState(1518)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case JavaParserSUPER, JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserIDENTIFIER:
			{
				p.SetState(1515)
				p.ExplicitGenericInvocationSuffix()
			}

		case JavaParserTHIS:
			{
				p.SetState(1516)
				p.Match(JavaParserTHIS)
			}
			{
				p.SetState(1517)
				p.Arguments()
			}

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

	}

	return localctx
}

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

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

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

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

func NewEmptySwitchExpressionContext() *SwitchExpressionContext {
	var p = new(SwitchExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_switchExpression
	return p
}

func (*SwitchExpressionContext) IsSwitchExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_switchExpression

	return p
}

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

func (s *SwitchExpressionContext) SWITCH() antlr.TerminalNode {
	return s.GetToken(JavaParserSWITCH, 0)
}

func (s *SwitchExpressionContext) ParExpression() IParExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParExpressionContext)
}

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

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

func (s *SwitchExpressionContext) AllSwitchLabeledRule() []ISwitchLabeledRuleContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISwitchLabeledRuleContext)(nil)).Elem())
	var tst = make([]ISwitchLabeledRuleContext, len(ts))

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

	return tst
}

func (s *SwitchExpressionContext) SwitchLabeledRule(i int) ISwitchLabeledRuleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISwitchLabeledRuleContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISwitchLabeledRuleContext)
}

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

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

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

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

func (p *JavaParser) SwitchExpression() (localctx ISwitchExpressionContext) {
	this := p
	_ = this

	localctx = NewSwitchExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 206, JavaParserRULE_switchExpression)
	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(1522)
		p.Match(JavaParserSWITCH)
	}
	{
		p.SetState(1523)
		p.ParExpression()
	}
	{
		p.SetState(1524)
		p.Match(JavaParserLBRACE)
	}
	p.SetState(1528)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCASE || _la == JavaParserDEFAULT {
		{
			p.SetState(1525)
			p.SwitchLabeledRule()
		}

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

	return localctx
}

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

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

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

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

func NewEmptySwitchLabeledRuleContext() *SwitchLabeledRuleContext {
	var p = new(SwitchLabeledRuleContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_switchLabeledRule
	return p
}

func (*SwitchLabeledRuleContext) IsSwitchLabeledRuleContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_switchLabeledRule

	return p
}

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

func (s *SwitchLabeledRuleContext) CASE() antlr.TerminalNode {
	return s.GetToken(JavaParserCASE, 0)
}

func (s *SwitchLabeledRuleContext) SwitchRuleOutcome() ISwitchRuleOutcomeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISwitchRuleOutcomeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISwitchRuleOutcomeContext)
}

func (s *SwitchLabeledRuleContext) ARROW() antlr.TerminalNode {
	return s.GetToken(JavaParserARROW, 0)
}

func (s *SwitchLabeledRuleContext) COLON() antlr.TerminalNode {
	return s.GetToken(JavaParserCOLON, 0)
}

func (s *SwitchLabeledRuleContext) ExpressionList() IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

func (s *SwitchLabeledRuleContext) NULL_LITERAL() antlr.TerminalNode {
	return s.GetToken(JavaParserNULL_LITERAL, 0)
}

func (s *SwitchLabeledRuleContext) GuardedPattern() IGuardedPatternContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGuardedPatternContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGuardedPatternContext)
}

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

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

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

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

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

func (p *JavaParser) SwitchLabeledRule() (localctx ISwitchLabeledRuleContext) {
	this := p
	_ = this

	localctx = NewSwitchLabeledRuleContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 208, JavaParserRULE_switchLabeledRule)
	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(1544)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserCASE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1533)
			p.Match(JavaParserCASE)
		}
		p.SetState(1537)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 182, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1534)
				p.ExpressionList()
			}

		case 2:
			{
				p.SetState(1535)
				p.Match(JavaParserNULL_LITERAL)
			}

		case 3:
			{
				p.SetState(1536)
				p.guardedPattern(0)
			}

		}
		{
			p.SetState(1539)
			_la = p.GetTokenStream().LA(1)

			if !(_la == JavaParserCOLON || _la == JavaParserARROW) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1540)
			p.SwitchRuleOutcome()
		}

	case JavaParserDEFAULT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1541)
			p.Match(JavaParserDEFAULT)
		}
		{
			p.SetState(1542)
			_la = p.GetTokenStream().LA(1)

			if !(_la == JavaParserCOLON || _la == JavaParserARROW) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1543)
			p.SwitchRuleOutcome()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyGuardedPatternContext() *GuardedPatternContext {
	var p = new(GuardedPatternContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_guardedPattern
	return p
}

func (*GuardedPatternContext) IsGuardedPatternContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_guardedPattern

	return p
}

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

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

func (s *GuardedPatternContext) GuardedPattern() IGuardedPatternContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGuardedPatternContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGuardedPatternContext)
}

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

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

	if t == nil {
		return nil
	}

	return t.(ITypeTypeContext)
}

func (s *GuardedPatternContext) Identifier() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IVariableModifierContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IAnnotationContext)
}

func (s *GuardedPatternContext) AllAND() []antlr.TerminalNode {
	return s.GetTokens(JavaParserAND)
}

func (s *GuardedPatternContext) AND(i int) antlr.TerminalNode {
	return s.GetToken(JavaParserAND, i)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

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

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

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

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

func (p *JavaParser) GuardedPattern() (localctx IGuardedPatternContext) {
	return p.guardedPattern(0)
}

func (p *JavaParser) guardedPattern(_p int) (localctx IGuardedPatternContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewGuardedPatternContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IGuardedPatternContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 210
	p.EnterRecursionRule(localctx, 210, JavaParserRULE_guardedPattern, _p)

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

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

	var _alt int

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

	switch p.GetTokenStream().LA(1) {
	case JavaParserLPAREN:
		{
			p.SetState(1547)
			p.Match(JavaParserLPAREN)
		}
		{
			p.SetState(1548)
			p.guardedPattern(0)
		}
		{
			p.SetState(1549)
			p.Match(JavaParserRPAREN)
		}

	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFINAL, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserSHORT, JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserAT, JavaParserIDENTIFIER:
		p.SetState(1554)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 184, p.GetParserRuleContext())

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

			}
			p.SetState(1556)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 184, p.GetParserRuleContext())
		}
		{
			p.SetState(1557)
			p.TypeType()
		}
		p.SetState(1561)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 185, p.GetParserRuleContext())

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

			}
			p.SetState(1563)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 185, p.GetParserRuleContext())
		}
		{
			p.SetState(1564)
			p.Identifier()
		}
		p.SetState(1569)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 186, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(1565)
					p.Match(JavaParserAND)
				}
				{
					p.SetState(1566)
					p.expression(0)
				}

			}
			p.SetState(1571)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 186, p.GetParserRuleContext())
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(1579)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 188, p.GetParserRuleContext())

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

			if !(p.Precpred(p.GetParserRuleContext(), 1)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
			}
			{
				p.SetState(1575)
				p.Match(JavaParserAND)
			}
			{
				p.SetState(1576)
				p.expression(0)
			}

		}
		p.SetState(1581)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 188, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptySwitchRuleOutcomeContext() *SwitchRuleOutcomeContext {
	var p = new(SwitchRuleOutcomeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = JavaParserRULE_switchRuleOutcome
	return p
}

func (*SwitchRuleOutcomeContext) IsSwitchRuleOutcomeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = JavaParserRULE_switchRuleOutcome

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IBlockStatementContext)
}

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

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

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

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

func (p *JavaParser) SwitchRuleOutcome() (localctx ISwitchRuleOutcomeContext) {
	this := p
	_ = this

	localctx = NewSwitchRuleOutcomeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 212, JavaParserRULE_switchRuleOutcome)
	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(1589)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 190, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1582)
			p.Block()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(1586)
		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<<(JavaParserMODULE-33))|(1<<(JavaParserOPEN-33))|(1<<(JavaParserREQUIRES-33))|(1<<(JavaParserEXPORTS-33))|(1<<(JavaParserOPENS-33))|(1<<(JavaParserTO-33))|(1<<(JavaParserUSES-33))|(1<<(JavaParserPROVIDES-33))|(1<<(JavaParserWITH-33))|(1<<(JavaParserTRANSITIVE-33))|(1<<(JavaParserVAR-33))|(1<<(JavaParserYIELD-33))|(1<<(JavaParserRECORD-33))|(1<<(JavaParserSEALED-33)))) != 0) || (((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(JavaParserPERMITS-65))|(1<<(JavaParserNON_SEALED-65))|(1<<(JavaParserDECIMAL_LITERAL-65))|(1<<(JavaParserHEX_LITERAL-65))|(1<<(JavaParserOCT_LITERAL-65))|(1<<(JavaParserBINARY_LITERAL-65))|(1<<(JavaParserFLOAT_LITERAL-65))|(1<<(JavaParserHEX_FLOAT_LITERAL-65))|(1<<(JavaParserBOOL_LITERAL-65))|(1<<(JavaParserCHAR_LITERAL-65))|(1<<(JavaParserSTRING_LITERAL-65))|(1<<(JavaParserTEXT_BLOCK-65))|(1<<(JavaParserNULL_LITERAL-65))|(1<<(JavaParserLPAREN-65))|(1<<(JavaParserLBRACE-65))|(1<<(JavaParserSEMI-65))|(1<<(JavaParserLT-65))|(1<<(JavaParserBANG-65))|(1<<(JavaParserTILDE-65)))) != 0) || (((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(JavaParserINC-100))|(1<<(JavaParserDEC-100))|(1<<(JavaParserADD-100))|(1<<(JavaParserSUB-100))|(1<<(JavaParserAT-100))|(1<<(JavaParserIDENTIFIER-100)))) != 0) {
			{
				p.SetState(1583)
				p.BlockStatement()
			}

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

	}

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

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewClassTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 214, 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)
			}
		}
	}()

	var _alt int

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 191, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1591)
			p.ClassOrInterfaceType()
		}
		{
			p.SetState(1592)
			p.Match(JavaParserDOT)
		}

	}
	p.SetState(1599)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 192, p.GetParserRuleContext())

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

		}
		p.SetState(1601)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 192, p.GetParserRuleContext())
	}
	{
		p.SetState(1602)
		p.Identifier()
	}
	p.SetState(1604)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserLT {
		{
			p.SetState(1603)
			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) {
	this := p
	_ = this

	localctx = NewCreatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 216, 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(1615)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserLT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1606)
			p.NonWildcardTypeArguments()
		}
		{
			p.SetState(1607)
			p.CreatedName()
		}
		{
			p.SetState(1608)
			p.ClassCreatorRest()
		}

	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserSHORT, JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1610)
			p.CreatedName()
		}
		p.SetState(1613)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case JavaParserLBRACK:
			{
				p.SetState(1611)
				p.ArrayCreatorRest()
			}

		case JavaParserLPAREN:
			{
				p.SetState(1612)
				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() []IIdentifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIdentifierContext)(nil)).Elem())
	var tst = make([]IIdentifierContext, len(ts))

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

	return tst
}

func (s *CreatedNameContext) Identifier(i int) IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewCreatedNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 218, 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(1632)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1617)
			p.Identifier()
		}
		p.SetState(1619)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserLT {
			{
				p.SetState(1618)
				p.TypeArgumentsOrDiamond()
			}

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

		for _la == JavaParserDOT {
			{
				p.SetState(1621)
				p.Match(JavaParserDOT)
			}
			{
				p.SetState(1622)
				p.Identifier()
			}
			p.SetState(1624)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == JavaParserLT {
				{
					p.SetState(1623)
					p.TypeArgumentsOrDiamond()
				}

			}

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

	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserSHORT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1631)
			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() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewInnerCreatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 220, 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(1634)
		p.Identifier()
	}
	p.SetState(1636)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == JavaParserLT {
		{
			p.SetState(1635)
			p.NonWildcardTypeArgumentsOrDiamond()
		}

	}
	{
		p.SetState(1638)
		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) {
	this := p
	_ = this

	localctx = NewArrayCreatorRestContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 222, 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(1640)
		p.Match(JavaParserLBRACK)
	}
	p.SetState(1668)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserRBRACK:
		{
			p.SetState(1641)
			p.Match(JavaParserRBRACK)
		}
		p.SetState(1646)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == JavaParserLBRACK {
			{
				p.SetState(1642)
				p.Match(JavaParserLBRACK)
			}
			{
				p.SetState(1643)
				p.Match(JavaParserRBRACK)
			}

			p.SetState(1648)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1649)
			p.ArrayInitializer()
		}

	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserNEW, JavaParserSHORT, JavaParserSUPER, JavaParserSWITCH, JavaParserTHIS, JavaParserVOID, JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserDECIMAL_LITERAL, JavaParserHEX_LITERAL, JavaParserOCT_LITERAL, JavaParserBINARY_LITERAL, JavaParserFLOAT_LITERAL, JavaParserHEX_FLOAT_LITERAL, JavaParserBOOL_LITERAL, JavaParserCHAR_LITERAL, JavaParserSTRING_LITERAL, JavaParserTEXT_BLOCK, JavaParserNULL_LITERAL, JavaParserLPAREN, JavaParserLT, JavaParserBANG, JavaParserTILDE, JavaParserINC, JavaParserDEC, JavaParserADD, JavaParserSUB, JavaParserAT, JavaParserIDENTIFIER:
		{
			p.SetState(1650)
			p.expression(0)
		}
		{
			p.SetState(1651)
			p.Match(JavaParserRBRACK)
		}
		p.SetState(1658)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 202, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(1652)
					p.Match(JavaParserLBRACK)
				}
				{
					p.SetState(1653)
					p.expression(0)
				}
				{
					p.SetState(1654)
					p.Match(JavaParserRBRACK)
				}

			}
			p.SetState(1660)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 202, p.GetParserRuleContext())
		}
		p.SetState(1665)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 203, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(1661)
					p.Match(JavaParserLBRACK)
				}
				{
					p.SetState(1662)
					p.Match(JavaParserRBRACK)
				}

			}
			p.SetState(1667)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 203, 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) {
	this := p
	_ = this

	localctx = NewClassCreatorRestContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 224, 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(1670)
		p.Arguments()
	}
	p.SetState(1672)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 205, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1671)
			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) {
	this := p
	_ = this

	localctx = NewExplicitGenericInvocationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 226, 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(1674)
		p.NonWildcardTypeArguments()
	}
	{
		p.SetState(1675)
		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) {
	this := p
	_ = this

	localctx = NewTypeArgumentsOrDiamondContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 228, 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(1680)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 206, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1677)
			p.Match(JavaParserLT)
		}
		{
			p.SetState(1678)
			p.Match(JavaParserGT)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1679)
			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) {
	this := p
	_ = this

	localctx = NewNonWildcardTypeArgumentsOrDiamondContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 230, 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(1685)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 207, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1682)
			p.Match(JavaParserLT)
		}
		{
			p.SetState(1683)
			p.Match(JavaParserGT)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1684)
			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) {
	this := p
	_ = this

	localctx = NewNonWildcardTypeArgumentsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 232, 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(1687)
		p.Match(JavaParserLT)
	}
	{
		p.SetState(1688)
		p.TypeList()
	}
	{
		p.SetState(1689)
		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) {
	this := p
	_ = this

	localctx = NewTypeListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 234, 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(1691)
		p.TypeType()
	}
	p.SetState(1696)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(1692)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(1693)
			p.TypeType()
		}

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

	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) {
	this := p
	_ = this

	localctx = NewTypeTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 236, 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(1702)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 209, p.GetParserRuleContext())

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

		}
		p.SetState(1704)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 209, p.GetParserRuleContext())
	}
	p.SetState(1707)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserIDENTIFIER:
		{
			p.SetState(1705)
			p.ClassOrInterfaceType()
		}

	case JavaParserBOOLEAN, JavaParserBYTE, JavaParserCHAR, JavaParserDOUBLE, JavaParserFLOAT, JavaParserINT, JavaParserLONG, JavaParserSHORT:
		{
			p.SetState(1706)
			p.PrimitiveType()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	p.SetState(1719)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 212, p.GetParserRuleContext())

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

			for (((_la-51)&-(0x1f+1)) == 0 && ((1<<uint((_la-51)))&((1<<(JavaParserMODULE-51))|(1<<(JavaParserOPEN-51))|(1<<(JavaParserREQUIRES-51))|(1<<(JavaParserEXPORTS-51))|(1<<(JavaParserOPENS-51))|(1<<(JavaParserTO-51))|(1<<(JavaParserUSES-51))|(1<<(JavaParserPROVIDES-51))|(1<<(JavaParserWITH-51))|(1<<(JavaParserTRANSITIVE-51))|(1<<(JavaParserVAR-51))|(1<<(JavaParserYIELD-51))|(1<<(JavaParserRECORD-51))|(1<<(JavaParserSEALED-51))|(1<<(JavaParserPERMITS-51)))) != 0) || _la == JavaParserAT || _la == JavaParserIDENTIFIER {
				{
					p.SetState(1709)
					p.Annotation()
				}

				p.SetState(1714)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(1715)
				p.Match(JavaParserLBRACK)
			}
			{
				p.SetState(1716)
				p.Match(JavaParserRBRACK)
			}

		}
		p.SetState(1721)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 212, 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) {
	this := p
	_ = this

	localctx = NewPrimitiveTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 238, 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(1722)
		_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) {
	this := p
	_ = this

	localctx = NewTypeArgumentsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 240, 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(1724)
		p.Match(JavaParserLT)
	}
	{
		p.SetState(1725)
		p.TypeArgument()
	}
	p.SetState(1730)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == JavaParserCOMMA {
		{
			p.SetState(1726)
			p.Match(JavaParserCOMMA)
		}
		{
			p.SetState(1727)
			p.TypeArgument()
		}

		p.SetState(1732)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1733)
		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() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

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) {
	this := p
	_ = this

	localctx = NewSuperSuffixContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 242, JavaParserRULE_superSuffix)
	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(1744)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserLPAREN:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1735)
			p.Arguments()
		}

	case JavaParserDOT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1736)
			p.Match(JavaParserDOT)
		}
		p.SetState(1738)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == JavaParserLT {
			{
				p.SetState(1737)
				p.TypeArguments()
			}

		}
		{
			p.SetState(1740)
			p.Identifier()
		}
		p.SetState(1742)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 215, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1741)
				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() IIdentifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierContext)
}

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) {
	this := p
	_ = this

	localctx = NewExplicitGenericInvocationSuffixContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 244, 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(1751)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case JavaParserSUPER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1746)
			p.Match(JavaParserSUPER)
		}
		{
			p.SetState(1747)
			p.SuperSuffix()
		}

	case JavaParserMODULE, JavaParserOPEN, JavaParserREQUIRES, JavaParserEXPORTS, JavaParserOPENS, JavaParserTO, JavaParserUSES, JavaParserPROVIDES, JavaParserWITH, JavaParserTRANSITIVE, JavaParserVAR, JavaParserYIELD, JavaParserRECORD, JavaParserSEALED, JavaParserPERMITS, JavaParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1748)
			p.Identifier()
		}
		{
			p.SetState(1749)
			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) {
	this := p
	_ = this

	localctx = NewArgumentsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 246, 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(1753)
		p.Match(JavaParserLPAREN)
	}
	p.SetState(1755)
	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<<(JavaParserSWITCH-37))|(1<<(JavaParserTHIS-37))|(1<<(JavaParserVOID-37))|(1<<(JavaParserMODULE-37))|(1<<(JavaParserOPEN-37))|(1<<(JavaParserREQUIRES-37))|(1<<(JavaParserEXPORTS-37))|(1<<(JavaParserOPENS-37))|(1<<(JavaParserTO-37))|(1<<(JavaParserUSES-37))|(1<<(JavaParserPROVIDES-37))|(1<<(JavaParserWITH-37))|(1<<(JavaParserTRANSITIVE-37))|(1<<(JavaParserVAR-37))|(1<<(JavaParserYIELD-37))|(1<<(JavaParserRECORD-37))|(1<<(JavaParserSEALED-37))|(1<<(JavaParserPERMITS-37))|(1<<(JavaParserDECIMAL_LITERAL-37))|(1<<(JavaParserHEX_LITERAL-37)))) != 0) || (((_la-69)&-(0x1f+1)) == 0 && ((1<<uint((_la-69)))&((1<<(JavaParserOCT_LITERAL-69))|(1<<(JavaParserBINARY_LITERAL-69))|(1<<(JavaParserFLOAT_LITERAL-69))|(1<<(JavaParserHEX_FLOAT_LITERAL-69))|(1<<(JavaParserBOOL_LITERAL-69))|(1<<(JavaParserCHAR_LITERAL-69))|(1<<(JavaParserSTRING_LITERAL-69))|(1<<(JavaParserTEXT_BLOCK-69))|(1<<(JavaParserNULL_LITERAL-69))|(1<<(JavaParserLPAREN-69))|(1<<(JavaParserLT-69))|(1<<(JavaParserBANG-69))|(1<<(JavaParserTILDE-69))|(1<<(JavaParserINC-69)))) != 0) || (((_la-101)&-(0x1f+1)) == 0 && ((1<<uint((_la-101)))&((1<<(JavaParserDEC-101))|(1<<(JavaParserADD-101))|(1<<(JavaParserSUB-101))|(1<<(JavaParserAT-101))|(1<<(JavaParserIDENTIFIER-101)))) != 0) {
		{
			p.SetState(1754)
			p.ExpressionList()
		}

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

	return localctx
}

func (p *JavaParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
	switch ruleIndex {
	case 97:
		var t *ExpressionContext = nil
		if localctx != nil {
			t = localctx.(*ExpressionContext)
		}
		return p.Expression_Sempred(t, predIndex)

	case 105:
		var t *GuardedPatternContext = nil
		if localctx != nil {
			t = localctx.(*GuardedPatternContext)
		}
		return p.GuardedPattern_Sempred(t, predIndex)

	default:
		panic("No predicate with index: " + fmt.Sprint(ruleIndex))
	}
}

func (p *JavaParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 0:
		return p.Precpred(p.GetParserRuleContext(), 18)

	case 1:
		return p.Precpred(p.GetParserRuleContext(), 17)

	case 2:
		return p.Precpred(p.GetParserRuleContext(), 16)

	case 3:
		return p.Precpred(p.GetParserRuleContext(), 15)

	case 4:
		return p.Precpred(p.GetParserRuleContext(), 13)

	case 5:
		return p.Precpred(p.GetParserRuleContext(), 12)

	case 6:
		return p.Precpred(p.GetParserRuleContext(), 11)

	case 7:
		return p.Precpred(p.GetParserRuleContext(), 10)

	case 8:
		return p.Precpred(p.GetParserRuleContext(), 9)

	case 9:
		return p.Precpred(p.GetParserRuleContext(), 8)

	case 10:
		return p.Precpred(p.GetParserRuleContext(), 7)

	case 11:
		return p.Precpred(p.GetParserRuleContext(), 6)

	case 12:
		return p.Precpred(p.GetParserRuleContext(), 26)

	case 13:
		return p.Precpred(p.GetParserRuleContext(), 25)

	case 14:
		return p.Precpred(p.GetParserRuleContext(), 21)

	case 15:
		return p.Precpred(p.GetParserRuleContext(), 14)

	case 16:
		return p.Precpred(p.GetParserRuleContext(), 3)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *JavaParser) GuardedPattern_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 17:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}
