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

package parser // TypeScriptParser

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

var literalNames = []string{
	"", "", "", "", "", "'['", "']'", "'('", "')'", "'{'", "'}'", "';'", "','",
	"'='", "'?'", "':'", "'...'", "'.'", "'++'", "'--'", "'+'", "'-'", "'~'",
	"'!'", "'*'", "'_'", "'$'", "'/'", "'%'", "'**'", "'??'", "'#'", "'>>'",
	"'<<'", "'>>>'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "'==='",
	"'!=='", "'&'", "'^'", "'|'", "'&&'", "'||'", "'*='", "'/='", "'%='", "'+='",
	"'-='", "'<<='", "'>>='", "'>>>='", "'&='", "'^='", "'|='", "'=>'", "'**='",
	"'null'", "", "", "", "", "", "", "'break'", "'do'", "'instanceof'", "'typeof'",
	"'case'", "'else'", "'new'", "'var'", "'catch'", "'finally'", "'return'",
	"'void'", "'continue'", "'for'", "'switch'", "'while'", "'debugger'", "'function'",
	"'this'", "'with'", "'default'", "'if'", "'throw'", "'delete'", "'in'",
	"'try'", "'as'", "'from'", "'readonly'", "'async'", "'class'", "'enum'",
	"'extends'", "'super'", "'const'", "'export'", "'import'", "'await'", "'implements'",
	"'let'", "'private'", "'public'", "'interface'", "'package'", "'protected'",
	"'static'", "'yield'", "'any'", "'number'", "'boolean'", "'string'", "'symbol'",
	"'type'", "'get '", "'set '", "'constructor'", "'namespace'", "'require'",
	"'module'", "'declare'", "'abstract'", "'is'", "'@'",
}
var symbolicNames = []string{
	"", "HashBangLine", "MultiLineComment", "SingleLineComment", "RegularExpressionLiteral",
	"OpenBracket", "CloseBracket", "OpenParen", "CloseParen", "OpenBrace",
	"CloseBrace", "SemiColon", "Comma", "Assign", "QuestionMark", "Colon",
	"Ellipsis", "Dot", "PlusPlus", "MinusMinus", "Plus", "Minus", "BitNot",
	"Not", "Multiply", "Lodash", "Dollar", "Divide", "Modulus", "Power", "NullCoalesce",
	"Hashtag", "RightShiftArithmetic", "LeftShiftArithmetic", "RightShiftLogical",
	"LessThan", "MoreThan", "LessThanEquals", "GreaterThanEquals", "Equals_",
	"NotEquals", "IdentityEquals", "IdentityNotEquals", "BitAnd", "BitXOr",
	"BitOr", "And", "Or", "MultiplyAssign", "DivideAssign", "ModulusAssign",
	"PlusAssign", "MinusAssign", "LeftShiftArithmeticAssign", "RightShiftArithmeticAssign",
	"RightShiftLogicalAssign", "BitAndAssign", "BitXorAssign", "BitOrAssign",
	"ARROW", "PowerAssign", "NullLiteral", "BooleanLiteral", "DecimalLiteral",
	"HexIntegerLiteral", "OctalIntegerLiteral", "OctalIntegerLiteral2", "BinaryIntegerLiteral",
	"Break", "Do", "Instanceof", "Typeof", "Case", "Else", "New", "Var", "Catch",
	"Finally", "Return", "Void", "Continue", "For", "Switch", "While", "Debugger",
	"Function", "This", "With", "Default", "If", "Throw", "Delete", "In", "Try",
	"As", "From", "ReadOnly", "Async", "NodeName", "Enum", "Extends", "Super",
	"Const", "Export", "Import", "Await", "Implements", "Let", "Private", "Public",
	"Interface", "Package", "Protected", "Static", "Yield", "ANY", "NUMBER",
	"BOOLEAN", "STRING", "SYMBOL", "TypeType", "Get", "Set", "Constructor", "Namespace",
	"Require", "Module", "Declare", "Abstract", "Is", "At", "Identifier", "StringLiteral",
	"TemplateStringLiteral", "WhiteSpaces", "LineTerminator", "HtmlComment",
	"CDataComment", "UnexpectedCharacter",
}

var ruleNames = []string{
	"initializer", "bindingPattern", "typeParameters", "typeParameterList",
	"typeParameter", "constraint", "typeArguments", "typeArgumentList", "typeArgument",
	"type_", "unionOrIntersectionOrPrimaryType", "primaryType", "predefinedType",
	"typeReference", "typeGeneric", "typeIncludeGeneric", "typeName", "objectType",
	"typeBody", "typeMemberList", "typeMember", "arrayType", "tupleType", "tupleElementTypes",
	"functionType", "constructorType", "typeQuery", "typeQueryExpression",
	"propertySignature", "typeAnnotation", "callSignature", "parameterList",
	"requiredParameterList", "requiredParameter", "accessibilityModifier",
	"identifierOrPattern", "optionalParameterList", "optionalParameter", "restParameter",
	"constructSignature", "indexSignature", "methodSignature", "typeAliasDeclaration",
	"constructorDeclaration", "interfaceDeclaration", "interfaceExtendsClause",
	"classOrInterfaceTypeList", "enumDeclaration", "enumBody", "enumMemberList",
	"enumMember", "namespaceDeclaration", "namespaceName", "importAliasDeclaration",
	"importAll", "decoratorList", "decorator", "decoratorMemberExpression",
	"decoratorCallExpression", "program", "sourceElement", "statement", "block",
	"statementList", "abstractDeclaration", "importStatement", "importFromBlock",
	"multipleImportStatement", "exportStatement", "variableStatement", "variableDeclarationList",
	"variableDeclaration", "emptyStatement_", "expressionStatement", "ifStatement",
	"iterationStatement", "varModifier", "continueStatement", "breakStatement",
	"returnStatement", "yieldStatement", "withStatement", "switchStatement",
	"caseBlock", "caseClauses", "caseClause", "defaultClause", "labelledStatement",
	"throwStatement", "tryStatement", "catchProduction", "assignable", "finallyProduction",
	"debuggerStatement", "functionDeclaration", "classDeclaration", "classHeritage",
	"classTail", "classExtendsClause", "implementsClause", "classElement",
	"propertyMemberDeclaration", "propertyMemberBase", "indexMemberDeclaration",
	"generatorMethod", "generatorFunctionDeclaration", "generatorBlock", "generatorDefinition",
	"iteratorBlock", "iteratorDefinition", "formalParameterList", "formalParameterArg",
	"lastFormalParameterArg", "functionBody", "sourceElements", "arrayLiteral",
	"elementList", "lastElement", "objectLiteral", "propertyAssignment", "getAccessor",
	"setAccessor", "propertyName", "arguments", "lastArgument", "expressionSequence",
	"functionExpressionDeclaration", "singleExpression", "arrowFunctionDeclaration",
	"arrowFunctionParameters", "arrowFunctionBody", "assignmentOperator", "literal",
	"numericLiteral", "identifierName", "reservedWord", "keyword", "getter",
	"setter", "eos",
}
var decisionToDFA = make([]*antlr.DFA, len(deserializedATN.DecisionToState))

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

type TypeScriptParser struct {
	TypeScriptBaseParser
}

func NewTypeScriptParser(input antlr.TokenStream) *TypeScriptParser {
	this := new(TypeScriptParser)

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

	return this
}

// TypeScriptParser tokens.
const (
	TypeScriptParserEOF                        = antlr.TokenEOF
	TypeScriptParserHashBangLine               = 1
	TypeScriptParserMultiLineComment           = 2
	TypeScriptParserSingleLineComment          = 3
	TypeScriptParserRegularExpressionLiteral   = 4
	TypeScriptParserOpenBracket                = 5
	TypeScriptParserCloseBracket               = 6
	TypeScriptParserOpenParen                  = 7
	TypeScriptParserCloseParen                 = 8
	TypeScriptParserOpenBrace                  = 9
	TypeScriptParserCloseBrace                 = 10
	TypeScriptParserSemiColon                  = 11
	TypeScriptParserComma                      = 12
	TypeScriptParserAssign                     = 13
	TypeScriptParserQuestionMark               = 14
	TypeScriptParserColon                      = 15
	TypeScriptParserEllipsis                   = 16
	TypeScriptParserDot                        = 17
	TypeScriptParserPlusPlus                   = 18
	TypeScriptParserMinusMinus                 = 19
	TypeScriptParserPlus                       = 20
	TypeScriptParserMinus                      = 21
	TypeScriptParserBitNot                     = 22
	TypeScriptParserNot                        = 23
	TypeScriptParserMultiply                   = 24
	TypeScriptParserLodash                     = 25
	TypeScriptParserDollar                     = 26
	TypeScriptParserDivide                     = 27
	TypeScriptParserModulus                    = 28
	TypeScriptParserPower                      = 29
	TypeScriptParserNullCoalesce               = 30
	TypeScriptParserHashtag                    = 31
	TypeScriptParserRightShiftArithmetic       = 32
	TypeScriptParserLeftShiftArithmetic        = 33
	TypeScriptParserRightShiftLogical          = 34
	TypeScriptParserLessThan                   = 35
	TypeScriptParserMoreThan                   = 36
	TypeScriptParserLessThanEquals             = 37
	TypeScriptParserGreaterThanEquals          = 38
	TypeScriptParserEquals_                    = 39
	TypeScriptParserNotEquals                  = 40
	TypeScriptParserIdentityEquals             = 41
	TypeScriptParserIdentityNotEquals          = 42
	TypeScriptParserBitAnd                     = 43
	TypeScriptParserBitXOr                     = 44
	TypeScriptParserBitOr                      = 45
	TypeScriptParserAnd                        = 46
	TypeScriptParserOr                         = 47
	TypeScriptParserMultiplyAssign             = 48
	TypeScriptParserDivideAssign               = 49
	TypeScriptParserModulusAssign              = 50
	TypeScriptParserPlusAssign                 = 51
	TypeScriptParserMinusAssign                = 52
	TypeScriptParserLeftShiftArithmeticAssign  = 53
	TypeScriptParserRightShiftArithmeticAssign = 54
	TypeScriptParserRightShiftLogicalAssign    = 55
	TypeScriptParserBitAndAssign               = 56
	TypeScriptParserBitXorAssign               = 57
	TypeScriptParserBitOrAssign                = 58
	TypeScriptParserARROW                      = 59
	TypeScriptParserPowerAssign                = 60
	TypeScriptParserNullLiteral                = 61
	TypeScriptParserBooleanLiteral             = 62
	TypeScriptParserDecimalLiteral             = 63
	TypeScriptParserHexIntegerLiteral          = 64
	TypeScriptParserOctalIntegerLiteral        = 65
	TypeScriptParserOctalIntegerLiteral2       = 66
	TypeScriptParserBinaryIntegerLiteral       = 67
	TypeScriptParserBreak                      = 68
	TypeScriptParserDo                         = 69
	TypeScriptParserInstanceof                 = 70
	TypeScriptParserTypeof                     = 71
	TypeScriptParserCase                       = 72
	TypeScriptParserElse                       = 73
	TypeScriptParserNew                        = 74
	TypeScriptParserVar                        = 75
	TypeScriptParserCatch                      = 76
	TypeScriptParserFinally                    = 77
	TypeScriptParserReturn                     = 78
	TypeScriptParserVoid                       = 79
	TypeScriptParserContinue                   = 80
	TypeScriptParserFor                        = 81
	TypeScriptParserSwitch                     = 82
	TypeScriptParserWhile                      = 83
	TypeScriptParserDebugger                   = 84
	TypeScriptParserFunction                   = 85
	TypeScriptParserThis                       = 86
	TypeScriptParserWith                       = 87
	TypeScriptParserDefault                    = 88
	TypeScriptParserIf                         = 89
	TypeScriptParserThrow                      = 90
	TypeScriptParserDelete                     = 91
	TypeScriptParserIn                         = 92
	TypeScriptParserTry                        = 93
	TypeScriptParserAs                         = 94
	TypeScriptParserFrom                       = 95
	TypeScriptParserReadOnly                   = 96
	TypeScriptParserAsync                      = 97
	TypeScriptParserClass                      = 98
	TypeScriptParserEnum                       = 99
	TypeScriptParserExtends                    = 100
	TypeScriptParserSuper                      = 101
	TypeScriptParserConst                      = 102
	TypeScriptParserExport                     = 103
	TypeScriptParserImport                     = 104
	TypeScriptParserAwait                      = 105
	TypeScriptParserImplements                 = 106
	TypeScriptParserLet                        = 107
	TypeScriptParserPrivate                    = 108
	TypeScriptParserPublic                     = 109
	TypeScriptParserInterface                  = 110
	TypeScriptParserPackage                    = 111
	TypeScriptParserProtected                  = 112
	TypeScriptParserStatic                     = 113
	TypeScriptParserYield                      = 114
	TypeScriptParserANY                        = 115
	TypeScriptParserNUMBER                     = 116
	TypeScriptParserBOOLEAN                    = 117
	TypeScriptParserSTRING                     = 118
	TypeScriptParserSYMBOL                     = 119
	TypeScriptParserType                       = 120
	TypeScriptParserGet                        = 121
	TypeScriptParserSet                        = 122
	TypeScriptParserConstructor                = 123
	TypeScriptParserNamespace                  = 124
	TypeScriptParserRequire                    = 125
	TypeScriptParserModule                     = 126
	TypeScriptParserDeclare                    = 127
	TypeScriptParserAbstract                   = 128
	TypeScriptParserIs                         = 129
	TypeScriptParserAt                         = 130
	TypeScriptParserIdentifier                 = 131
	TypeScriptParserStringLiteral              = 132
	TypeScriptParserTemplateStringLiteral      = 133
	TypeScriptParserWhiteSpaces                = 134
	TypeScriptParserLineTerminator             = 135
	TypeScriptParserHtmlComment                = 136
	TypeScriptParserCDataComment               = 137
	TypeScriptParserUnexpectedCharacter        = 138
)

// TypeScriptParser rules.
const (
	TypeScriptParserRULE_initializer                      = 0
	TypeScriptParserRULE_bindingPattern                   = 1
	TypeScriptParserRULE_typeParameters                   = 2
	TypeScriptParserRULE_typeParameterList                = 3
	TypeScriptParserRULE_typeParameter                    = 4
	TypeScriptParserRULE_constraint                       = 5
	TypeScriptParserRULE_typeArguments                    = 6
	TypeScriptParserRULE_typeArgumentList                 = 7
	TypeScriptParserRULE_typeArgument                     = 8
	TypeScriptParserRULE_type_                            = 9
	TypeScriptParserRULE_unionOrIntersectionOrPrimaryType = 10
	TypeScriptParserRULE_primaryType                      = 11
	TypeScriptParserRULE_predefinedType                   = 12
	TypeScriptParserRULE_typeReference                    = 13
	TypeScriptParserRULE_typeGeneric                      = 14
	TypeScriptParserRULE_typeIncludeGeneric               = 15
	TypeScriptParserRULE_typeName                         = 16
	TypeScriptParserRULE_objectType                       = 17
	TypeScriptParserRULE_typeBody                         = 18
	TypeScriptParserRULE_typeMemberList                   = 19
	TypeScriptParserRULE_typeMember                       = 20
	TypeScriptParserRULE_arrayType                        = 21
	TypeScriptParserRULE_tupleType                        = 22
	TypeScriptParserRULE_tupleElementTypes                = 23
	TypeScriptParserRULE_functionType                     = 24
	TypeScriptParserRULE_constructorType                  = 25
	TypeScriptParserRULE_typeQuery                        = 26
	TypeScriptParserRULE_typeQueryExpression              = 27
	TypeScriptParserRULE_propertySignature                = 28
	TypeScriptParserRULE_typeAnnotation                   = 29
	TypeScriptParserRULE_callSignature                    = 30
	TypeScriptParserRULE_parameterList                    = 31
	TypeScriptParserRULE_requiredParameterList            = 32
	TypeScriptParserRULE_requiredParameter                = 33
	TypeScriptParserRULE_accessibilityModifier            = 34
	TypeScriptParserRULE_identifierOrPattern              = 35
	TypeScriptParserRULE_optionalParameterList            = 36
	TypeScriptParserRULE_optionalParameter                = 37
	TypeScriptParserRULE_restParameter                    = 38
	TypeScriptParserRULE_constructSignature               = 39
	TypeScriptParserRULE_indexSignature                   = 40
	TypeScriptParserRULE_methodSignature                  = 41
	TypeScriptParserRULE_typeAliasDeclaration             = 42
	TypeScriptParserRULE_constructorDeclaration           = 43
	TypeScriptParserRULE_interfaceDeclaration             = 44
	TypeScriptParserRULE_interfaceExtendsClause           = 45
	TypeScriptParserRULE_classOrInterfaceTypeList         = 46
	TypeScriptParserRULE_enumDeclaration                  = 47
	TypeScriptParserRULE_enumBody                         = 48
	TypeScriptParserRULE_enumMemberList                   = 49
	TypeScriptParserRULE_enumMember                       = 50
	TypeScriptParserRULE_namespaceDeclaration             = 51
	TypeScriptParserRULE_namespaceName                    = 52
	TypeScriptParserRULE_importAliasDeclaration           = 53
	TypeScriptParserRULE_importAll                        = 54
	TypeScriptParserRULE_decoratorList                    = 55
	TypeScriptParserRULE_decorator                        = 56
	TypeScriptParserRULE_decoratorMemberExpression        = 57
	TypeScriptParserRULE_decoratorCallExpression          = 58
	TypeScriptParserRULE_program                          = 59
	TypeScriptParserRULE_sourceElement                    = 60
	TypeScriptParserRULE_statement                        = 61
	TypeScriptParserRULE_block                            = 62
	TypeScriptParserRULE_statementList                    = 63
	TypeScriptParserRULE_abstractDeclaration              = 64
	TypeScriptParserRULE_importStatement                  = 65
	TypeScriptParserRULE_importFromBlock                  = 66
	TypeScriptParserRULE_multipleImportStatement          = 67
	TypeScriptParserRULE_exportStatement                  = 68
	TypeScriptParserRULE_variableStatement                = 69
	TypeScriptParserRULE_variableDeclarationList          = 70
	TypeScriptParserRULE_variableDeclaration              = 71
	TypeScriptParserRULE_emptyStatement_                  = 72
	TypeScriptParserRULE_expressionStatement              = 73
	TypeScriptParserRULE_ifStatement                      = 74
	TypeScriptParserRULE_iterationStatement               = 75
	TypeScriptParserRULE_varModifier                      = 76
	TypeScriptParserRULE_continueStatement                = 77
	TypeScriptParserRULE_breakStatement                   = 78
	TypeScriptParserRULE_returnStatement                  = 79
	TypeScriptParserRULE_yieldStatement                   = 80
	TypeScriptParserRULE_withStatement                    = 81
	TypeScriptParserRULE_switchStatement                  = 82
	TypeScriptParserRULE_caseBlock                        = 83
	TypeScriptParserRULE_caseClauses                      = 84
	TypeScriptParserRULE_caseClause                       = 85
	TypeScriptParserRULE_defaultClause                    = 86
	TypeScriptParserRULE_labelledStatement                = 87
	TypeScriptParserRULE_throwStatement                   = 88
	TypeScriptParserRULE_tryStatement                     = 89
	TypeScriptParserRULE_catchProduction                  = 90
	TypeScriptParserRULE_assignable                       = 91
	TypeScriptParserRULE_finallyProduction                = 92
	TypeScriptParserRULE_debuggerStatement                = 93
	TypeScriptParserRULE_functionDeclaration              = 94
	TypeScriptParserRULE_classDeclaration                 = 95
	TypeScriptParserRULE_classHeritage                    = 96
	TypeScriptParserRULE_classTail                        = 97
	TypeScriptParserRULE_classExtendsClause               = 98
	TypeScriptParserRULE_implementsClause                 = 99
	TypeScriptParserRULE_classElement                     = 100
	TypeScriptParserRULE_propertyMemberDeclaration        = 101
	TypeScriptParserRULE_propertyMemberBase               = 102
	TypeScriptParserRULE_indexMemberDeclaration           = 103
	TypeScriptParserRULE_generatorMethod                  = 104
	TypeScriptParserRULE_generatorFunctionDeclaration     = 105
	TypeScriptParserRULE_generatorBlock                   = 106
	TypeScriptParserRULE_generatorDefinition              = 107
	TypeScriptParserRULE_iteratorBlock                    = 108
	TypeScriptParserRULE_iteratorDefinition               = 109
	TypeScriptParserRULE_formalParameterList              = 110
	TypeScriptParserRULE_formalParameterArg               = 111
	TypeScriptParserRULE_lastFormalParameterArg           = 112
	TypeScriptParserRULE_functionBody                     = 113
	TypeScriptParserRULE_sourceElements                   = 114
	TypeScriptParserRULE_arrayLiteral                     = 115
	TypeScriptParserRULE_elementList                      = 116
	TypeScriptParserRULE_lastElement                      = 117
	TypeScriptParserRULE_objectLiteral                    = 118
	TypeScriptParserRULE_propertyAssignment               = 119
	TypeScriptParserRULE_getAccessor                      = 120
	TypeScriptParserRULE_setAccessor                      = 121
	TypeScriptParserRULE_propertyName                     = 122
	TypeScriptParserRULE_arguments                        = 123
	TypeScriptParserRULE_lastArgument                     = 124
	TypeScriptParserRULE_expressionSequence               = 125
	TypeScriptParserRULE_functionExpressionDeclaration    = 126
	TypeScriptParserRULE_singleExpression                 = 127
	TypeScriptParserRULE_arrowFunctionDeclaration         = 128
	TypeScriptParserRULE_arrowFunctionParameters          = 129
	TypeScriptParserRULE_arrowFunctionBody                = 130
	TypeScriptParserRULE_assignmentOperator               = 131
	TypeScriptParserRULE_literal                          = 132
	TypeScriptParserRULE_numericLiteral                   = 133
	TypeScriptParserRULE_identifierName                   = 134
	TypeScriptParserRULE_reservedWord                     = 135
	TypeScriptParserRULE_keyword                          = 136
	TypeScriptParserRULE_getter                           = 137
	TypeScriptParserRULE_setter                           = 138
	TypeScriptParserRULE_eos                              = 139
)

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

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

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

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

func NewEmptyInitializerContext() *InitializerContext {
	var p = new(InitializerContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_initializer
	return p
}

func (*InitializerContext) IsInitializerContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_initializer

	return p
}

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

func (s *InitializerContext) Assign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAssign, 0)
}

func (s *InitializerContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

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

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

func (s *InitializerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterInitializer(s)
	}
}

func (s *InitializerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitInitializer(s)
	}
}

func (p *TypeScriptParser) Initializer() (localctx IInitializerContext) {
	localctx = NewInitializerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 0, TypeScriptParserRULE_initializer)

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

	defer func() {
		if err := recover(); err != nil {
			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(280)
		p.Match(TypeScriptParserAssign)
	}
	{
		p.SetState(281)
		p.singleExpression(0)
	}

	return localctx
}

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

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

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

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

func NewEmptyBindingPatternContext() *BindingPatternContext {
	var p = new(BindingPatternContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_bindingPattern
	return p
}

func (*BindingPatternContext) IsBindingPatternContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_bindingPattern

	return p
}

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

func (s *BindingPatternContext) ArrayLiteral() IArrayLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayLiteralContext)
}

func (s *BindingPatternContext) ObjectLiteral() IObjectLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IObjectLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IObjectLiteralContext)
}

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

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

func (s *BindingPatternContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterBindingPattern(s)
	}
}

func (s *BindingPatternContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitBindingPattern(s)
	}
}

func (p *TypeScriptParser) BindingPattern() (localctx IBindingPatternContext) {
	localctx = NewBindingPatternContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 2, TypeScriptParserRULE_bindingPattern)

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

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

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserOpenBracket:
		{
			p.SetState(283)
			p.ArrayLiteral()
		}

	case TypeScriptParserOpenBrace:
		{
			p.SetState(284)
			p.ObjectLiteral()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyTypeParametersContext() *TypeParametersContext {
	var p = new(TypeParametersContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_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 = TypeScriptParserRULE_typeParameters

	return p
}

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

func (s *TypeParametersContext) LessThan() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserLessThan, 0)
}

func (s *TypeParametersContext) MoreThan() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMoreThan, 0)
}

func (s *TypeParametersContext) TypeParameterList() ITypeParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeParameterListContext)
}

func (s *TypeParametersContext) 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.(TypeScriptParserListener); ok {
		listenerT.EnterTypeParameters(s)
	}
}

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

func (p *TypeScriptParser) TypeParameters() (localctx ITypeParametersContext) {
	localctx = NewTypeParametersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, TypeScriptParserRULE_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(287)
		p.Match(TypeScriptParserLessThan)
	}
	p.SetState(289)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserLessThan || _la == TypeScriptParserIdentifier {
		{
			p.SetState(288)
			p.TypeParameterList()
		}

	}
	{
		p.SetState(291)
		p.Match(TypeScriptParserMoreThan)
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeParameterListContext() *TypeParameterListContext {
	var p = new(TypeParameterListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_typeParameterList
	return p
}

func (*TypeParameterListContext) IsTypeParameterListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_typeParameterList

	return p
}

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

func (s *TypeParameterListContext) AllTypeParameter() []ITypeParameterContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeParameterContext)(nil)).Elem())
	var tst = make([]ITypeParameterContext, len(ts))

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

	return tst
}

func (s *TypeParameterListContext) TypeParameter(i int) ITypeParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeParameterContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeParameterContext)
}

func (s *TypeParameterListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *TypeParameterListContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

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

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

func (s *TypeParameterListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTypeParameterList(s)
	}
}

func (s *TypeParameterListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTypeParameterList(s)
	}
}

func (p *TypeScriptParser) TypeParameterList() (localctx ITypeParameterListContext) {
	localctx = NewTypeParameterListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 6, TypeScriptParserRULE_typeParameterList)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(293)
		p.TypeParameter()
	}
	p.SetState(298)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == TypeScriptParserComma {
		{
			p.SetState(294)
			p.Match(TypeScriptParserComma)
		}
		{
			p.SetState(295)
			p.TypeParameter()
		}

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

	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 = TypeScriptParserRULE_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 = TypeScriptParserRULE_typeParameter

	return p
}

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

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

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

	if t == nil {
		return nil
	}

	return t.(IConstraintContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

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

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

func (p *TypeScriptParser) TypeParameter() (localctx ITypeParameterContext) {
	localctx = NewTypeParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 8, TypeScriptParserRULE_typeParameter)
	var _la int

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

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

	p.SetState(306)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserIdentifier:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(301)
			p.Match(TypeScriptParserIdentifier)
		}
		p.SetState(303)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserExtends {
			{
				p.SetState(302)
				p.Constraint()
			}

		}

	case TypeScriptParserLessThan:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(305)
			p.TypeParameters()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyConstraintContext() *ConstraintContext {
	var p = new(ConstraintContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_constraint
	return p
}

func (*ConstraintContext) IsConstraintContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_constraint

	return p
}

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

func (s *ConstraintContext) Extends() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserExtends, 0)
}

func (s *ConstraintContext) Type_() IType_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

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

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

func (s *ConstraintContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterConstraint(s)
	}
}

func (s *ConstraintContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitConstraint(s)
	}
}

func (p *TypeScriptParser) Constraint() (localctx IConstraintContext) {
	localctx = NewConstraintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 10, TypeScriptParserRULE_constraint)

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

	defer func() {
		if err := recover(); err != nil {
			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(308)
		p.Match(TypeScriptParserExtends)
	}
	{
		p.SetState(309)
		p.Type_()
	}

	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 = TypeScriptParserRULE_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 = TypeScriptParserRULE_typeArguments

	return p
}

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

func (s *TypeArgumentsContext) LessThan() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserLessThan, 0)
}

func (s *TypeArgumentsContext) MoreThan() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMoreThan, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentListContext)
}

func (s *TypeArgumentsContext) 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.(TypeScriptParserListener); ok {
		listenerT.EnterTypeArguments(s)
	}
}

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

func (p *TypeScriptParser) TypeArguments() (localctx ITypeArgumentsContext) {
	localctx = NewTypeArgumentsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 12, TypeScriptParserRULE_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(311)
		p.Match(TypeScriptParserLessThan)
	}
	p.SetState(313)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la-5)&-(0x1f+1)) == 0 && ((1<<uint((_la-5)))&((1<<(TypeScriptParserOpenBracket-5))|(1<<(TypeScriptParserOpenParen-5))|(1<<(TypeScriptParserOpenBrace-5))|(1<<(TypeScriptParserLessThan-5)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(TypeScriptParserTypeof-71))|(1<<(TypeScriptParserNew-71))|(1<<(TypeScriptParserVoid-71))|(1<<(TypeScriptParserThis-71)))) != 0) || (((_la-115)&-(0x1f+1)) == 0 && ((1<<uint((_la-115)))&((1<<(TypeScriptParserANY-115))|(1<<(TypeScriptParserNUMBER-115))|(1<<(TypeScriptParserBOOLEAN-115))|(1<<(TypeScriptParserSTRING-115))|(1<<(TypeScriptParserSYMBOL-115))|(1<<(TypeScriptParserIdentifier-115))|(1<<(TypeScriptParserStringLiteral-115)))) != 0) {
		{
			p.SetState(312)
			p.TypeArgumentList()
		}

	}
	{
		p.SetState(315)
		p.Match(TypeScriptParserMoreThan)
	}

	return localctx
}

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

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

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

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

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

func (*TypeArgumentListContext) IsTypeArgumentListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_typeArgumentList

	return p
}

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

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentContext)
}

func (s *TypeArgumentListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

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

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

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

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

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

func (p *TypeScriptParser) TypeArgumentList() (localctx ITypeArgumentListContext) {
	localctx = NewTypeArgumentListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 14, TypeScriptParserRULE_typeArgumentList)
	var _la int

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

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

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

	for _la == TypeScriptParserComma {
		{
			p.SetState(318)
			p.Match(TypeScriptParserComma)
		}
		{
			p.SetState(319)
			p.TypeArgument()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyTypeArgumentContext() *TypeArgumentContext {
	var p = new(TypeArgumentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_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 = TypeScriptParserRULE_typeArgument

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

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

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

func (p *TypeScriptParser) TypeArgument() (localctx ITypeArgumentContext) {
	localctx = NewTypeArgumentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, TypeScriptParserRULE_typeArgument)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(325)
		p.Type_()
	}

	return localctx
}

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

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

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

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

func NewEmptyType_Context() *Type_Context {
	var p = new(Type_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_type_
	return p
}

func (*Type_Context) IsType_Context() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_type_

	return p
}

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

func (s *Type_Context) UnionOrIntersectionOrPrimaryType() IUnionOrIntersectionOrPrimaryTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnionOrIntersectionOrPrimaryTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnionOrIntersectionOrPrimaryTypeContext)
}

func (s *Type_Context) FunctionType() IFunctionTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionTypeContext)
}

func (s *Type_Context) ConstructorType() IConstructorTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstructorTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstructorTypeContext)
}

func (s *Type_Context) TypeGeneric() ITypeGenericContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeGenericContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeGenericContext)
}

func (s *Type_Context) StringLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserStringLiteral, 0)
}

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

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

func (s *Type_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterType_(s)
	}
}

func (s *Type_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitType_(s)
	}
}

func (p *TypeScriptParser) Type_() (localctx IType_Context) {
	localctx = NewType_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, TypeScriptParserRULE_type_)

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

	defer func() {
		if err := recover(); err != nil {
			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(332)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(327)
			p.unionOrIntersectionOrPrimaryType(0)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(328)
			p.FunctionType()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(329)
			p.ConstructorType()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(330)
			p.TypeGeneric()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(331)
			p.Match(TypeScriptParserStringLiteral)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyUnionOrIntersectionOrPrimaryTypeContext() *UnionOrIntersectionOrPrimaryTypeContext {
	var p = new(UnionOrIntersectionOrPrimaryTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_unionOrIntersectionOrPrimaryType
	return p
}

func (*UnionOrIntersectionOrPrimaryTypeContext) IsUnionOrIntersectionOrPrimaryTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_unionOrIntersectionOrPrimaryType

	return p
}

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

func (s *UnionOrIntersectionOrPrimaryTypeContext) CopyFrom(ctx *UnionOrIntersectionOrPrimaryTypeContext) {
	s.BaseParserRuleContext.CopyFrom(ctx.BaseParserRuleContext)
}

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

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

type IntersectionContext struct {
	*UnionOrIntersectionOrPrimaryTypeContext
}

func NewIntersectionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntersectionContext {
	var p = new(IntersectionContext)

	p.UnionOrIntersectionOrPrimaryTypeContext = NewEmptyUnionOrIntersectionOrPrimaryTypeContext()
	p.parser = parser
	p.CopyFrom(ctx.(*UnionOrIntersectionOrPrimaryTypeContext))

	return p
}

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

func (s *IntersectionContext) AllUnionOrIntersectionOrPrimaryType() []IUnionOrIntersectionOrPrimaryTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IUnionOrIntersectionOrPrimaryTypeContext)(nil)).Elem())
	var tst = make([]IUnionOrIntersectionOrPrimaryTypeContext, len(ts))

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

	return tst
}

func (s *IntersectionContext) UnionOrIntersectionOrPrimaryType(i int) IUnionOrIntersectionOrPrimaryTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnionOrIntersectionOrPrimaryTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IUnionOrIntersectionOrPrimaryTypeContext)
}

func (s *IntersectionContext) BitAnd() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBitAnd, 0)
}

func (s *IntersectionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterIntersection(s)
	}
}

func (s *IntersectionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitIntersection(s)
	}
}

type PrimaryContext struct {
	*UnionOrIntersectionOrPrimaryTypeContext
}

func NewPrimaryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PrimaryContext {
	var p = new(PrimaryContext)

	p.UnionOrIntersectionOrPrimaryTypeContext = NewEmptyUnionOrIntersectionOrPrimaryTypeContext()
	p.parser = parser
	p.CopyFrom(ctx.(*UnionOrIntersectionOrPrimaryTypeContext))

	return p
}

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

func (s *PrimaryContext) PrimaryType() IPrimaryTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryTypeContext)
}

func (s *PrimaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPrimary(s)
	}
}

func (s *PrimaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPrimary(s)
	}
}

type UnionContext struct {
	*UnionOrIntersectionOrPrimaryTypeContext
}

func NewUnionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnionContext {
	var p = new(UnionContext)

	p.UnionOrIntersectionOrPrimaryTypeContext = NewEmptyUnionOrIntersectionOrPrimaryTypeContext()
	p.parser = parser
	p.CopyFrom(ctx.(*UnionOrIntersectionOrPrimaryTypeContext))

	return p
}

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

func (s *UnionContext) AllUnionOrIntersectionOrPrimaryType() []IUnionOrIntersectionOrPrimaryTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IUnionOrIntersectionOrPrimaryTypeContext)(nil)).Elem())
	var tst = make([]IUnionOrIntersectionOrPrimaryTypeContext, len(ts))

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

	return tst
}

func (s *UnionContext) UnionOrIntersectionOrPrimaryType(i int) IUnionOrIntersectionOrPrimaryTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnionOrIntersectionOrPrimaryTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IUnionOrIntersectionOrPrimaryTypeContext)
}

func (s *UnionContext) BitOr() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBitOr, 0)
}

func (s *UnionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterUnion(s)
	}
}

func (s *UnionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitUnion(s)
	}
}

func (p *TypeScriptParser) UnionOrIntersectionOrPrimaryType() (localctx IUnionOrIntersectionOrPrimaryTypeContext) {
	return p.unionOrIntersectionOrPrimaryType(0)
}

func (p *TypeScriptParser) unionOrIntersectionOrPrimaryType(_p int) (localctx IUnionOrIntersectionOrPrimaryTypeContext) {
	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewUnionOrIntersectionOrPrimaryTypeContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IUnionOrIntersectionOrPrimaryTypeContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 20
	p.EnterRecursionRule(localctx, 20, TypeScriptParserRULE_unionOrIntersectionOrPrimaryType, _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)
	localctx = NewPrimaryContext(p, localctx)
	p.SetParserRuleContext(localctx)
	_prevctx = localctx

	{
		p.SetState(335)
		p.primaryType(0)
	}

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

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(343)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 8, p.GetParserRuleContext()) {
			case 1:
				localctx = NewUnionContext(p, NewUnionOrIntersectionOrPrimaryTypeContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_unionOrIntersectionOrPrimaryType)
				p.SetState(337)

				if !(p.Precpred(p.GetParserRuleContext(), 3)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
				}
				{
					p.SetState(338)
					p.Match(TypeScriptParserBitOr)
				}
				{
					p.SetState(339)
					p.unionOrIntersectionOrPrimaryType(4)
				}

			case 2:
				localctx = NewIntersectionContext(p, NewUnionOrIntersectionOrPrimaryTypeContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_unionOrIntersectionOrPrimaryType)
				p.SetState(340)

				if !(p.Precpred(p.GetParserRuleContext(), 2)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
				}
				{
					p.SetState(341)
					p.Match(TypeScriptParserBitAnd)
				}
				{
					p.SetState(342)
					p.unionOrIntersectionOrPrimaryType(3)
				}

			}

		}
		p.SetState(347)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 9, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyPrimaryTypeContext() *PrimaryTypeContext {
	var p = new(PrimaryTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_primaryType
	return p
}

func (*PrimaryTypeContext) IsPrimaryTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_primaryType

	return p
}

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

func (s *PrimaryTypeContext) CopyFrom(ctx *PrimaryTypeContext) {
	s.BaseParserRuleContext.CopyFrom(ctx.BaseParserRuleContext)
}

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

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

type RedefinitionOfTypeContext struct {
	*PrimaryTypeContext
}

func NewRedefinitionOfTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RedefinitionOfTypeContext {
	var p = new(RedefinitionOfTypeContext)

	p.PrimaryTypeContext = NewEmptyPrimaryTypeContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PrimaryTypeContext))

	return p
}

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

func (s *RedefinitionOfTypeContext) TypeReference() ITypeReferenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeReferenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeReferenceContext)
}

func (s *RedefinitionOfTypeContext) Is() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIs, 0)
}

func (s *RedefinitionOfTypeContext) PrimaryType() IPrimaryTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryTypeContext)
}

func (s *RedefinitionOfTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterRedefinitionOfType(s)
	}
}

func (s *RedefinitionOfTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitRedefinitionOfType(s)
	}
}

type PredefinedPrimTypeContext struct {
	*PrimaryTypeContext
}

func NewPredefinedPrimTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PredefinedPrimTypeContext {
	var p = new(PredefinedPrimTypeContext)

	p.PrimaryTypeContext = NewEmptyPrimaryTypeContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PrimaryTypeContext))

	return p
}

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

func (s *PredefinedPrimTypeContext) PredefinedType() IPredefinedTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPredefinedTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPredefinedTypeContext)
}

func (s *PredefinedPrimTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPredefinedPrimType(s)
	}
}

func (s *PredefinedPrimTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPredefinedPrimType(s)
	}
}

type ArrayPrimTypeContext struct {
	*PrimaryTypeContext
}

func NewArrayPrimTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrayPrimTypeContext {
	var p = new(ArrayPrimTypeContext)

	p.PrimaryTypeContext = NewEmptyPrimaryTypeContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PrimaryTypeContext))

	return p
}

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

func (s *ArrayPrimTypeContext) PrimaryType() IPrimaryTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryTypeContext)
}

func (s *ArrayPrimTypeContext) OpenBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBracket, 0)
}

func (s *ArrayPrimTypeContext) CloseBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBracket, 0)
}

func (s *ArrayPrimTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterArrayPrimType(s)
	}
}

func (s *ArrayPrimTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitArrayPrimType(s)
	}
}

type ParenthesizedPrimTypeContext struct {
	*PrimaryTypeContext
}

func NewParenthesizedPrimTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParenthesizedPrimTypeContext {
	var p = new(ParenthesizedPrimTypeContext)

	p.PrimaryTypeContext = NewEmptyPrimaryTypeContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PrimaryTypeContext))

	return p
}

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

func (s *ParenthesizedPrimTypeContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *ParenthesizedPrimTypeContext) Type_() IType_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

func (s *ParenthesizedPrimTypeContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *ParenthesizedPrimTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterParenthesizedPrimType(s)
	}
}

func (s *ParenthesizedPrimTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitParenthesizedPrimType(s)
	}
}

type ThisPrimTypeContext struct {
	*PrimaryTypeContext
}

func NewThisPrimTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ThisPrimTypeContext {
	var p = new(ThisPrimTypeContext)

	p.PrimaryTypeContext = NewEmptyPrimaryTypeContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PrimaryTypeContext))

	return p
}

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

func (s *ThisPrimTypeContext) This() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserThis, 0)
}

func (s *ThisPrimTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterThisPrimType(s)
	}
}

func (s *ThisPrimTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitThisPrimType(s)
	}
}

type TuplePrimTypeContext struct {
	*PrimaryTypeContext
}

func NewTuplePrimTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TuplePrimTypeContext {
	var p = new(TuplePrimTypeContext)

	p.PrimaryTypeContext = NewEmptyPrimaryTypeContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PrimaryTypeContext))

	return p
}

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

func (s *TuplePrimTypeContext) OpenBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBracket, 0)
}

func (s *TuplePrimTypeContext) TupleElementTypes() ITupleElementTypesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITupleElementTypesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITupleElementTypesContext)
}

func (s *TuplePrimTypeContext) CloseBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBracket, 0)
}

func (s *TuplePrimTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTuplePrimType(s)
	}
}

func (s *TuplePrimTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTuplePrimType(s)
	}
}

type ObjectPrimTypeContext struct {
	*PrimaryTypeContext
}

func NewObjectPrimTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ObjectPrimTypeContext {
	var p = new(ObjectPrimTypeContext)

	p.PrimaryTypeContext = NewEmptyPrimaryTypeContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PrimaryTypeContext))

	return p
}

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

func (s *ObjectPrimTypeContext) ObjectType() IObjectTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IObjectTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IObjectTypeContext)
}

func (s *ObjectPrimTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterObjectPrimType(s)
	}
}

func (s *ObjectPrimTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitObjectPrimType(s)
	}
}

type ReferencePrimTypeContext struct {
	*PrimaryTypeContext
}

func NewReferencePrimTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReferencePrimTypeContext {
	var p = new(ReferencePrimTypeContext)

	p.PrimaryTypeContext = NewEmptyPrimaryTypeContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PrimaryTypeContext))

	return p
}

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

func (s *ReferencePrimTypeContext) TypeReference() ITypeReferenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeReferenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeReferenceContext)
}

func (s *ReferencePrimTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterReferencePrimType(s)
	}
}

func (s *ReferencePrimTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitReferencePrimType(s)
	}
}

type QueryPrimTypeContext struct {
	*PrimaryTypeContext
}

func NewQueryPrimTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *QueryPrimTypeContext {
	var p = new(QueryPrimTypeContext)

	p.PrimaryTypeContext = NewEmptyPrimaryTypeContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PrimaryTypeContext))

	return p
}

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

func (s *QueryPrimTypeContext) TypeQuery() ITypeQueryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeQueryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeQueryContext)
}

func (s *QueryPrimTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterQueryPrimType(s)
	}
}

func (s *QueryPrimTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitQueryPrimType(s)
	}
}

func (p *TypeScriptParser) PrimaryType() (localctx IPrimaryTypeContext) {
	return p.primaryType(0)
}

func (p *TypeScriptParser) primaryType(_p int) (localctx IPrimaryTypeContext) {
	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewPrimaryTypeContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IPrimaryTypeContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 22
	p.EnterRecursionRule(localctx, 22, TypeScriptParserRULE_primaryType, _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(366)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 10, p.GetParserRuleContext()) {
	case 1:
		localctx = NewParenthesizedPrimTypeContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx

		{
			p.SetState(349)
			p.Match(TypeScriptParserOpenParen)
		}
		{
			p.SetState(350)
			p.Type_()
		}
		{
			p.SetState(351)
			p.Match(TypeScriptParserCloseParen)
		}

	case 2:
		localctx = NewPredefinedPrimTypeContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(353)
			p.PredefinedType()
		}

	case 3:
		localctx = NewReferencePrimTypeContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(354)
			p.TypeReference()
		}

	case 4:
		localctx = NewObjectPrimTypeContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(355)
			p.ObjectType()
		}

	case 5:
		localctx = NewTuplePrimTypeContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(356)
			p.Match(TypeScriptParserOpenBracket)
		}
		{
			p.SetState(357)
			p.TupleElementTypes()
		}
		{
			p.SetState(358)
			p.Match(TypeScriptParserCloseBracket)
		}

	case 6:
		localctx = NewQueryPrimTypeContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(360)
			p.TypeQuery()
		}

	case 7:
		localctx = NewThisPrimTypeContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(361)
			p.Match(TypeScriptParserThis)
		}

	case 8:
		localctx = NewRedefinitionOfTypeContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(362)
			p.TypeReference()
		}
		{
			p.SetState(363)
			p.Match(TypeScriptParserIs)
		}
		{
			p.SetState(364)
			p.primaryType(1)
		}

	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(374)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 11, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			localctx = NewArrayPrimTypeContext(p, NewPrimaryTypeContext(p, _parentctx, _parentState))
			p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_primaryType)
			p.SetState(368)

			if !(p.Precpred(p.GetParserRuleContext(), 5)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
			}
			p.SetState(369)

			if !(p.notLineTerminator()) {
				panic(antlr.NewFailedPredicateException(p, "p.notLineTerminator()", ""))
			}
			{
				p.SetState(370)
				p.Match(TypeScriptParserOpenBracket)
			}
			{
				p.SetState(371)
				p.Match(TypeScriptParserCloseBracket)
			}

		}
		p.SetState(376)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 11, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyPredefinedTypeContext() *PredefinedTypeContext {
	var p = new(PredefinedTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_predefinedType
	return p
}

func (*PredefinedTypeContext) IsPredefinedTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_predefinedType

	return p
}

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

func (s *PredefinedTypeContext) ANY() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserANY, 0)
}

func (s *PredefinedTypeContext) NUMBER() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserNUMBER, 0)
}

func (s *PredefinedTypeContext) BOOLEAN() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBOOLEAN, 0)
}

func (s *PredefinedTypeContext) STRING() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSTRING, 0)
}

func (s *PredefinedTypeContext) SYMBOL() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSYMBOL, 0)
}

func (s *PredefinedTypeContext) Void() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserVoid, 0)
}

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

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

func (s *PredefinedTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPredefinedType(s)
	}
}

func (s *PredefinedTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPredefinedType(s)
	}
}

func (p *TypeScriptParser) PredefinedType() (localctx IPredefinedTypeContext) {
	localctx = NewPredefinedTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, TypeScriptParserRULE_predefinedType)
	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(377)
		_la = p.GetTokenStream().LA(1)

		if !(_la == TypeScriptParserVoid || (((_la-115)&-(0x1f+1)) == 0 && ((1<<uint((_la-115)))&((1<<(TypeScriptParserANY-115))|(1<<(TypeScriptParserNUMBER-115))|(1<<(TypeScriptParserBOOLEAN-115))|(1<<(TypeScriptParserSTRING-115))|(1<<(TypeScriptParserSYMBOL-115)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeReferenceContext() *TypeReferenceContext {
	var p = new(TypeReferenceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_typeReference
	return p
}

func (*TypeReferenceContext) IsTypeReferenceContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_typeReference

	return p
}

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

func (s *TypeReferenceContext) TypeName() ITypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *TypeReferenceContext) TypeIncludeGeneric() ITypeIncludeGenericContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeIncludeGenericContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeIncludeGenericContext)
}

func (s *TypeReferenceContext) TypeGeneric() ITypeGenericContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeGenericContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeGenericContext)
}

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

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

func (s *TypeReferenceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTypeReference(s)
	}
}

func (s *TypeReferenceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTypeReference(s)
	}
}

func (p *TypeScriptParser) TypeReference() (localctx ITypeReferenceContext) {
	localctx = NewTypeReferenceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 26, TypeScriptParserRULE_typeReference)

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

	defer func() {
		if err := recover(); err != nil {
			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(379)
		p.TypeName()
	}
	p.SetState(382)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 12, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(380)
			p.TypeIncludeGeneric()
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 12, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(381)
			p.TypeGeneric()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyTypeGenericContext() *TypeGenericContext {
	var p = new(TypeGenericContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_typeGeneric
	return p
}

func (*TypeGenericContext) IsTypeGenericContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_typeGeneric

	return p
}

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

func (s *TypeGenericContext) LessThan() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserLessThan, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentListContext)
}

func (s *TypeGenericContext) MoreThan() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMoreThan, 0)
}

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

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

func (s *TypeGenericContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTypeGeneric(s)
	}
}

func (s *TypeGenericContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTypeGeneric(s)
	}
}

func (p *TypeScriptParser) TypeGeneric() (localctx ITypeGenericContext) {
	localctx = NewTypeGenericContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, TypeScriptParserRULE_typeGeneric)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(384)
		p.Match(TypeScriptParserLessThan)
	}
	{
		p.SetState(385)
		p.TypeArgumentList()
	}
	{
		p.SetState(386)
		p.Match(TypeScriptParserMoreThan)
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeIncludeGenericContext() *TypeIncludeGenericContext {
	var p = new(TypeIncludeGenericContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_typeIncludeGeneric
	return p
}

func (*TypeIncludeGenericContext) IsTypeIncludeGenericContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_typeIncludeGeneric

	return p
}

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

func (s *TypeIncludeGenericContext) AllLessThan() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserLessThan)
}

func (s *TypeIncludeGenericContext) LessThan(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserLessThan, i)
}

func (s *TypeIncludeGenericContext) AllTypeArgumentList() []ITypeArgumentListContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeArgumentListContext)(nil)).Elem())
	var tst = make([]ITypeArgumentListContext, len(ts))

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

	return tst
}

func (s *TypeIncludeGenericContext) TypeArgumentList(i int) ITypeArgumentListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentListContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentListContext)
}

func (s *TypeIncludeGenericContext) AllMoreThan() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserMoreThan)
}

func (s *TypeIncludeGenericContext) MoreThan(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMoreThan, i)
}

func (s *TypeIncludeGenericContext) BindingPattern() IBindingPatternContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBindingPatternContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBindingPatternContext)
}

func (s *TypeIncludeGenericContext) RightShiftArithmetic() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserRightShiftArithmetic, 0)
}

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

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

func (s *TypeIncludeGenericContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTypeIncludeGeneric(s)
	}
}

func (s *TypeIncludeGenericContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTypeIncludeGeneric(s)
	}
}

func (p *TypeScriptParser) TypeIncludeGeneric() (localctx ITypeIncludeGenericContext) {
	localctx = NewTypeIncludeGenericContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, TypeScriptParserRULE_typeIncludeGeneric)

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

	defer func() {
		if err := recover(); err != nil {
			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(388)
		p.Match(TypeScriptParserLessThan)
	}
	{
		p.SetState(389)
		p.TypeArgumentList()
	}
	{
		p.SetState(390)
		p.Match(TypeScriptParserLessThan)
	}
	{
		p.SetState(391)
		p.TypeArgumentList()
	}
	p.SetState(397)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserMoreThan:
		{
			p.SetState(392)
			p.Match(TypeScriptParserMoreThan)
		}
		{
			p.SetState(393)
			p.BindingPattern()
		}
		{
			p.SetState(394)
			p.Match(TypeScriptParserMoreThan)
		}

	case TypeScriptParserRightShiftArithmetic:
		{
			p.SetState(396)
			p.Match(TypeScriptParserRightShiftArithmetic)
		}

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

	return localctx
}

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

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

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

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

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

func (*TypeNameContext) IsTypeNameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_typeName

	return p
}

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

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

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

	if t == nil {
		return nil
	}

	return t.(INamespaceNameContext)
}

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

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

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

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

func (p *TypeScriptParser) TypeName() (localctx ITypeNameContext) {
	localctx = NewTypeNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, TypeScriptParserRULE_typeName)

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

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

	p.SetState(401)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 14, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(399)
			p.Match(TypeScriptParserIdentifier)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(400)
			p.NamespaceName()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyObjectTypeContext() *ObjectTypeContext {
	var p = new(ObjectTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_objectType
	return p
}

func (*ObjectTypeContext) IsObjectTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_objectType

	return p
}

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

func (s *ObjectTypeContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *ObjectTypeContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *ObjectTypeContext) TypeBody() ITypeBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeBodyContext)
}

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

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

func (s *ObjectTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterObjectType(s)
	}
}

func (s *ObjectTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitObjectType(s)
	}
}

func (p *TypeScriptParser) ObjectType() (localctx IObjectTypeContext) {
	localctx = NewObjectTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 34, TypeScriptParserRULE_objectType)
	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(403)
		p.Match(TypeScriptParserOpenBrace)
	}
	p.SetState(405)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la-5)&-(0x1f+1)) == 0 && ((1<<uint((_la-5)))&((1<<(TypeScriptParserOpenBracket-5))|(1<<(TypeScriptParserOpenParen-5))|(1<<(TypeScriptParserLessThan-5)))) != 0) || (((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(TypeScriptParserNullLiteral-61))|(1<<(TypeScriptParserBooleanLiteral-61))|(1<<(TypeScriptParserDecimalLiteral-61))|(1<<(TypeScriptParserHexIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral2-61))|(1<<(TypeScriptParserBinaryIntegerLiteral-61))|(1<<(TypeScriptParserBreak-61))|(1<<(TypeScriptParserDo-61))|(1<<(TypeScriptParserInstanceof-61))|(1<<(TypeScriptParserTypeof-61))|(1<<(TypeScriptParserCase-61))|(1<<(TypeScriptParserElse-61))|(1<<(TypeScriptParserNew-61))|(1<<(TypeScriptParserVar-61))|(1<<(TypeScriptParserCatch-61))|(1<<(TypeScriptParserFinally-61))|(1<<(TypeScriptParserReturn-61))|(1<<(TypeScriptParserVoid-61))|(1<<(TypeScriptParserContinue-61))|(1<<(TypeScriptParserFor-61))|(1<<(TypeScriptParserSwitch-61))|(1<<(TypeScriptParserWhile-61))|(1<<(TypeScriptParserDebugger-61))|(1<<(TypeScriptParserFunction-61))|(1<<(TypeScriptParserThis-61))|(1<<(TypeScriptParserWith-61))|(1<<(TypeScriptParserDefault-61))|(1<<(TypeScriptParserIf-61))|(1<<(TypeScriptParserThrow-61))|(1<<(TypeScriptParserDelete-61))|(1<<(TypeScriptParserIn-61)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(TypeScriptParserTry-93))|(1<<(TypeScriptParserAs-93))|(1<<(TypeScriptParserFrom-93))|(1<<(TypeScriptParserReadOnly-93))|(1<<(TypeScriptParserAsync-93))|(1<<(TypeScriptParserClass-93))|(1<<(TypeScriptParserEnum-93))|(1<<(TypeScriptParserExtends-93))|(1<<(TypeScriptParserSuper-93))|(1<<(TypeScriptParserConst-93))|(1<<(TypeScriptParserExport-93))|(1<<(TypeScriptParserImport-93))|(1<<(TypeScriptParserAwait-93))|(1<<(TypeScriptParserImplements-93))|(1<<(TypeScriptParserLet-93))|(1<<(TypeScriptParserPrivate-93))|(1<<(TypeScriptParserPublic-93))|(1<<(TypeScriptParserInterface-93))|(1<<(TypeScriptParserPackage-93))|(1<<(TypeScriptParserProtected-93))|(1<<(TypeScriptParserStatic-93))|(1<<(TypeScriptParserYield-93)))) != 0) || _la == TypeScriptParserIdentifier || _la == TypeScriptParserStringLiteral {
		{
			p.SetState(404)
			p.TypeBody()
		}

	}
	{
		p.SetState(407)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeBodyContext() *TypeBodyContext {
	var p = new(TypeBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_typeBody
	return p
}

func (*TypeBodyContext) IsTypeBodyContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_typeBody

	return p
}

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

func (s *TypeBodyContext) TypeMemberList() ITypeMemberListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeMemberListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeMemberListContext)
}

func (s *TypeBodyContext) SemiColon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, 0)
}

func (s *TypeBodyContext) Comma() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, 0)
}

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

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

func (s *TypeBodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTypeBody(s)
	}
}

func (s *TypeBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTypeBody(s)
	}
}

func (p *TypeScriptParser) TypeBody() (localctx ITypeBodyContext) {
	localctx = NewTypeBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, TypeScriptParserRULE_typeBody)
	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(409)
		p.TypeMemberList()
	}
	p.SetState(411)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserSemiColon || _la == TypeScriptParserComma {
		{
			p.SetState(410)
			_la = p.GetTokenStream().LA(1)

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

	}

	return localctx
}

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

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

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

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

func NewEmptyTypeMemberListContext() *TypeMemberListContext {
	var p = new(TypeMemberListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_typeMemberList
	return p
}

func (*TypeMemberListContext) IsTypeMemberListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_typeMemberList

	return p
}

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

func (s *TypeMemberListContext) AllTypeMember() []ITypeMemberContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeMemberContext)(nil)).Elem())
	var tst = make([]ITypeMemberContext, len(ts))

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

	return tst
}

func (s *TypeMemberListContext) TypeMember(i int) ITypeMemberContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeMemberContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeMemberContext)
}

func (s *TypeMemberListContext) AllSemiColon() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserSemiColon)
}

func (s *TypeMemberListContext) SemiColon(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, i)
}

func (s *TypeMemberListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *TypeMemberListContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

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

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

func (s *TypeMemberListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTypeMemberList(s)
	}
}

func (s *TypeMemberListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTypeMemberList(s)
	}
}

func (p *TypeScriptParser) TypeMemberList() (localctx ITypeMemberListContext) {
	localctx = NewTypeMemberListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, TypeScriptParserRULE_typeMemberList)
	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(413)
		p.TypeMember()
	}
	p.SetState(418)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 17, p.GetParserRuleContext())

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

				if !(_la == TypeScriptParserSemiColon || _la == TypeScriptParserComma) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(415)
				p.TypeMember()
			}

		}
		p.SetState(420)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 17, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeMemberContext() *TypeMemberContext {
	var p = new(TypeMemberContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_typeMember
	return p
}

func (*TypeMemberContext) IsTypeMemberContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_typeMember

	return p
}

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

func (s *TypeMemberContext) PropertySignature() IPropertySignatureContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertySignatureContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPropertySignatureContext)
}

func (s *TypeMemberContext) CallSignature() ICallSignatureContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICallSignatureContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICallSignatureContext)
}

func (s *TypeMemberContext) ConstructSignature() IConstructSignatureContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstructSignatureContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstructSignatureContext)
}

func (s *TypeMemberContext) IndexSignature() IIndexSignatureContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexSignatureContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndexSignatureContext)
}

func (s *TypeMemberContext) MethodSignature() IMethodSignatureContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMethodSignatureContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMethodSignatureContext)
}

func (s *TypeMemberContext) ARROW() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserARROW, 0)
}

func (s *TypeMemberContext) Type_() IType_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

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

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

func (s *TypeMemberContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTypeMember(s)
	}
}

func (s *TypeMemberContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTypeMember(s)
	}
}

func (p *TypeScriptParser) TypeMember() (localctx ITypeMemberContext) {
	localctx = NewTypeMemberContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, TypeScriptParserRULE_typeMember)
	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(430)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 19, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(421)
			p.PropertySignature()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(422)
			p.CallSignature()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(423)
			p.ConstructSignature()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(424)
			p.IndexSignature()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(425)
			p.MethodSignature()
		}
		p.SetState(428)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserARROW {
			{
				p.SetState(426)
				p.Match(TypeScriptParserARROW)
			}
			{
				p.SetState(427)
				p.Type_()
			}

		}

	}

	return localctx
}

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

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

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

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

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

func (*ArrayTypeContext) IsArrayTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_arrayType

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IPrimaryTypeContext)
}

func (s *ArrayTypeContext) OpenBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBracket, 0)
}

func (s *ArrayTypeContext) CloseBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBracket, 0)
}

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

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

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

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

func (p *TypeScriptParser) ArrayType() (localctx IArrayTypeContext) {
	localctx = NewArrayTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, TypeScriptParserRULE_arrayType)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(432)
		p.primaryType(0)
	}
	p.SetState(433)

	if !(p.notLineTerminator()) {
		panic(antlr.NewFailedPredicateException(p, "p.notLineTerminator()", ""))
	}
	{
		p.SetState(434)
		p.Match(TypeScriptParserOpenBracket)
	}
	{
		p.SetState(435)
		p.Match(TypeScriptParserCloseBracket)
	}

	return localctx
}

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

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

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

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

func NewEmptyTupleTypeContext() *TupleTypeContext {
	var p = new(TupleTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_tupleType
	return p
}

func (*TupleTypeContext) IsTupleTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_tupleType

	return p
}

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

func (s *TupleTypeContext) OpenBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBracket, 0)
}

func (s *TupleTypeContext) TupleElementTypes() ITupleElementTypesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITupleElementTypesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITupleElementTypesContext)
}

func (s *TupleTypeContext) CloseBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBracket, 0)
}

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

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

func (s *TupleTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTupleType(s)
	}
}

func (s *TupleTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTupleType(s)
	}
}

func (p *TypeScriptParser) TupleType() (localctx ITupleTypeContext) {
	localctx = NewTupleTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, TypeScriptParserRULE_tupleType)

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

	defer func() {
		if err := recover(); err != nil {
			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(437)
		p.Match(TypeScriptParserOpenBracket)
	}
	{
		p.SetState(438)
		p.TupleElementTypes()
	}
	{
		p.SetState(439)
		p.Match(TypeScriptParserCloseBracket)
	}

	return localctx
}

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

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

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

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

func NewEmptyTupleElementTypesContext() *TupleElementTypesContext {
	var p = new(TupleElementTypesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_tupleElementTypes
	return p
}

func (*TupleElementTypesContext) IsTupleElementTypesContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_tupleElementTypes

	return p
}

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

func (s *TupleElementTypesContext) AllType_() []IType_Context {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IType_Context)(nil)).Elem())
	var tst = make([]IType_Context, len(ts))

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

	return tst
}

func (s *TupleElementTypesContext) Type_(i int) IType_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_Context)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

func (s *TupleElementTypesContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *TupleElementTypesContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

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

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

func (s *TupleElementTypesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTupleElementTypes(s)
	}
}

func (s *TupleElementTypesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTupleElementTypes(s)
	}
}

func (p *TypeScriptParser) TupleElementTypes() (localctx ITupleElementTypesContext) {
	localctx = NewTupleElementTypesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, TypeScriptParserRULE_tupleElementTypes)
	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(441)
		p.Type_()
	}
	p.SetState(446)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == TypeScriptParserComma {
		{
			p.SetState(442)
			p.Match(TypeScriptParserComma)
		}
		{
			p.SetState(443)
			p.Type_()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyFunctionTypeContext() *FunctionTypeContext {
	var p = new(FunctionTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_functionType
	return p
}

func (*FunctionTypeContext) IsFunctionTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_functionType

	return p
}

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

func (s *FunctionTypeContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *FunctionTypeContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *FunctionTypeContext) ARROW() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserARROW, 0)
}

func (s *FunctionTypeContext) Type_() IType_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

func (s *FunctionTypeContext) ParameterList() IParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParameterListContext)
}

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

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

func (s *FunctionTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterFunctionType(s)
	}
}

func (s *FunctionTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitFunctionType(s)
	}
}

func (p *TypeScriptParser) FunctionType() (localctx IFunctionTypeContext) {
	localctx = NewFunctionTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, TypeScriptParserRULE_functionType)
	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(450)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserLessThan {
		{
			p.SetState(449)
			p.TypeParameters()
		}

	}
	{
		p.SetState(452)
		p.Match(TypeScriptParserOpenParen)
	}
	p.SetState(454)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<TypeScriptParserOpenBracket)|(1<<TypeScriptParserOpenBrace)|(1<<TypeScriptParserEllipsis))) != 0) || (((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(TypeScriptParserNullLiteral-61))|(1<<(TypeScriptParserBooleanLiteral-61))|(1<<(TypeScriptParserBreak-61))|(1<<(TypeScriptParserDo-61))|(1<<(TypeScriptParserInstanceof-61))|(1<<(TypeScriptParserTypeof-61))|(1<<(TypeScriptParserCase-61))|(1<<(TypeScriptParserElse-61))|(1<<(TypeScriptParserNew-61))|(1<<(TypeScriptParserVar-61))|(1<<(TypeScriptParserCatch-61))|(1<<(TypeScriptParserFinally-61))|(1<<(TypeScriptParserReturn-61))|(1<<(TypeScriptParserVoid-61))|(1<<(TypeScriptParserContinue-61))|(1<<(TypeScriptParserFor-61))|(1<<(TypeScriptParserSwitch-61))|(1<<(TypeScriptParserWhile-61))|(1<<(TypeScriptParserDebugger-61))|(1<<(TypeScriptParserFunction-61))|(1<<(TypeScriptParserThis-61))|(1<<(TypeScriptParserWith-61))|(1<<(TypeScriptParserDefault-61))|(1<<(TypeScriptParserIf-61))|(1<<(TypeScriptParserThrow-61))|(1<<(TypeScriptParserDelete-61))|(1<<(TypeScriptParserIn-61)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(TypeScriptParserTry-93))|(1<<(TypeScriptParserAs-93))|(1<<(TypeScriptParserFrom-93))|(1<<(TypeScriptParserReadOnly-93))|(1<<(TypeScriptParserAsync-93))|(1<<(TypeScriptParserClass-93))|(1<<(TypeScriptParserEnum-93))|(1<<(TypeScriptParserExtends-93))|(1<<(TypeScriptParserSuper-93))|(1<<(TypeScriptParserConst-93))|(1<<(TypeScriptParserExport-93))|(1<<(TypeScriptParserImport-93))|(1<<(TypeScriptParserAwait-93))|(1<<(TypeScriptParserImplements-93))|(1<<(TypeScriptParserLet-93))|(1<<(TypeScriptParserPrivate-93))|(1<<(TypeScriptParserPublic-93))|(1<<(TypeScriptParserInterface-93))|(1<<(TypeScriptParserPackage-93))|(1<<(TypeScriptParserProtected-93))|(1<<(TypeScriptParserStatic-93))|(1<<(TypeScriptParserYield-93))|(1<<(TypeScriptParserANY-93))|(1<<(TypeScriptParserNUMBER-93))|(1<<(TypeScriptParserBOOLEAN-93))|(1<<(TypeScriptParserSTRING-93))|(1<<(TypeScriptParserSYMBOL-93)))) != 0) || _la == TypeScriptParserAt || _la == TypeScriptParserIdentifier {
		{
			p.SetState(453)
			p.ParameterList()
		}

	}
	{
		p.SetState(456)
		p.Match(TypeScriptParserCloseParen)
	}
	{
		p.SetState(457)
		p.Match(TypeScriptParserARROW)
	}
	{
		p.SetState(458)
		p.Type_()
	}

	return localctx
}

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

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

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

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

func NewEmptyConstructorTypeContext() *ConstructorTypeContext {
	var p = new(ConstructorTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_constructorType
	return p
}

func (*ConstructorTypeContext) IsConstructorTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_constructorType

	return p
}

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

func (s *ConstructorTypeContext) New() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserNew, 0)
}

func (s *ConstructorTypeContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *ConstructorTypeContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *ConstructorTypeContext) ARROW() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserARROW, 0)
}

func (s *ConstructorTypeContext) Type_() IType_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

func (s *ConstructorTypeContext) ParameterList() IParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParameterListContext)
}

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

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

func (s *ConstructorTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterConstructorType(s)
	}
}

func (s *ConstructorTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitConstructorType(s)
	}
}

func (p *TypeScriptParser) ConstructorType() (localctx IConstructorTypeContext) {
	localctx = NewConstructorTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 50, TypeScriptParserRULE_constructorType)
	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(460)
		p.Match(TypeScriptParserNew)
	}
	p.SetState(462)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserLessThan {
		{
			p.SetState(461)
			p.TypeParameters()
		}

	}
	{
		p.SetState(464)
		p.Match(TypeScriptParserOpenParen)
	}
	p.SetState(466)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<TypeScriptParserOpenBracket)|(1<<TypeScriptParserOpenBrace)|(1<<TypeScriptParserEllipsis))) != 0) || (((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(TypeScriptParserNullLiteral-61))|(1<<(TypeScriptParserBooleanLiteral-61))|(1<<(TypeScriptParserBreak-61))|(1<<(TypeScriptParserDo-61))|(1<<(TypeScriptParserInstanceof-61))|(1<<(TypeScriptParserTypeof-61))|(1<<(TypeScriptParserCase-61))|(1<<(TypeScriptParserElse-61))|(1<<(TypeScriptParserNew-61))|(1<<(TypeScriptParserVar-61))|(1<<(TypeScriptParserCatch-61))|(1<<(TypeScriptParserFinally-61))|(1<<(TypeScriptParserReturn-61))|(1<<(TypeScriptParserVoid-61))|(1<<(TypeScriptParserContinue-61))|(1<<(TypeScriptParserFor-61))|(1<<(TypeScriptParserSwitch-61))|(1<<(TypeScriptParserWhile-61))|(1<<(TypeScriptParserDebugger-61))|(1<<(TypeScriptParserFunction-61))|(1<<(TypeScriptParserThis-61))|(1<<(TypeScriptParserWith-61))|(1<<(TypeScriptParserDefault-61))|(1<<(TypeScriptParserIf-61))|(1<<(TypeScriptParserThrow-61))|(1<<(TypeScriptParserDelete-61))|(1<<(TypeScriptParserIn-61)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(TypeScriptParserTry-93))|(1<<(TypeScriptParserAs-93))|(1<<(TypeScriptParserFrom-93))|(1<<(TypeScriptParserReadOnly-93))|(1<<(TypeScriptParserAsync-93))|(1<<(TypeScriptParserClass-93))|(1<<(TypeScriptParserEnum-93))|(1<<(TypeScriptParserExtends-93))|(1<<(TypeScriptParserSuper-93))|(1<<(TypeScriptParserConst-93))|(1<<(TypeScriptParserExport-93))|(1<<(TypeScriptParserImport-93))|(1<<(TypeScriptParserAwait-93))|(1<<(TypeScriptParserImplements-93))|(1<<(TypeScriptParserLet-93))|(1<<(TypeScriptParserPrivate-93))|(1<<(TypeScriptParserPublic-93))|(1<<(TypeScriptParserInterface-93))|(1<<(TypeScriptParserPackage-93))|(1<<(TypeScriptParserProtected-93))|(1<<(TypeScriptParserStatic-93))|(1<<(TypeScriptParserYield-93))|(1<<(TypeScriptParserANY-93))|(1<<(TypeScriptParserNUMBER-93))|(1<<(TypeScriptParserBOOLEAN-93))|(1<<(TypeScriptParserSTRING-93))|(1<<(TypeScriptParserSYMBOL-93)))) != 0) || _la == TypeScriptParserAt || _la == TypeScriptParserIdentifier {
		{
			p.SetState(465)
			p.ParameterList()
		}

	}
	{
		p.SetState(468)
		p.Match(TypeScriptParserCloseParen)
	}
	{
		p.SetState(469)
		p.Match(TypeScriptParserARROW)
	}
	{
		p.SetState(470)
		p.Type_()
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeQueryContext() *TypeQueryContext {
	var p = new(TypeQueryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_typeQuery
	return p
}

func (*TypeQueryContext) IsTypeQueryContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_typeQuery

	return p
}

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

func (s *TypeQueryContext) Typeof() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserTypeof, 0)
}

func (s *TypeQueryContext) TypeQueryExpression() ITypeQueryExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeQueryExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeQueryExpressionContext)
}

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

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

func (s *TypeQueryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTypeQuery(s)
	}
}

func (s *TypeQueryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTypeQuery(s)
	}
}

func (p *TypeScriptParser) TypeQuery() (localctx ITypeQueryContext) {
	localctx = NewTypeQueryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, TypeScriptParserRULE_typeQuery)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(472)
		p.Match(TypeScriptParserTypeof)
	}
	{
		p.SetState(473)
		p.TypeQueryExpression()
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeQueryExpressionContext() *TypeQueryExpressionContext {
	var p = new(TypeQueryExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_typeQueryExpression
	return p
}

func (*TypeQueryExpressionContext) IsTypeQueryExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_typeQueryExpression

	return p
}

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

func (s *TypeQueryExpressionContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *TypeQueryExpressionContext) AllIdentifierName() []IIdentifierNameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIdentifierNameContext)(nil)).Elem())
	var tst = make([]IIdentifierNameContext, len(ts))

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

	return tst
}

func (s *TypeQueryExpressionContext) IdentifierName(i int) IIdentifierNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierNameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIdentifierNameContext)
}

func (s *TypeQueryExpressionContext) AllDot() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserDot)
}

func (s *TypeQueryExpressionContext) Dot(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDot, i)
}

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

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

func (s *TypeQueryExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTypeQueryExpression(s)
	}
}

func (s *TypeQueryExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTypeQueryExpression(s)
	}
}

func (p *TypeScriptParser) TypeQueryExpression() (localctx ITypeQueryExpressionContext) {
	localctx = NewTypeQueryExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 54, TypeScriptParserRULE_typeQueryExpression)

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

	defer func() {
		if err := recover(); err != 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(485)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 26, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(475)
			p.Match(TypeScriptParserIdentifier)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(479)
		p.GetErrorHandler().Sync(p)
		_alt = 1
		for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			switch _alt {
			case 1:
				{
					p.SetState(476)
					p.IdentifierName()
				}
				{
					p.SetState(477)
					p.Match(TypeScriptParserDot)
				}

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

			p.SetState(481)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 25, p.GetParserRuleContext())
		}
		{
			p.SetState(483)
			p.IdentifierName()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyPropertySignatureContext() *PropertySignatureContext {
	var p = new(PropertySignatureContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_propertySignature
	return p
}

func (*PropertySignatureContext) IsPropertySignatureContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_propertySignature

	return p
}

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

func (s *PropertySignatureContext) PropertyName() IPropertyNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertyNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPropertyNameContext)
}

func (s *PropertySignatureContext) ReadOnly() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserReadOnly, 0)
}

func (s *PropertySignatureContext) QuestionMark() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserQuestionMark, 0)
}

func (s *PropertySignatureContext) TypeAnnotation() ITypeAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAnnotationContext)
}

func (s *PropertySignatureContext) ARROW() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserARROW, 0)
}

func (s *PropertySignatureContext) Type_() IType_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

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

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

func (s *PropertySignatureContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPropertySignature(s)
	}
}

func (s *PropertySignatureContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPropertySignature(s)
	}
}

func (p *TypeScriptParser) PropertySignature() (localctx IPropertySignatureContext) {
	localctx = NewPropertySignatureContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, TypeScriptParserRULE_propertySignature)
	var _la int

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

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

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 27, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(487)
			p.Match(TypeScriptParserReadOnly)
		}

	}
	{
		p.SetState(490)
		p.PropertyName()
	}
	p.SetState(492)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserQuestionMark {
		{
			p.SetState(491)
			p.Match(TypeScriptParserQuestionMark)
		}

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

	if _la == TypeScriptParserColon {
		{
			p.SetState(494)
			p.TypeAnnotation()
		}

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

	if _la == TypeScriptParserARROW {
		{
			p.SetState(497)
			p.Match(TypeScriptParserARROW)
		}
		{
			p.SetState(498)
			p.Type_()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyTypeAnnotationContext() *TypeAnnotationContext {
	var p = new(TypeAnnotationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_typeAnnotation
	return p
}

func (*TypeAnnotationContext) IsTypeAnnotationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_typeAnnotation

	return p
}

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

func (s *TypeAnnotationContext) Colon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserColon, 0)
}

func (s *TypeAnnotationContext) Type_() IType_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

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

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

func (s *TypeAnnotationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTypeAnnotation(s)
	}
}

func (s *TypeAnnotationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTypeAnnotation(s)
	}
}

func (p *TypeScriptParser) TypeAnnotation() (localctx ITypeAnnotationContext) {
	localctx = NewTypeAnnotationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, TypeScriptParserRULE_typeAnnotation)

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

	defer func() {
		if err := recover(); err != nil {
			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(501)
		p.Match(TypeScriptParserColon)
	}
	{
		p.SetState(502)
		p.Type_()
	}

	return localctx
}

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

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

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

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

func NewEmptyCallSignatureContext() *CallSignatureContext {
	var p = new(CallSignatureContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_callSignature
	return p
}

func (*CallSignatureContext) IsCallSignatureContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_callSignature

	return p
}

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

func (s *CallSignatureContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *CallSignatureContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

func (s *CallSignatureContext) ParameterList() IParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParameterListContext)
}

func (s *CallSignatureContext) TypeAnnotation() ITypeAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAnnotationContext)
}

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

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

func (s *CallSignatureContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterCallSignature(s)
	}
}

func (s *CallSignatureContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitCallSignature(s)
	}
}

func (p *TypeScriptParser) CallSignature() (localctx ICallSignatureContext) {
	localctx = NewCallSignatureContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 60, TypeScriptParserRULE_callSignature)
	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(505)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserLessThan {
		{
			p.SetState(504)
			p.TypeParameters()
		}

	}
	{
		p.SetState(507)
		p.Match(TypeScriptParserOpenParen)
	}
	p.SetState(509)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<TypeScriptParserOpenBracket)|(1<<TypeScriptParserOpenBrace)|(1<<TypeScriptParserEllipsis))) != 0) || (((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(TypeScriptParserNullLiteral-61))|(1<<(TypeScriptParserBooleanLiteral-61))|(1<<(TypeScriptParserBreak-61))|(1<<(TypeScriptParserDo-61))|(1<<(TypeScriptParserInstanceof-61))|(1<<(TypeScriptParserTypeof-61))|(1<<(TypeScriptParserCase-61))|(1<<(TypeScriptParserElse-61))|(1<<(TypeScriptParserNew-61))|(1<<(TypeScriptParserVar-61))|(1<<(TypeScriptParserCatch-61))|(1<<(TypeScriptParserFinally-61))|(1<<(TypeScriptParserReturn-61))|(1<<(TypeScriptParserVoid-61))|(1<<(TypeScriptParserContinue-61))|(1<<(TypeScriptParserFor-61))|(1<<(TypeScriptParserSwitch-61))|(1<<(TypeScriptParserWhile-61))|(1<<(TypeScriptParserDebugger-61))|(1<<(TypeScriptParserFunction-61))|(1<<(TypeScriptParserThis-61))|(1<<(TypeScriptParserWith-61))|(1<<(TypeScriptParserDefault-61))|(1<<(TypeScriptParserIf-61))|(1<<(TypeScriptParserThrow-61))|(1<<(TypeScriptParserDelete-61))|(1<<(TypeScriptParserIn-61)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(TypeScriptParserTry-93))|(1<<(TypeScriptParserAs-93))|(1<<(TypeScriptParserFrom-93))|(1<<(TypeScriptParserReadOnly-93))|(1<<(TypeScriptParserAsync-93))|(1<<(TypeScriptParserClass-93))|(1<<(TypeScriptParserEnum-93))|(1<<(TypeScriptParserExtends-93))|(1<<(TypeScriptParserSuper-93))|(1<<(TypeScriptParserConst-93))|(1<<(TypeScriptParserExport-93))|(1<<(TypeScriptParserImport-93))|(1<<(TypeScriptParserAwait-93))|(1<<(TypeScriptParserImplements-93))|(1<<(TypeScriptParserLet-93))|(1<<(TypeScriptParserPrivate-93))|(1<<(TypeScriptParserPublic-93))|(1<<(TypeScriptParserInterface-93))|(1<<(TypeScriptParserPackage-93))|(1<<(TypeScriptParserProtected-93))|(1<<(TypeScriptParserStatic-93))|(1<<(TypeScriptParserYield-93))|(1<<(TypeScriptParserANY-93))|(1<<(TypeScriptParserNUMBER-93))|(1<<(TypeScriptParserBOOLEAN-93))|(1<<(TypeScriptParserSTRING-93))|(1<<(TypeScriptParserSYMBOL-93)))) != 0) || _la == TypeScriptParserAt || _la == TypeScriptParserIdentifier {
		{
			p.SetState(508)
			p.ParameterList()
		}

	}
	{
		p.SetState(511)
		p.Match(TypeScriptParserCloseParen)
	}
	p.SetState(513)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 33, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(512)
			p.TypeAnnotation()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyParameterListContext() *ParameterListContext {
	var p = new(ParameterListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_parameterList
	return p
}

func (*ParameterListContext) IsParameterListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_parameterList

	return p
}

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

func (s *ParameterListContext) RestParameter() IRestParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRestParameterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRestParameterContext)
}

func (s *ParameterListContext) AllPredefinedType() []IPredefinedTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IPredefinedTypeContext)(nil)).Elem())
	var tst = make([]IPredefinedTypeContext, len(ts))

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

	return tst
}

func (s *ParameterListContext) PredefinedType(i int) IPredefinedTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPredefinedTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IPredefinedTypeContext)
}

func (s *ParameterListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *ParameterListContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

func (s *ParameterListContext) OptionalParameterList() IOptionalParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOptionalParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOptionalParameterListContext)
}

func (s *ParameterListContext) RequiredParameterList() IRequiredParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRequiredParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRequiredParameterListContext)
}

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

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

func (s *ParameterListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterParameterList(s)
	}
}

func (s *ParameterListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitParameterList(s)
	}
}

func (p *TypeScriptParser) ParameterList() (localctx IParameterListContext) {
	localctx = NewParameterListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 62, TypeScriptParserRULE_parameterList)
	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(541)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 39, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(515)
			p.RestParameter()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(516)
			p.PredefinedType()
		}
		p.SetState(521)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == TypeScriptParserComma {
			{
				p.SetState(517)
				p.Match(TypeScriptParserComma)
			}
			{
				p.SetState(518)
				p.PredefinedType()
			}

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

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(524)
			p.OptionalParameterList()
		}
		p.SetState(527)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserComma {
			{
				p.SetState(525)
				p.Match(TypeScriptParserComma)
			}
			{
				p.SetState(526)
				p.RestParameter()
			}

		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(529)
			p.RequiredParameterList()
		}
		p.SetState(539)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserComma {
			{
				p.SetState(530)
				p.Match(TypeScriptParserComma)
			}
			p.SetState(537)
			p.GetErrorHandler().Sync(p)

			switch p.GetTokenStream().LA(1) {
			case TypeScriptParserOpenBracket, TypeScriptParserOpenBrace, TypeScriptParserNullLiteral, TypeScriptParserBooleanLiteral, TypeScriptParserBreak, TypeScriptParserDo, TypeScriptParserInstanceof, TypeScriptParserTypeof, TypeScriptParserCase, TypeScriptParserElse, TypeScriptParserNew, TypeScriptParserVar, TypeScriptParserCatch, TypeScriptParserFinally, TypeScriptParserReturn, TypeScriptParserVoid, TypeScriptParserContinue, TypeScriptParserFor, TypeScriptParserSwitch, TypeScriptParserWhile, TypeScriptParserDebugger, TypeScriptParserFunction, TypeScriptParserThis, TypeScriptParserWith, TypeScriptParserDefault, TypeScriptParserIf, TypeScriptParserThrow, TypeScriptParserDelete, TypeScriptParserIn, TypeScriptParserTry, TypeScriptParserAs, TypeScriptParserFrom, TypeScriptParserReadOnly, TypeScriptParserAsync, TypeScriptParserClass, TypeScriptParserEnum, TypeScriptParserExtends, TypeScriptParserSuper, TypeScriptParserConst, TypeScriptParserExport, TypeScriptParserImport, TypeScriptParserAwait, TypeScriptParserImplements, TypeScriptParserLet, TypeScriptParserPrivate, TypeScriptParserPublic, TypeScriptParserInterface, TypeScriptParserPackage, TypeScriptParserProtected, TypeScriptParserStatic, TypeScriptParserYield, TypeScriptParserAt, TypeScriptParserIdentifier:
				{
					p.SetState(531)
					p.OptionalParameterList()
				}
				p.SetState(534)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == TypeScriptParserComma {
					{
						p.SetState(532)
						p.Match(TypeScriptParserComma)
					}
					{
						p.SetState(533)
						p.RestParameter()
					}

				}

			case TypeScriptParserEllipsis:
				{
					p.SetState(536)
					p.RestParameter()
				}

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

		}

	}

	return localctx
}

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

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

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

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

func NewEmptyRequiredParameterListContext() *RequiredParameterListContext {
	var p = new(RequiredParameterListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_requiredParameterList
	return p
}

func (*RequiredParameterListContext) IsRequiredParameterListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_requiredParameterList

	return p
}

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

func (s *RequiredParameterListContext) AllRequiredParameter() []IRequiredParameterContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IRequiredParameterContext)(nil)).Elem())
	var tst = make([]IRequiredParameterContext, len(ts))

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

	return tst
}

func (s *RequiredParameterListContext) RequiredParameter(i int) IRequiredParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRequiredParameterContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IRequiredParameterContext)
}

func (s *RequiredParameterListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *RequiredParameterListContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

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

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

func (s *RequiredParameterListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterRequiredParameterList(s)
	}
}

func (s *RequiredParameterListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitRequiredParameterList(s)
	}
}

func (p *TypeScriptParser) RequiredParameterList() (localctx IRequiredParameterListContext) {
	localctx = NewRequiredParameterListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 64, TypeScriptParserRULE_requiredParameterList)

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

	defer func() {
		if err := recover(); err != 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(543)
		p.RequiredParameter()
	}
	p.SetState(548)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 40, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(544)
				p.Match(TypeScriptParserComma)
			}
			{
				p.SetState(545)
				p.RequiredParameter()
			}

		}
		p.SetState(550)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 40, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyRequiredParameterContext() *RequiredParameterContext {
	var p = new(RequiredParameterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_requiredParameter
	return p
}

func (*RequiredParameterContext) IsRequiredParameterContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_requiredParameter

	return p
}

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

func (s *RequiredParameterContext) IdentifierOrPattern() IIdentifierOrPatternContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierOrPatternContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierOrPatternContext)
}

func (s *RequiredParameterContext) DecoratorList() IDecoratorListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDecoratorListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDecoratorListContext)
}

func (s *RequiredParameterContext) AccessibilityModifier() IAccessibilityModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAccessibilityModifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAccessibilityModifierContext)
}

func (s *RequiredParameterContext) TypeAnnotation() ITypeAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAnnotationContext)
}

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

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

func (s *RequiredParameterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterRequiredParameter(s)
	}
}

func (s *RequiredParameterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitRequiredParameter(s)
	}
}

func (p *TypeScriptParser) RequiredParameter() (localctx IRequiredParameterContext) {
	localctx = NewRequiredParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, TypeScriptParserRULE_requiredParameter)
	var _la int

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

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

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

	if _la == TypeScriptParserAt {
		{
			p.SetState(551)
			p.DecoratorList()
		}

	}
	p.SetState(555)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 42, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(554)
			p.AccessibilityModifier()
		}

	}
	{
		p.SetState(557)
		p.IdentifierOrPattern()
	}
	p.SetState(559)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserColon {
		{
			p.SetState(558)
			p.TypeAnnotation()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyAccessibilityModifierContext() *AccessibilityModifierContext {
	var p = new(AccessibilityModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_accessibilityModifier
	return p
}

func (*AccessibilityModifierContext) IsAccessibilityModifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_accessibilityModifier

	return p
}

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

func (s *AccessibilityModifierContext) Public() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserPublic, 0)
}

func (s *AccessibilityModifierContext) Private() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserPrivate, 0)
}

func (s *AccessibilityModifierContext) Protected() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserProtected, 0)
}

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

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

func (s *AccessibilityModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterAccessibilityModifier(s)
	}
}

func (s *AccessibilityModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitAccessibilityModifier(s)
	}
}

func (p *TypeScriptParser) AccessibilityModifier() (localctx IAccessibilityModifierContext) {
	localctx = NewAccessibilityModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, TypeScriptParserRULE_accessibilityModifier)
	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(561)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-108)&-(0x1f+1)) == 0 && ((1<<uint((_la-108)))&((1<<(TypeScriptParserPrivate-108))|(1<<(TypeScriptParserPublic-108))|(1<<(TypeScriptParserProtected-108)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

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

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

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

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

func NewEmptyIdentifierOrPatternContext() *IdentifierOrPatternContext {
	var p = new(IdentifierOrPatternContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_identifierOrPattern
	return p
}

func (*IdentifierOrPatternContext) IsIdentifierOrPatternContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_identifierOrPattern

	return p
}

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

func (s *IdentifierOrPatternContext) IdentifierName() IIdentifierNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierNameContext)
}

func (s *IdentifierOrPatternContext) BindingPattern() IBindingPatternContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBindingPatternContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBindingPatternContext)
}

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

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

func (s *IdentifierOrPatternContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterIdentifierOrPattern(s)
	}
}

func (s *IdentifierOrPatternContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitIdentifierOrPattern(s)
	}
}

func (p *TypeScriptParser) IdentifierOrPattern() (localctx IIdentifierOrPatternContext) {
	localctx = NewIdentifierOrPatternContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, TypeScriptParserRULE_identifierOrPattern)

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

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

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserNullLiteral, TypeScriptParserBooleanLiteral, TypeScriptParserBreak, TypeScriptParserDo, TypeScriptParserInstanceof, TypeScriptParserTypeof, TypeScriptParserCase, TypeScriptParserElse, TypeScriptParserNew, TypeScriptParserVar, TypeScriptParserCatch, TypeScriptParserFinally, TypeScriptParserReturn, TypeScriptParserVoid, TypeScriptParserContinue, TypeScriptParserFor, TypeScriptParserSwitch, TypeScriptParserWhile, TypeScriptParserDebugger, TypeScriptParserFunction, TypeScriptParserThis, TypeScriptParserWith, TypeScriptParserDefault, TypeScriptParserIf, TypeScriptParserThrow, TypeScriptParserDelete, TypeScriptParserIn, TypeScriptParserTry, TypeScriptParserAs, TypeScriptParserFrom, TypeScriptParserReadOnly, TypeScriptParserAsync, TypeScriptParserClass, TypeScriptParserEnum, TypeScriptParserExtends, TypeScriptParserSuper, TypeScriptParserConst, TypeScriptParserExport, TypeScriptParserImport, TypeScriptParserAwait, TypeScriptParserImplements, TypeScriptParserLet, TypeScriptParserPrivate, TypeScriptParserPublic, TypeScriptParserInterface, TypeScriptParserPackage, TypeScriptParserProtected, TypeScriptParserStatic, TypeScriptParserYield, TypeScriptParserIdentifier:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(563)
			p.IdentifierName()
		}

	case TypeScriptParserOpenBracket, TypeScriptParserOpenBrace:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(564)
			p.BindingPattern()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyOptionalParameterListContext() *OptionalParameterListContext {
	var p = new(OptionalParameterListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_optionalParameterList
	return p
}

func (*OptionalParameterListContext) IsOptionalParameterListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_optionalParameterList

	return p
}

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

func (s *OptionalParameterListContext) AllOptionalParameter() []IOptionalParameterContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IOptionalParameterContext)(nil)).Elem())
	var tst = make([]IOptionalParameterContext, len(ts))

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

	return tst
}

func (s *OptionalParameterListContext) OptionalParameter(i int) IOptionalParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOptionalParameterContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IOptionalParameterContext)
}

func (s *OptionalParameterListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *OptionalParameterListContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

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

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

func (s *OptionalParameterListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterOptionalParameterList(s)
	}
}

func (s *OptionalParameterListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitOptionalParameterList(s)
	}
}

func (p *TypeScriptParser) OptionalParameterList() (localctx IOptionalParameterListContext) {
	localctx = NewOptionalParameterListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, TypeScriptParserRULE_optionalParameterList)

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

	defer func() {
		if err := recover(); err != 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(567)
		p.OptionalParameter()
	}
	p.SetState(572)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 45, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(568)
				p.Match(TypeScriptParserComma)
			}
			{
				p.SetState(569)
				p.OptionalParameter()
			}

		}
		p.SetState(574)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 45, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyOptionalParameterContext() *OptionalParameterContext {
	var p = new(OptionalParameterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_optionalParameter
	return p
}

func (*OptionalParameterContext) IsOptionalParameterContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_optionalParameter

	return p
}

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

func (s *OptionalParameterContext) IdentifierOrPattern() IIdentifierOrPatternContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierOrPatternContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierOrPatternContext)
}

func (s *OptionalParameterContext) DecoratorList() IDecoratorListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDecoratorListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDecoratorListContext)
}

func (s *OptionalParameterContext) QuestionMark() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserQuestionMark, 0)
}

func (s *OptionalParameterContext) Initializer() IInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitializerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInitializerContext)
}

func (s *OptionalParameterContext) AccessibilityModifier() IAccessibilityModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAccessibilityModifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAccessibilityModifierContext)
}

func (s *OptionalParameterContext) TypeAnnotation() ITypeAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAnnotationContext)
}

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

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

func (s *OptionalParameterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterOptionalParameter(s)
	}
}

func (s *OptionalParameterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitOptionalParameter(s)
	}
}

func (p *TypeScriptParser) OptionalParameter() (localctx IOptionalParameterContext) {
	localctx = NewOptionalParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, TypeScriptParserRULE_optionalParameter)
	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(576)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserAt {
		{
			p.SetState(575)
			p.DecoratorList()
		}

	}

	p.SetState(579)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 47, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(578)
			p.AccessibilityModifier()
		}

	}
	{
		p.SetState(581)
		p.IdentifierOrPattern()
	}
	p.SetState(590)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserQuestionMark:
		{
			p.SetState(582)
			p.Match(TypeScriptParserQuestionMark)
		}
		p.SetState(584)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserColon {
			{
				p.SetState(583)
				p.TypeAnnotation()
			}

		}

	case TypeScriptParserAssign, TypeScriptParserColon:
		p.SetState(587)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserColon {
			{
				p.SetState(586)
				p.TypeAnnotation()
			}

		}
		{
			p.SetState(589)
			p.Initializer()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyRestParameterContext() *RestParameterContext {
	var p = new(RestParameterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_restParameter
	return p
}

func (*RestParameterContext) IsRestParameterContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_restParameter

	return p
}

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

func (s *RestParameterContext) Ellipsis() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserEllipsis, 0)
}

func (s *RestParameterContext) RequiredParameter() IRequiredParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRequiredParameterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRequiredParameterContext)
}

func (s *RestParameterContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

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

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

func (s *RestParameterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterRestParameter(s)
	}
}

func (s *RestParameterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitRestParameter(s)
	}
}

func (p *TypeScriptParser) RestParameter() (localctx IRestParameterContext) {
	localctx = NewRestParameterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 76, TypeScriptParserRULE_restParameter)

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

	defer func() {
		if err := recover(); err != nil {
			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(596)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 51, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(592)
			p.Match(TypeScriptParserEllipsis)
		}
		{
			p.SetState(593)
			p.RequiredParameter()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(594)
			p.Match(TypeScriptParserEllipsis)
		}
		{
			p.SetState(595)
			p.singleExpression(0)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyConstructSignatureContext() *ConstructSignatureContext {
	var p = new(ConstructSignatureContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_constructSignature
	return p
}

func (*ConstructSignatureContext) IsConstructSignatureContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_constructSignature

	return p
}

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

func (s *ConstructSignatureContext) New() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserNew, 0)
}

func (s *ConstructSignatureContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *ConstructSignatureContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

func (s *ConstructSignatureContext) ParameterList() IParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParameterListContext)
}

func (s *ConstructSignatureContext) TypeAnnotation() ITypeAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAnnotationContext)
}

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

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

func (s *ConstructSignatureContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterConstructSignature(s)
	}
}

func (s *ConstructSignatureContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitConstructSignature(s)
	}
}

func (p *TypeScriptParser) ConstructSignature() (localctx IConstructSignatureContext) {
	localctx = NewConstructSignatureContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, TypeScriptParserRULE_constructSignature)
	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(598)
		p.Match(TypeScriptParserNew)
	}
	p.SetState(600)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserLessThan {
		{
			p.SetState(599)
			p.TypeParameters()
		}

	}
	{
		p.SetState(602)
		p.Match(TypeScriptParserOpenParen)
	}
	p.SetState(604)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<TypeScriptParserOpenBracket)|(1<<TypeScriptParserOpenBrace)|(1<<TypeScriptParserEllipsis))) != 0) || (((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(TypeScriptParserNullLiteral-61))|(1<<(TypeScriptParserBooleanLiteral-61))|(1<<(TypeScriptParserBreak-61))|(1<<(TypeScriptParserDo-61))|(1<<(TypeScriptParserInstanceof-61))|(1<<(TypeScriptParserTypeof-61))|(1<<(TypeScriptParserCase-61))|(1<<(TypeScriptParserElse-61))|(1<<(TypeScriptParserNew-61))|(1<<(TypeScriptParserVar-61))|(1<<(TypeScriptParserCatch-61))|(1<<(TypeScriptParserFinally-61))|(1<<(TypeScriptParserReturn-61))|(1<<(TypeScriptParserVoid-61))|(1<<(TypeScriptParserContinue-61))|(1<<(TypeScriptParserFor-61))|(1<<(TypeScriptParserSwitch-61))|(1<<(TypeScriptParserWhile-61))|(1<<(TypeScriptParserDebugger-61))|(1<<(TypeScriptParserFunction-61))|(1<<(TypeScriptParserThis-61))|(1<<(TypeScriptParserWith-61))|(1<<(TypeScriptParserDefault-61))|(1<<(TypeScriptParserIf-61))|(1<<(TypeScriptParserThrow-61))|(1<<(TypeScriptParserDelete-61))|(1<<(TypeScriptParserIn-61)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(TypeScriptParserTry-93))|(1<<(TypeScriptParserAs-93))|(1<<(TypeScriptParserFrom-93))|(1<<(TypeScriptParserReadOnly-93))|(1<<(TypeScriptParserAsync-93))|(1<<(TypeScriptParserClass-93))|(1<<(TypeScriptParserEnum-93))|(1<<(TypeScriptParserExtends-93))|(1<<(TypeScriptParserSuper-93))|(1<<(TypeScriptParserConst-93))|(1<<(TypeScriptParserExport-93))|(1<<(TypeScriptParserImport-93))|(1<<(TypeScriptParserAwait-93))|(1<<(TypeScriptParserImplements-93))|(1<<(TypeScriptParserLet-93))|(1<<(TypeScriptParserPrivate-93))|(1<<(TypeScriptParserPublic-93))|(1<<(TypeScriptParserInterface-93))|(1<<(TypeScriptParserPackage-93))|(1<<(TypeScriptParserProtected-93))|(1<<(TypeScriptParserStatic-93))|(1<<(TypeScriptParserYield-93))|(1<<(TypeScriptParserANY-93))|(1<<(TypeScriptParserNUMBER-93))|(1<<(TypeScriptParserBOOLEAN-93))|(1<<(TypeScriptParserSTRING-93))|(1<<(TypeScriptParserSYMBOL-93)))) != 0) || _la == TypeScriptParserAt || _la == TypeScriptParserIdentifier {
		{
			p.SetState(603)
			p.ParameterList()
		}

	}
	{
		p.SetState(606)
		p.Match(TypeScriptParserCloseParen)
	}
	p.SetState(608)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserColon {
		{
			p.SetState(607)
			p.TypeAnnotation()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyIndexSignatureContext() *IndexSignatureContext {
	var p = new(IndexSignatureContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_indexSignature
	return p
}

func (*IndexSignatureContext) IsIndexSignatureContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_indexSignature

	return p
}

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

func (s *IndexSignatureContext) OpenBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBracket, 0)
}

func (s *IndexSignatureContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *IndexSignatureContext) Colon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserColon, 0)
}

func (s *IndexSignatureContext) CloseBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBracket, 0)
}

func (s *IndexSignatureContext) TypeAnnotation() ITypeAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAnnotationContext)
}

func (s *IndexSignatureContext) NUMBER() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserNUMBER, 0)
}

func (s *IndexSignatureContext) STRING() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSTRING, 0)
}

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

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

func (s *IndexSignatureContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterIndexSignature(s)
	}
}

func (s *IndexSignatureContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitIndexSignature(s)
	}
}

func (p *TypeScriptParser) IndexSignature() (localctx IIndexSignatureContext) {
	localctx = NewIndexSignatureContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, TypeScriptParserRULE_indexSignature)
	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(610)
		p.Match(TypeScriptParserOpenBracket)
	}
	{
		p.SetState(611)
		p.Match(TypeScriptParserIdentifier)
	}
	{
		p.SetState(612)
		p.Match(TypeScriptParserColon)
	}
	{
		p.SetState(613)
		_la = p.GetTokenStream().LA(1)

		if !(_la == TypeScriptParserNUMBER || _la == TypeScriptParserSTRING) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	{
		p.SetState(614)
		p.Match(TypeScriptParserCloseBracket)
	}
	{
		p.SetState(615)
		p.TypeAnnotation()
	}

	return localctx
}

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

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

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

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

func NewEmptyMethodSignatureContext() *MethodSignatureContext {
	var p = new(MethodSignatureContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_methodSignature
	return p
}

func (*MethodSignatureContext) IsMethodSignatureContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_methodSignature

	return p
}

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

func (s *MethodSignatureContext) PropertyName() IPropertyNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertyNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPropertyNameContext)
}

func (s *MethodSignatureContext) CallSignature() ICallSignatureContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICallSignatureContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICallSignatureContext)
}

func (s *MethodSignatureContext) QuestionMark() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserQuestionMark, 0)
}

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

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

func (s *MethodSignatureContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterMethodSignature(s)
	}
}

func (s *MethodSignatureContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitMethodSignature(s)
	}
}

func (p *TypeScriptParser) MethodSignature() (localctx IMethodSignatureContext) {
	localctx = NewMethodSignatureContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, TypeScriptParserRULE_methodSignature)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(617)
		p.PropertyName()
	}
	p.SetState(619)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserQuestionMark {
		{
			p.SetState(618)
			p.Match(TypeScriptParserQuestionMark)
		}

	}
	{
		p.SetState(621)
		p.CallSignature()
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeAliasDeclarationContext() *TypeAliasDeclarationContext {
	var p = new(TypeAliasDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_typeAliasDeclaration
	return p
}

func (*TypeAliasDeclarationContext) IsTypeAliasDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_typeAliasDeclaration

	return p
}

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

func (s *TypeAliasDeclarationContext) Type() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserType, 0)
}

func (s *TypeAliasDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *TypeAliasDeclarationContext) Assign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAssign, 0)
}

func (s *TypeAliasDeclarationContext) Type_() IType_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

func (s *TypeAliasDeclarationContext) SemiColon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

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

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

func (s *TypeAliasDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTypeAliasDeclaration(s)
	}
}

func (s *TypeAliasDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTypeAliasDeclaration(s)
	}
}

func (p *TypeScriptParser) TypeAliasDeclaration() (localctx ITypeAliasDeclarationContext) {
	localctx = NewTypeAliasDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 84, TypeScriptParserRULE_typeAliasDeclaration)
	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.Match(TypeScriptParserType)
	}
	{
		p.SetState(624)
		p.Match(TypeScriptParserIdentifier)
	}
	p.SetState(626)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserLessThan {
		{
			p.SetState(625)
			p.TypeParameters()
		}

	}
	{
		p.SetState(628)
		p.Match(TypeScriptParserAssign)
	}
	{
		p.SetState(629)
		p.Type_()
	}
	{
		p.SetState(630)
		p.Match(TypeScriptParserSemiColon)
	}

	return localctx
}

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

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

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

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

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

	return p
}

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

func (s *ConstructorDeclarationContext) Constructor() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserConstructor, 0)
}

func (s *ConstructorDeclarationContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *ConstructorDeclarationContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IAccessibilityModifierContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IFormalParameterListContext)
}

func (s *ConstructorDeclarationContext) SemiColon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, 0)
}

func (s *ConstructorDeclarationContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IFunctionBodyContext)
}

func (s *ConstructorDeclarationContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

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

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

func (p *TypeScriptParser) ConstructorDeclaration() (localctx IConstructorDeclarationContext) {
	localctx = NewConstructorDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, TypeScriptParserRULE_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(633)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-108)&-(0x1f+1)) == 0 && ((1<<uint((_la-108)))&((1<<(TypeScriptParserPrivate-108))|(1<<(TypeScriptParserPublic-108))|(1<<(TypeScriptParserProtected-108)))) != 0 {
		{
			p.SetState(632)
			p.AccessibilityModifier()
		}

	}
	{
		p.SetState(635)
		p.Match(TypeScriptParserConstructor)
	}
	{
		p.SetState(636)
		p.Match(TypeScriptParserOpenParen)
	}
	p.SetState(638)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<TypeScriptParserOpenBracket)|(1<<TypeScriptParserOpenBrace)|(1<<TypeScriptParserEllipsis))) != 0) || (((_la-108)&-(0x1f+1)) == 0 && ((1<<uint((_la-108)))&((1<<(TypeScriptParserPrivate-108))|(1<<(TypeScriptParserPublic-108))|(1<<(TypeScriptParserProtected-108))|(1<<(TypeScriptParserIdentifier-108)))) != 0) {
		{
			p.SetState(637)
			p.FormalParameterList()
		}

	}
	{
		p.SetState(640)
		p.Match(TypeScriptParserCloseParen)
	}
	p.SetState(646)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 59, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(641)
			p.Match(TypeScriptParserOpenBrace)
		}
		{
			p.SetState(642)
			p.FunctionBody()
		}
		{
			p.SetState(643)
			p.Match(TypeScriptParserCloseBrace)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 59, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(645)
			p.Match(TypeScriptParserSemiColon)
		}

	}

	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 = TypeScriptParserRULE_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 = TypeScriptParserRULE_interfaceDeclaration

	return p
}

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

func (s *InterfaceDeclarationContext) Interface() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserInterface, 0)
}

func (s *InterfaceDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IObjectTypeContext)
}

func (s *InterfaceDeclarationContext) Export() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserExport, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IInterfaceExtendsClauseContext)
}

func (s *InterfaceDeclarationContext) SemiColon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, 0)
}

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

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

func (p *TypeScriptParser) InterfaceDeclaration() (localctx IInterfaceDeclarationContext) {
	localctx = NewInterfaceDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, TypeScriptParserRULE_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(649)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserExport {
		{
			p.SetState(648)
			p.Match(TypeScriptParserExport)
		}

	}
	{
		p.SetState(651)
		p.Match(TypeScriptParserInterface)
	}
	{
		p.SetState(652)
		p.Match(TypeScriptParserIdentifier)
	}
	p.SetState(654)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserLessThan {
		{
			p.SetState(653)
			p.TypeParameters()
		}

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

	if _la == TypeScriptParserExtends {
		{
			p.SetState(656)
			p.InterfaceExtendsClause()
		}

	}
	{
		p.SetState(659)
		p.ObjectType()
	}
	p.SetState(661)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 63, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(660)
			p.Match(TypeScriptParserSemiColon)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyInterfaceExtendsClauseContext() *InterfaceExtendsClauseContext {
	var p = new(InterfaceExtendsClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_interfaceExtendsClause
	return p
}

func (*InterfaceExtendsClauseContext) IsInterfaceExtendsClauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_interfaceExtendsClause

	return p
}

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

func (s *InterfaceExtendsClauseContext) Extends() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserExtends, 0)
}

func (s *InterfaceExtendsClauseContext) ClassOrInterfaceTypeList() IClassOrInterfaceTypeListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassOrInterfaceTypeListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassOrInterfaceTypeListContext)
}

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

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

func (s *InterfaceExtendsClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterInterfaceExtendsClause(s)
	}
}

func (s *InterfaceExtendsClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitInterfaceExtendsClause(s)
	}
}

func (p *TypeScriptParser) InterfaceExtendsClause() (localctx IInterfaceExtendsClauseContext) {
	localctx = NewInterfaceExtendsClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, TypeScriptParserRULE_interfaceExtendsClause)

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

	defer func() {
		if err := recover(); err != nil {
			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(663)
		p.Match(TypeScriptParserExtends)
	}
	{
		p.SetState(664)
		p.ClassOrInterfaceTypeList()
	}

	return localctx
}

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

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

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

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

func NewEmptyClassOrInterfaceTypeListContext() *ClassOrInterfaceTypeListContext {
	var p = new(ClassOrInterfaceTypeListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_classOrInterfaceTypeList
	return p
}

func (*ClassOrInterfaceTypeListContext) IsClassOrInterfaceTypeListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_classOrInterfaceTypeList

	return p
}

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

func (s *ClassOrInterfaceTypeListContext) AllTypeReference() []ITypeReferenceContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeReferenceContext)(nil)).Elem())
	var tst = make([]ITypeReferenceContext, len(ts))

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

	return tst
}

func (s *ClassOrInterfaceTypeListContext) TypeReference(i int) ITypeReferenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeReferenceContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeReferenceContext)
}

func (s *ClassOrInterfaceTypeListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *ClassOrInterfaceTypeListContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

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

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

func (s *ClassOrInterfaceTypeListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterClassOrInterfaceTypeList(s)
	}
}

func (s *ClassOrInterfaceTypeListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitClassOrInterfaceTypeList(s)
	}
}

func (p *TypeScriptParser) ClassOrInterfaceTypeList() (localctx IClassOrInterfaceTypeListContext) {
	localctx = NewClassOrInterfaceTypeListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, TypeScriptParserRULE_classOrInterfaceTypeList)
	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(666)
		p.TypeReference()
	}
	p.SetState(671)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == TypeScriptParserComma {
		{
			p.SetState(667)
			p.Match(TypeScriptParserComma)
		}
		{
			p.SetState(668)
			p.TypeReference()
		}

		p.SetState(673)
		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 = TypeScriptParserRULE_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 = TypeScriptParserRULE_enumDeclaration

	return p
}

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

func (s *EnumDeclarationContext) Enum() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserEnum, 0)
}

func (s *EnumDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *EnumDeclarationContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *EnumDeclarationContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *EnumDeclarationContext) Const() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserConst, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IEnumBodyContext)
}

func (s *EnumDeclarationContext) 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.(TypeScriptParserListener); ok {
		listenerT.EnterEnumDeclaration(s)
	}
}

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

func (p *TypeScriptParser) EnumDeclaration() (localctx IEnumDeclarationContext) {
	localctx = NewEnumDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, TypeScriptParserRULE_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(675)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserConst {
		{
			p.SetState(674)
			p.Match(TypeScriptParserConst)
		}

	}
	{
		p.SetState(677)
		p.Match(TypeScriptParserEnum)
	}
	{
		p.SetState(678)
		p.Match(TypeScriptParserIdentifier)
	}
	{
		p.SetState(679)
		p.Match(TypeScriptParserOpenBrace)
	}
	p.SetState(681)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserOpenBracket || (((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(TypeScriptParserNullLiteral-61))|(1<<(TypeScriptParserBooleanLiteral-61))|(1<<(TypeScriptParserDecimalLiteral-61))|(1<<(TypeScriptParserHexIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral2-61))|(1<<(TypeScriptParserBinaryIntegerLiteral-61))|(1<<(TypeScriptParserBreak-61))|(1<<(TypeScriptParserDo-61))|(1<<(TypeScriptParserInstanceof-61))|(1<<(TypeScriptParserTypeof-61))|(1<<(TypeScriptParserCase-61))|(1<<(TypeScriptParserElse-61))|(1<<(TypeScriptParserNew-61))|(1<<(TypeScriptParserVar-61))|(1<<(TypeScriptParserCatch-61))|(1<<(TypeScriptParserFinally-61))|(1<<(TypeScriptParserReturn-61))|(1<<(TypeScriptParserVoid-61))|(1<<(TypeScriptParserContinue-61))|(1<<(TypeScriptParserFor-61))|(1<<(TypeScriptParserSwitch-61))|(1<<(TypeScriptParserWhile-61))|(1<<(TypeScriptParserDebugger-61))|(1<<(TypeScriptParserFunction-61))|(1<<(TypeScriptParserThis-61))|(1<<(TypeScriptParserWith-61))|(1<<(TypeScriptParserDefault-61))|(1<<(TypeScriptParserIf-61))|(1<<(TypeScriptParserThrow-61))|(1<<(TypeScriptParserDelete-61))|(1<<(TypeScriptParserIn-61)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(TypeScriptParserTry-93))|(1<<(TypeScriptParserAs-93))|(1<<(TypeScriptParserFrom-93))|(1<<(TypeScriptParserReadOnly-93))|(1<<(TypeScriptParserAsync-93))|(1<<(TypeScriptParserClass-93))|(1<<(TypeScriptParserEnum-93))|(1<<(TypeScriptParserExtends-93))|(1<<(TypeScriptParserSuper-93))|(1<<(TypeScriptParserConst-93))|(1<<(TypeScriptParserExport-93))|(1<<(TypeScriptParserImport-93))|(1<<(TypeScriptParserAwait-93))|(1<<(TypeScriptParserImplements-93))|(1<<(TypeScriptParserLet-93))|(1<<(TypeScriptParserPrivate-93))|(1<<(TypeScriptParserPublic-93))|(1<<(TypeScriptParserInterface-93))|(1<<(TypeScriptParserPackage-93))|(1<<(TypeScriptParserProtected-93))|(1<<(TypeScriptParserStatic-93))|(1<<(TypeScriptParserYield-93)))) != 0) || _la == TypeScriptParserIdentifier || _la == TypeScriptParserStringLiteral {
		{
			p.SetState(680)
			p.EnumBody()
		}

	}
	{
		p.SetState(683)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

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

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

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

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

func NewEmptyEnumBodyContext() *EnumBodyContext {
	var p = new(EnumBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_enumBody
	return p
}

func (*EnumBodyContext) IsEnumBodyContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_enumBody

	return p
}

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

func (s *EnumBodyContext) EnumMemberList() IEnumMemberListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumMemberListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumMemberListContext)
}

func (s *EnumBodyContext) Comma() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, 0)
}

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

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

func (s *EnumBodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterEnumBody(s)
	}
}

func (s *EnumBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitEnumBody(s)
	}
}

func (p *TypeScriptParser) EnumBody() (localctx IEnumBodyContext) {
	localctx = NewEnumBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 96, TypeScriptParserRULE_enumBody)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(685)
		p.EnumMemberList()
	}
	p.SetState(687)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserComma {
		{
			p.SetState(686)
			p.Match(TypeScriptParserComma)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyEnumMemberListContext() *EnumMemberListContext {
	var p = new(EnumMemberListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_enumMemberList
	return p
}

func (*EnumMemberListContext) IsEnumMemberListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_enumMemberList

	return p
}

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

func (s *EnumMemberListContext) AllEnumMember() []IEnumMemberContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEnumMemberContext)(nil)).Elem())
	var tst = make([]IEnumMemberContext, len(ts))

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

	return tst
}

func (s *EnumMemberListContext) EnumMember(i int) IEnumMemberContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumMemberContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEnumMemberContext)
}

func (s *EnumMemberListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *EnumMemberListContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

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

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

func (s *EnumMemberListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterEnumMemberList(s)
	}
}

func (s *EnumMemberListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitEnumMemberList(s)
	}
}

func (p *TypeScriptParser) EnumMemberList() (localctx IEnumMemberListContext) {
	localctx = NewEnumMemberListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 98, TypeScriptParserRULE_enumMemberList)

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

	defer func() {
		if err := recover(); err != 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(689)
		p.EnumMember()
	}
	p.SetState(694)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 68, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(690)
				p.Match(TypeScriptParserComma)
			}
			{
				p.SetState(691)
				p.EnumMember()
			}

		}
		p.SetState(696)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 68, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyEnumMemberContext() *EnumMemberContext {
	var p = new(EnumMemberContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_enumMember
	return p
}

func (*EnumMemberContext) IsEnumMemberContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_enumMember

	return p
}

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

func (s *EnumMemberContext) PropertyName() IPropertyNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertyNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPropertyNameContext)
}

func (s *EnumMemberContext) Assign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAssign, 0)
}

func (s *EnumMemberContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

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

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

func (s *EnumMemberContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterEnumMember(s)
	}
}

func (s *EnumMemberContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitEnumMember(s)
	}
}

func (p *TypeScriptParser) EnumMember() (localctx IEnumMemberContext) {
	localctx = NewEnumMemberContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, TypeScriptParserRULE_enumMember)
	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(697)
		p.PropertyName()
	}
	p.SetState(700)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserAssign {
		{
			p.SetState(698)
			p.Match(TypeScriptParserAssign)
		}
		{
			p.SetState(699)
			p.singleExpression(0)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyNamespaceDeclarationContext() *NamespaceDeclarationContext {
	var p = new(NamespaceDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_namespaceDeclaration
	return p
}

func (*NamespaceDeclarationContext) IsNamespaceDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_namespaceDeclaration

	return p
}

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

func (s *NamespaceDeclarationContext) Namespace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserNamespace, 0)
}

func (s *NamespaceDeclarationContext) NamespaceName() INamespaceNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INamespaceNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INamespaceNameContext)
}

func (s *NamespaceDeclarationContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *NamespaceDeclarationContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *NamespaceDeclarationContext) StatementList() IStatementListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementListContext)
}

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

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

func (s *NamespaceDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterNamespaceDeclaration(s)
	}
}

func (s *NamespaceDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitNamespaceDeclaration(s)
	}
}

func (p *TypeScriptParser) NamespaceDeclaration() (localctx INamespaceDeclarationContext) {
	localctx = NewNamespaceDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, TypeScriptParserRULE_namespaceDeclaration)

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

	defer func() {
		if err := recover(); err != nil {
			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(702)
		p.Match(TypeScriptParserNamespace)
	}
	{
		p.SetState(703)
		p.NamespaceName()
	}
	{
		p.SetState(704)
		p.Match(TypeScriptParserOpenBrace)
	}
	p.SetState(706)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 70, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(705)
			p.StatementList()
		}

	}
	{
		p.SetState(708)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

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

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

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

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

func NewEmptyNamespaceNameContext() *NamespaceNameContext {
	var p = new(NamespaceNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_namespaceName
	return p
}

func (*NamespaceNameContext) IsNamespaceNameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_namespaceName

	return p
}

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

func (s *NamespaceNameContext) AllIdentifier() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserIdentifier)
}

func (s *NamespaceNameContext) Identifier(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, i)
}

func (s *NamespaceNameContext) AllDot() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserDot)
}

func (s *NamespaceNameContext) Dot(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDot, i)
}

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

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

func (s *NamespaceNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterNamespaceName(s)
	}
}

func (s *NamespaceNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitNamespaceName(s)
	}
}

func (p *TypeScriptParser) NamespaceName() (localctx INamespaceNameContext) {
	localctx = NewNamespaceNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 104, TypeScriptParserRULE_namespaceName)
	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(710)
		p.Match(TypeScriptParserIdentifier)
	}
	p.SetState(719)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 72, p.GetParserRuleContext())

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

			for ok := true; ok; ok = _la == TypeScriptParserDot {
				{
					p.SetState(711)
					p.Match(TypeScriptParserDot)
				}

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

		}
		p.SetState(721)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 72, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyImportAliasDeclarationContext() *ImportAliasDeclarationContext {
	var p = new(ImportAliasDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_importAliasDeclaration
	return p
}

func (*ImportAliasDeclarationContext) IsImportAliasDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_importAliasDeclaration

	return p
}

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

func (s *ImportAliasDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *ImportAliasDeclarationContext) Assign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAssign, 0)
}

func (s *ImportAliasDeclarationContext) NamespaceName() INamespaceNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INamespaceNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INamespaceNameContext)
}

func (s *ImportAliasDeclarationContext) SemiColon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, 0)
}

func (s *ImportAliasDeclarationContext) Require() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserRequire, 0)
}

func (s *ImportAliasDeclarationContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *ImportAliasDeclarationContext) StringLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserStringLiteral, 0)
}

func (s *ImportAliasDeclarationContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

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

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

func (s *ImportAliasDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterImportAliasDeclaration(s)
	}
}

func (s *ImportAliasDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitImportAliasDeclaration(s)
	}
}

func (p *TypeScriptParser) ImportAliasDeclaration() (localctx IImportAliasDeclarationContext) {
	localctx = NewImportAliasDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, TypeScriptParserRULE_importAliasDeclaration)

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

	defer func() {
		if err := recover(); err != nil {
			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(734)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 73, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(722)
			p.Match(TypeScriptParserIdentifier)
		}
		{
			p.SetState(723)
			p.Match(TypeScriptParserAssign)
		}
		{
			p.SetState(724)
			p.NamespaceName()
		}
		{
			p.SetState(725)
			p.Match(TypeScriptParserSemiColon)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(727)
			p.Match(TypeScriptParserIdentifier)
		}
		{
			p.SetState(728)
			p.Match(TypeScriptParserAssign)
		}
		{
			p.SetState(729)
			p.Match(TypeScriptParserRequire)
		}
		{
			p.SetState(730)
			p.Match(TypeScriptParserOpenParen)
		}
		{
			p.SetState(731)
			p.Match(TypeScriptParserStringLiteral)
		}
		{
			p.SetState(732)
			p.Match(TypeScriptParserCloseParen)
		}
		{
			p.SetState(733)
			p.Match(TypeScriptParserSemiColon)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyImportAllContext() *ImportAllContext {
	var p = new(ImportAllContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_importAll
	return p
}

func (*ImportAllContext) IsImportAllContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_importAll

	return p
}

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

func (s *ImportAllContext) StringLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserStringLiteral, 0)
}

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

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

func (s *ImportAllContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterImportAll(s)
	}
}

func (s *ImportAllContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitImportAll(s)
	}
}

func (p *TypeScriptParser) ImportAll() (localctx IImportAllContext) {
	localctx = NewImportAllContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, TypeScriptParserRULE_importAll)

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

	defer func() {
		if err := recover(); err != nil {
			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(736)
		p.Match(TypeScriptParserStringLiteral)
	}

	return localctx
}

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

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

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

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

func NewEmptyDecoratorListContext() *DecoratorListContext {
	var p = new(DecoratorListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_decoratorList
	return p
}

func (*DecoratorListContext) IsDecoratorListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_decoratorList

	return p
}

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

func (s *DecoratorListContext) AllDecorator() []IDecoratorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDecoratorContext)(nil)).Elem())
	var tst = make([]IDecoratorContext, len(ts))

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

	return tst
}

func (s *DecoratorListContext) Decorator(i int) IDecoratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDecoratorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDecoratorContext)
}

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

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

func (s *DecoratorListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterDecoratorList(s)
	}
}

func (s *DecoratorListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitDecoratorList(s)
	}
}

func (p *TypeScriptParser) DecoratorList() (localctx IDecoratorListContext) {
	localctx = NewDecoratorListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, TypeScriptParserRULE_decoratorList)
	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(739)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == TypeScriptParserAt {
		{
			p.SetState(738)
			p.Decorator()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyDecoratorContext() *DecoratorContext {
	var p = new(DecoratorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_decorator
	return p
}

func (*DecoratorContext) IsDecoratorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_decorator

	return p
}

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

func (s *DecoratorContext) At() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAt, 0)
}

func (s *DecoratorContext) DecoratorMemberExpression() IDecoratorMemberExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDecoratorMemberExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDecoratorMemberExpressionContext)
}

func (s *DecoratorContext) DecoratorCallExpression() IDecoratorCallExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDecoratorCallExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDecoratorCallExpressionContext)
}

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

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

func (s *DecoratorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterDecorator(s)
	}
}

func (s *DecoratorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitDecorator(s)
	}
}

func (p *TypeScriptParser) Decorator() (localctx IDecoratorContext) {
	localctx = NewDecoratorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 112, TypeScriptParserRULE_decorator)

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

	defer func() {
		if err := recover(); err != nil {
			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(743)
		p.Match(TypeScriptParserAt)
	}
	p.SetState(746)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 75, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(744)
			p.decoratorMemberExpression(0)
		}

	case 2:
		{
			p.SetState(745)
			p.DecoratorCallExpression()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyDecoratorMemberExpressionContext() *DecoratorMemberExpressionContext {
	var p = new(DecoratorMemberExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_decoratorMemberExpression
	return p
}

func (*DecoratorMemberExpressionContext) IsDecoratorMemberExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_decoratorMemberExpression

	return p
}

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

func (s *DecoratorMemberExpressionContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *DecoratorMemberExpressionContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *DecoratorMemberExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *DecoratorMemberExpressionContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *DecoratorMemberExpressionContext) DecoratorMemberExpression() IDecoratorMemberExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDecoratorMemberExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDecoratorMemberExpressionContext)
}

func (s *DecoratorMemberExpressionContext) Dot() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDot, 0)
}

func (s *DecoratorMemberExpressionContext) IdentifierName() IIdentifierNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierNameContext)
}

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

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

func (s *DecoratorMemberExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterDecoratorMemberExpression(s)
	}
}

func (s *DecoratorMemberExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitDecoratorMemberExpression(s)
	}
}

func (p *TypeScriptParser) DecoratorMemberExpression() (localctx IDecoratorMemberExpressionContext) {
	return p.decoratorMemberExpression(0)
}

func (p *TypeScriptParser) decoratorMemberExpression(_p int) (localctx IDecoratorMemberExpressionContext) {
	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewDecoratorMemberExpressionContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IDecoratorMemberExpressionContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 114
	p.EnterRecursionRule(localctx, 114, TypeScriptParserRULE_decoratorMemberExpression, _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(754)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserIdentifier:
		{
			p.SetState(749)
			p.Match(TypeScriptParserIdentifier)
		}

	case TypeScriptParserOpenParen:
		{
			p.SetState(750)
			p.Match(TypeScriptParserOpenParen)
		}
		{
			p.SetState(751)
			p.singleExpression(0)
		}
		{
			p.SetState(752)
			p.Match(TypeScriptParserCloseParen)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(761)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 77, p.GetParserRuleContext())

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

			if !(p.Precpred(p.GetParserRuleContext(), 2)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
			}
			{
				p.SetState(757)
				p.Match(TypeScriptParserDot)
			}
			{
				p.SetState(758)
				p.IdentifierName()
			}

		}
		p.SetState(763)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 77, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyDecoratorCallExpressionContext() *DecoratorCallExpressionContext {
	var p = new(DecoratorCallExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_decoratorCallExpression
	return p
}

func (*DecoratorCallExpressionContext) IsDecoratorCallExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_decoratorCallExpression

	return p
}

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

func (s *DecoratorCallExpressionContext) DecoratorMemberExpression() IDecoratorMemberExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDecoratorMemberExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDecoratorMemberExpressionContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IArgumentsContext)
}

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

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

func (s *DecoratorCallExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterDecoratorCallExpression(s)
	}
}

func (s *DecoratorCallExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitDecoratorCallExpression(s)
	}
}

func (p *TypeScriptParser) DecoratorCallExpression() (localctx IDecoratorCallExpressionContext) {
	localctx = NewDecoratorCallExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, TypeScriptParserRULE_decoratorCallExpression)

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

	defer func() {
		if err := recover(); err != nil {
			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(764)
		p.decoratorMemberExpression(0)
	}
	{
		p.SetState(765)
		p.Arguments()
	}

	return localctx
}

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

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

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

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

func NewEmptyProgramContext() *ProgramContext {
	var p = new(ProgramContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_program
	return p
}

func (*ProgramContext) IsProgramContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_program

	return p
}

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

func (s *ProgramContext) EOF() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserEOF, 0)
}

func (s *ProgramContext) SourceElements() ISourceElementsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISourceElementsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISourceElementsContext)
}

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

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

func (s *ProgramContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterProgram(s)
	}
}

func (s *ProgramContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitProgram(s)
	}
}

func (p *TypeScriptParser) Program() (localctx IProgramContext) {
	localctx = NewProgramContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, TypeScriptParserRULE_program)

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

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 78, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(767)
			p.SourceElements()
		}

	}
	{
		p.SetState(770)
		p.Match(TypeScriptParserEOF)
	}

	return localctx
}

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

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

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

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

func NewEmptySourceElementContext() *SourceElementContext {
	var p = new(SourceElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_sourceElement
	return p
}

func (*SourceElementContext) IsSourceElementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_sourceElement

	return p
}

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

func (s *SourceElementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *SourceElementContext) Export() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserExport, 0)
}

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

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

func (s *SourceElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterSourceElement(s)
	}
}

func (s *SourceElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitSourceElement(s)
	}
}

func (p *TypeScriptParser) SourceElement() (localctx ISourceElementContext) {
	localctx = NewSourceElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, TypeScriptParserRULE_sourceElement)

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

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 79, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(772)
			p.Match(TypeScriptParserExport)
		}

	}
	{
		p.SetState(775)
		p.Statement()
	}

	return localctx
}

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

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

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

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

func NewEmptyStatementContext() *StatementContext {
	var p = new(StatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_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 = TypeScriptParserRULE_statement

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IVariableStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IImportStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExportStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IEmptyStatement_Context)
}

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

	if t == nil {
		return nil
	}

	return t.(IAbstractDeclarationContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IClassDeclarationContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IInterfaceDeclarationContext)
}

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

	if t == nil {
		return nil
	}

	return t.(INamespaceDeclarationContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IIfStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IIterationStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IContinueStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IBreakStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IReturnStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IYieldStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IWithStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ILabelledStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ISwitchStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IThrowStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ITryStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IDebuggerStatementContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IFunctionDeclarationContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IArrowFunctionDeclarationContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IGeneratorFunctionDeclarationContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeAliasDeclarationContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IEnumDeclarationContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionStatementContext)
}

func (s *StatementContext) Export() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserExport, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

func (s *StatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitStatement(s)
	}
}

func (p *TypeScriptParser) Statement() (localctx IStatementContext) {
	localctx = NewStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 122, TypeScriptParserRULE_statement)

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

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

	p.SetState(806)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 80, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(777)
			p.Block()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(778)
			p.VariableStatement()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(779)
			p.ImportStatement()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(780)
			p.ExportStatement()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(781)
			p.EmptyStatement_()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(782)
			p.AbstractDeclaration()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(783)
			p.ClassDeclaration()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(784)
			p.InterfaceDeclaration()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(785)
			p.NamespaceDeclaration()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(786)
			p.IfStatement()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(787)
			p.IterationStatement()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(788)
			p.ContinueStatement()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(789)
			p.BreakStatement()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(790)
			p.ReturnStatement()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(791)
			p.YieldStatement()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(792)
			p.WithStatement()
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(793)
			p.LabelledStatement()
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(794)
			p.SwitchStatement()
		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(795)
			p.ThrowStatement()
		}

	case 20:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(796)
			p.TryStatement()
		}

	case 21:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(797)
			p.DebuggerStatement()
		}

	case 22:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(798)
			p.FunctionDeclaration()
		}

	case 23:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(799)
			p.ArrowFunctionDeclaration()
		}

	case 24:
		p.EnterOuterAlt(localctx, 24)
		{
			p.SetState(800)
			p.GeneratorFunctionDeclaration()
		}

	case 25:
		p.EnterOuterAlt(localctx, 25)
		{
			p.SetState(801)
			p.TypeAliasDeclaration()
		}

	case 26:
		p.EnterOuterAlt(localctx, 26)
		{
			p.SetState(802)
			p.EnumDeclaration()
		}

	case 27:
		p.EnterOuterAlt(localctx, 27)
		{
			p.SetState(803)
			p.ExpressionStatement()
		}

	case 28:
		p.EnterOuterAlt(localctx, 28)
		{
			p.SetState(804)
			p.Match(TypeScriptParserExport)
		}
		{
			p.SetState(805)
			p.Statement()
		}

	}

	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 = TypeScriptParserRULE_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 = TypeScriptParserRULE_block

	return p
}

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

func (s *BlockContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *BlockContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *BlockContext) StatementList() IStatementListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementListContext)
}

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

func (s *BlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitBlock(s)
	}
}

func (p *TypeScriptParser) Block() (localctx IBlockContext) {
	localctx = NewBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 124, TypeScriptParserRULE_block)

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

	defer func() {
		if err := recover(); err != nil {
			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(808)
		p.Match(TypeScriptParserOpenBrace)
	}
	p.SetState(810)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 81, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(809)
			p.StatementList()
		}

	}
	{
		p.SetState(812)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

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

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

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

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

func NewEmptyStatementListContext() *StatementListContext {
	var p = new(StatementListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_statementList
	return p
}

func (*StatementListContext) IsStatementListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_statementList

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

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

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

func (s *StatementListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterStatementList(s)
	}
}

func (s *StatementListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitStatementList(s)
	}
}

func (p *TypeScriptParser) StatementList() (localctx IStatementListContext) {
	localctx = NewStatementListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 126, TypeScriptParserRULE_statementList)

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

	defer func() {
		if err := recover(); err != 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(815)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(814)
				p.Statement()
			}

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

		p.SetState(817)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 82, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyAbstractDeclarationContext() *AbstractDeclarationContext {
	var p = new(AbstractDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_abstractDeclaration
	return p
}

func (*AbstractDeclarationContext) IsAbstractDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_abstractDeclaration

	return p
}

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

func (s *AbstractDeclarationContext) Abstract() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAbstract, 0)
}

func (s *AbstractDeclarationContext) Eos() IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

func (s *AbstractDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *AbstractDeclarationContext) CallSignature() ICallSignatureContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICallSignatureContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICallSignatureContext)
}

func (s *AbstractDeclarationContext) VariableStatement() IVariableStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableStatementContext)
}

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

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

func (s *AbstractDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterAbstractDeclaration(s)
	}
}

func (s *AbstractDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitAbstractDeclaration(s)
	}
}

func (p *TypeScriptParser) AbstractDeclaration() (localctx IAbstractDeclarationContext) {
	localctx = NewAbstractDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 128, TypeScriptParserRULE_abstractDeclaration)

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

	defer func() {
		if err := recover(); err != nil {
			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(819)
		p.Match(TypeScriptParserAbstract)
	}
	p.SetState(823)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 83, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(820)
			p.Match(TypeScriptParserIdentifier)
		}
		{
			p.SetState(821)
			p.CallSignature()
		}

	case 2:
		{
			p.SetState(822)
			p.VariableStatement()
		}

	}
	{
		p.SetState(825)
		p.Eos()
	}

	return localctx
}

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

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

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

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

func NewEmptyImportStatementContext() *ImportStatementContext {
	var p = new(ImportStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_importStatement
	return p
}

func (*ImportStatementContext) IsImportStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_importStatement

	return p
}

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

func (s *ImportStatementContext) Import() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserImport, 0)
}

func (s *ImportStatementContext) Eos() IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

func (s *ImportStatementContext) ImportFromBlock() IImportFromBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportFromBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImportFromBlockContext)
}

func (s *ImportStatementContext) ImportAliasDeclaration() IImportAliasDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportAliasDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImportAliasDeclarationContext)
}

func (s *ImportStatementContext) ImportAll() IImportAllContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportAllContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImportAllContext)
}

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

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

func (s *ImportStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterImportStatement(s)
	}
}

func (s *ImportStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitImportStatement(s)
	}
}

func (p *TypeScriptParser) ImportStatement() (localctx IImportStatementContext) {
	localctx = NewImportStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 130, TypeScriptParserRULE_importStatement)

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

	defer func() {
		if err := recover(); err != nil {
			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(827)
		p.Match(TypeScriptParserImport)
	}
	p.SetState(831)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 84, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(828)
			p.ImportFromBlock()
		}

	case 2:
		{
			p.SetState(829)
			p.ImportAliasDeclaration()
		}

	case 3:
		{
			p.SetState(830)
			p.ImportAll()
		}

	}
	{
		p.SetState(833)
		p.Eos()
	}

	return localctx
}

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

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

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

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

func NewEmptyImportFromBlockContext() *ImportFromBlockContext {
	var p = new(ImportFromBlockContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_importFromBlock
	return p
}

func (*ImportFromBlockContext) IsImportFromBlockContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_importFromBlock

	return p
}

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

func (s *ImportFromBlockContext) From() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserFrom, 0)
}

func (s *ImportFromBlockContext) StringLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserStringLiteral, 0)
}

func (s *ImportFromBlockContext) Dollar() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDollar, 0)
}

func (s *ImportFromBlockContext) Lodash() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserLodash, 0)
}

func (s *ImportFromBlockContext) Multiply() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMultiply, 0)
}

func (s *ImportFromBlockContext) MultipleImportStatement() IMultipleImportStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMultipleImportStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMultipleImportStatementContext)
}

func (s *ImportFromBlockContext) AllIdentifierName() []IIdentifierNameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIdentifierNameContext)(nil)).Elem())
	var tst = make([]IIdentifierNameContext, len(ts))

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

	return tst
}

func (s *ImportFromBlockContext) IdentifierName(i int) IIdentifierNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierNameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIdentifierNameContext)
}

func (s *ImportFromBlockContext) As() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAs, 0)
}

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

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

func (s *ImportFromBlockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterImportFromBlock(s)
	}
}

func (s *ImportFromBlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitImportFromBlock(s)
	}
}

func (p *TypeScriptParser) ImportFromBlock() (localctx IImportFromBlockContext) {
	localctx = NewImportFromBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 132, TypeScriptParserRULE_importFromBlock)
	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(840)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 85, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(835)
			p.Match(TypeScriptParserDollar)
		}

	case 2:
		{
			p.SetState(836)
			p.Match(TypeScriptParserLodash)
		}

	case 3:
		{
			p.SetState(837)
			p.Match(TypeScriptParserMultiply)
		}

	case 4:
		{
			p.SetState(838)
			p.MultipleImportStatement()
		}

	case 5:
		{
			p.SetState(839)
			p.IdentifierName()
		}

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

	if _la == TypeScriptParserAs {
		{
			p.SetState(842)
			p.Match(TypeScriptParserAs)
		}
		{
			p.SetState(843)
			p.IdentifierName()
		}

	}
	{
		p.SetState(846)
		p.Match(TypeScriptParserFrom)
	}
	{
		p.SetState(847)
		p.Match(TypeScriptParserStringLiteral)
	}

	return localctx
}

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

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

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

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

func NewEmptyMultipleImportStatementContext() *MultipleImportStatementContext {
	var p = new(MultipleImportStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_multipleImportStatement
	return p
}

func (*MultipleImportStatementContext) IsMultipleImportStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_multipleImportStatement

	return p
}

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

func (s *MultipleImportStatementContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *MultipleImportStatementContext) AllIdentifierName() []IIdentifierNameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIdentifierNameContext)(nil)).Elem())
	var tst = make([]IIdentifierNameContext, len(ts))

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

	return tst
}

func (s *MultipleImportStatementContext) IdentifierName(i int) IIdentifierNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierNameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIdentifierNameContext)
}

func (s *MultipleImportStatementContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *MultipleImportStatementContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *MultipleImportStatementContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

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

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

func (s *MultipleImportStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterMultipleImportStatement(s)
	}
}

func (s *MultipleImportStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitMultipleImportStatement(s)
	}
}

func (p *TypeScriptParser) MultipleImportStatement() (localctx IMultipleImportStatementContext) {
	localctx = NewMultipleImportStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 134, TypeScriptParserRULE_multipleImportStatement)
	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(852)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(TypeScriptParserNullLiteral-61))|(1<<(TypeScriptParserBooleanLiteral-61))|(1<<(TypeScriptParserBreak-61))|(1<<(TypeScriptParserDo-61))|(1<<(TypeScriptParserInstanceof-61))|(1<<(TypeScriptParserTypeof-61))|(1<<(TypeScriptParserCase-61))|(1<<(TypeScriptParserElse-61))|(1<<(TypeScriptParserNew-61))|(1<<(TypeScriptParserVar-61))|(1<<(TypeScriptParserCatch-61))|(1<<(TypeScriptParserFinally-61))|(1<<(TypeScriptParserReturn-61))|(1<<(TypeScriptParserVoid-61))|(1<<(TypeScriptParserContinue-61))|(1<<(TypeScriptParserFor-61))|(1<<(TypeScriptParserSwitch-61))|(1<<(TypeScriptParserWhile-61))|(1<<(TypeScriptParserDebugger-61))|(1<<(TypeScriptParserFunction-61))|(1<<(TypeScriptParserThis-61))|(1<<(TypeScriptParserWith-61))|(1<<(TypeScriptParserDefault-61))|(1<<(TypeScriptParserIf-61))|(1<<(TypeScriptParserThrow-61))|(1<<(TypeScriptParserDelete-61))|(1<<(TypeScriptParserIn-61)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(TypeScriptParserTry-93))|(1<<(TypeScriptParserAs-93))|(1<<(TypeScriptParserFrom-93))|(1<<(TypeScriptParserReadOnly-93))|(1<<(TypeScriptParserAsync-93))|(1<<(TypeScriptParserClass-93))|(1<<(TypeScriptParserEnum-93))|(1<<(TypeScriptParserExtends-93))|(1<<(TypeScriptParserSuper-93))|(1<<(TypeScriptParserConst-93))|(1<<(TypeScriptParserExport-93))|(1<<(TypeScriptParserImport-93))|(1<<(TypeScriptParserAwait-93))|(1<<(TypeScriptParserImplements-93))|(1<<(TypeScriptParserLet-93))|(1<<(TypeScriptParserPrivate-93))|(1<<(TypeScriptParserPublic-93))|(1<<(TypeScriptParserInterface-93))|(1<<(TypeScriptParserPackage-93))|(1<<(TypeScriptParserProtected-93))|(1<<(TypeScriptParserStatic-93))|(1<<(TypeScriptParserYield-93)))) != 0) || _la == TypeScriptParserIdentifier {
		{
			p.SetState(849)
			p.IdentifierName()
		}
		{
			p.SetState(850)
			p.Match(TypeScriptParserComma)
		}

	}
	{
		p.SetState(854)
		p.Match(TypeScriptParserOpenBrace)
	}
	{
		p.SetState(855)
		p.IdentifierName()
	}
	p.SetState(860)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == TypeScriptParserComma {
		{
			p.SetState(856)
			p.Match(TypeScriptParserComma)
		}
		{
			p.SetState(857)
			p.IdentifierName()
		}

		p.SetState(862)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(863)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

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

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

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

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

func NewEmptyExportStatementContext() *ExportStatementContext {
	var p = new(ExportStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_exportStatement
	return p
}

func (*ExportStatementContext) IsExportStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_exportStatement

	return p
}

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

func (s *ExportStatementContext) Export() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserExport, 0)
}

func (s *ExportStatementContext) ImportFromBlock() IImportFromBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportFromBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImportFromBlockContext)
}

func (s *ExportStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *ExportStatementContext) Default() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDefault, 0)
}

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

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

func (s *ExportStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterExportStatement(s)
	}
}

func (s *ExportStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitExportStatement(s)
	}
}

func (p *TypeScriptParser) ExportStatement() (localctx IExportStatementContext) {
	localctx = NewExportStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 136, TypeScriptParserRULE_exportStatement)

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

	defer func() {
		if err := recover(); err != nil {
			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(865)
		p.Match(TypeScriptParserExport)
	}
	p.SetState(867)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 89, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(866)
			p.Match(TypeScriptParserDefault)
		}

	}
	p.SetState(871)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 90, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(869)
			p.ImportFromBlock()
		}

	case 2:
		{
			p.SetState(870)
			p.Statement()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyVariableStatementContext() *VariableStatementContext {
	var p = new(VariableStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_variableStatement
	return p
}

func (*VariableStatementContext) IsVariableStatementContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_variableStatement

	return p
}

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

func (s *VariableStatementContext) BindingPattern() IBindingPatternContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBindingPatternContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBindingPatternContext)
}

func (s *VariableStatementContext) Initializer() IInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitializerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInitializerContext)
}

func (s *VariableStatementContext) TypeAnnotation() ITypeAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAnnotationContext)
}

func (s *VariableStatementContext) SemiColon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, 0)
}

func (s *VariableStatementContext) VariableDeclarationList() IVariableDeclarationListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclarationListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclarationListContext)
}

func (s *VariableStatementContext) AccessibilityModifier() IAccessibilityModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAccessibilityModifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAccessibilityModifierContext)
}

func (s *VariableStatementContext) VarModifier() IVarModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVarModifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVarModifierContext)
}

func (s *VariableStatementContext) ReadOnly() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserReadOnly, 0)
}

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

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

func (s *VariableStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterVariableStatement(s)
	}
}

func (s *VariableStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitVariableStatement(s)
	}
}

func (p *TypeScriptParser) VariableStatement() (localctx IVariableStatementContext) {
	localctx = NewVariableStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 138, TypeScriptParserRULE_variableStatement)
	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(894)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 97, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(873)
			p.BindingPattern()
		}
		p.SetState(875)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserColon {
			{
				p.SetState(874)
				p.TypeAnnotation()
			}

		}
		{
			p.SetState(877)
			p.Initializer()
		}
		p.SetState(879)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 92, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(878)
				p.Match(TypeScriptParserSemiColon)
			}

		}

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

		if ((_la-108)&-(0x1f+1)) == 0 && ((1<<uint((_la-108)))&((1<<(TypeScriptParserPrivate-108))|(1<<(TypeScriptParserPublic-108))|(1<<(TypeScriptParserProtected-108)))) != 0 {
			{
				p.SetState(881)
				p.AccessibilityModifier()
			}

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

		if _la == TypeScriptParserVar || _la == TypeScriptParserConst || _la == TypeScriptParserLet {
			{
				p.SetState(884)
				p.VarModifier()
			}

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

		if _la == TypeScriptParserReadOnly {
			{
				p.SetState(887)
				p.Match(TypeScriptParserReadOnly)
			}

		}
		{
			p.SetState(890)
			p.VariableDeclarationList()
		}
		p.SetState(892)
		p.GetErrorHandler().Sync(p)

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

		}

	}

	return localctx
}

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

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

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

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

func NewEmptyVariableDeclarationListContext() *VariableDeclarationListContext {
	var p = new(VariableDeclarationListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_variableDeclarationList
	return p
}

func (*VariableDeclarationListContext) IsVariableDeclarationListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_variableDeclarationList

	return p
}

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

func (s *VariableDeclarationListContext) AllVariableDeclaration() []IVariableDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IVariableDeclarationContext)(nil)).Elem())
	var tst = make([]IVariableDeclarationContext, len(ts))

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

	return tst
}

func (s *VariableDeclarationListContext) VariableDeclaration(i int) IVariableDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclarationContext)
}

func (s *VariableDeclarationListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *VariableDeclarationListContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

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

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

func (s *VariableDeclarationListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterVariableDeclarationList(s)
	}
}

func (s *VariableDeclarationListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitVariableDeclarationList(s)
	}
}

func (p *TypeScriptParser) VariableDeclarationList() (localctx IVariableDeclarationListContext) {
	localctx = NewVariableDeclarationListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 140, TypeScriptParserRULE_variableDeclarationList)

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

	defer func() {
		if err := recover(); err != 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(896)
		p.VariableDeclaration()
	}
	p.SetState(901)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 98, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(897)
				p.Match(TypeScriptParserComma)
			}
			{
				p.SetState(898)
				p.VariableDeclaration()
			}

		}
		p.SetState(903)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 98, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyVariableDeclarationContext() *VariableDeclarationContext {
	var p = new(VariableDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_variableDeclaration
	return p
}

func (*VariableDeclarationContext) IsVariableDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_variableDeclaration

	return p
}

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

func (s *VariableDeclarationContext) Assignable() IAssignableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignableContext)
}

func (s *VariableDeclarationContext) TypeAnnotation() ITypeAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAnnotationContext)
}

func (s *VariableDeclarationContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

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

	return tst
}

func (s *VariableDeclarationContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *VariableDeclarationContext) Assign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAssign, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeParametersContext)
}

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

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

func (s *VariableDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterVariableDeclaration(s)
	}
}

func (s *VariableDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitVariableDeclaration(s)
	}
}

func (p *TypeScriptParser) VariableDeclaration() (localctx IVariableDeclarationContext) {
	localctx = NewVariableDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 142, TypeScriptParserRULE_variableDeclaration)

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

	defer func() {
		if err := recover(); err != nil {
			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(904)
		p.Assignable()
	}
	p.SetState(906)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 99, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(905)
			p.TypeAnnotation()
		}

	}
	p.SetState(909)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 100, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(908)
			p.singleExpression(0)
		}

	}
	p.SetState(916)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 102, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(911)
			p.Match(TypeScriptParserAssign)
		}
		p.SetState(913)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 101, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(912)
				p.TypeParameters()
			}

		}
		{
			p.SetState(915)
			p.singleExpression(0)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyEmptyStatement_Context() *EmptyStatement_Context {
	var p = new(EmptyStatement_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_emptyStatement_
	return p
}

func (*EmptyStatement_Context) IsEmptyStatement_Context() {}

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

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

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_emptyStatement_

	return p
}

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

func (s *EmptyStatement_Context) SemiColon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, 0)
}

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

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

func (s *EmptyStatement_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterEmptyStatement_(s)
	}
}

func (s *EmptyStatement_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitEmptyStatement_(s)
	}
}

func (p *TypeScriptParser) EmptyStatement_() (localctx IEmptyStatement_Context) {
	localctx = NewEmptyStatement_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 144, TypeScriptParserRULE_emptyStatement_)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(918)
		p.Match(TypeScriptParserSemiColon)
	}

	return localctx
}

// IExpressionStatementContext is an interface to support dynamic dispatch.
type IExpressionStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExpressionStatementContext differentiates from other interfaces.
	IsExpressionStatementContext()
}

type ExpressionStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExpressionStatementContext() *ExpressionStatementContext {
	var p = new(ExpressionStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_expressionStatement
	return p
}

func (*ExpressionStatementContext) IsExpressionStatementContext() {}

func NewExpressionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionStatementContext {
	var p = new(ExpressionStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_expressionStatement

	return p
}

func (s *ExpressionStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *ExpressionStatementContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *ExpressionStatementContext) SemiColon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, 0)
}

func (s *ExpressionStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExpressionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExpressionStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterExpressionStatement(s)
	}
}

func (s *ExpressionStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitExpressionStatement(s)
	}
}

func (p *TypeScriptParser) ExpressionStatement() (localctx IExpressionStatementContext) {
	localctx = NewExpressionStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 146, TypeScriptParserRULE_expressionStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(920)

	if !(p.notOpenBraceAndNotFunction()) {
		panic(antlr.NewFailedPredicateException(p, "p.notOpenBraceAndNotFunction()", ""))
	}
	{
		p.SetState(921)
		p.ExpressionSequence()
	}
	p.SetState(923)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 103, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(922)
			p.Match(TypeScriptParserSemiColon)
		}

	}

	return localctx
}

// IIfStatementContext is an interface to support dynamic dispatch.
type IIfStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIfStatementContext differentiates from other interfaces.
	IsIfStatementContext()
}

type IfStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIfStatementContext() *IfStatementContext {
	var p = new(IfStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_ifStatement
	return p
}

func (*IfStatementContext) IsIfStatementContext() {}

func NewIfStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfStatementContext {
	var p = new(IfStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_ifStatement

	return p
}

func (s *IfStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *IfStatementContext) If() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIf, 0)
}

func (s *IfStatementContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *IfStatementContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *IfStatementContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *IfStatementContext) 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 *IfStatementContext) Statement(i int) IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *IfStatementContext) Else() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserElse, 0)
}

func (s *IfStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IfStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IfStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterIfStatement(s)
	}
}

func (s *IfStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitIfStatement(s)
	}
}

func (p *TypeScriptParser) IfStatement() (localctx IIfStatementContext) {
	localctx = NewIfStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 148, TypeScriptParserRULE_ifStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(925)
		p.Match(TypeScriptParserIf)
	}
	{
		p.SetState(926)
		p.Match(TypeScriptParserOpenParen)
	}
	{
		p.SetState(927)
		p.ExpressionSequence()
	}
	{
		p.SetState(928)
		p.Match(TypeScriptParserCloseParen)
	}
	{
		p.SetState(929)
		p.Statement()
	}
	p.SetState(932)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 104, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(930)
			p.Match(TypeScriptParserElse)
		}
		{
			p.SetState(931)
			p.Statement()
		}

	}

	return localctx
}

// IIterationStatementContext is an interface to support dynamic dispatch.
type IIterationStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIterationStatementContext differentiates from other interfaces.
	IsIterationStatementContext()
}

type IterationStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIterationStatementContext() *IterationStatementContext {
	var p = new(IterationStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_iterationStatement
	return p
}

func (*IterationStatementContext) IsIterationStatementContext() {}

func NewIterationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IterationStatementContext {
	var p = new(IterationStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_iterationStatement

	return p
}

func (s *IterationStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *IterationStatementContext) CopyFrom(ctx *IterationStatementContext) {
	s.BaseParserRuleContext.CopyFrom(ctx.BaseParserRuleContext)
}

func (s *IterationStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IterationStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

type DoStatementContext struct {
	*IterationStatementContext
}

func NewDoStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DoStatementContext {
	var p = new(DoStatementContext)

	p.IterationStatementContext = NewEmptyIterationStatementContext()
	p.parser = parser
	p.CopyFrom(ctx.(*IterationStatementContext))

	return p
}

func (s *DoStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DoStatementContext) Do() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDo, 0)
}

func (s *DoStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *DoStatementContext) While() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserWhile, 0)
}

func (s *DoStatementContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *DoStatementContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *DoStatementContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *DoStatementContext) Eos() IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

func (s *DoStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterDoStatement(s)
	}
}

func (s *DoStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitDoStatement(s)
	}
}

type ForVarStatementContext struct {
	*IterationStatementContext
}

func NewForVarStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForVarStatementContext {
	var p = new(ForVarStatementContext)

	p.IterationStatementContext = NewEmptyIterationStatementContext()
	p.parser = parser
	p.CopyFrom(ctx.(*IterationStatementContext))

	return p
}

func (s *ForVarStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ForVarStatementContext) For() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserFor, 0)
}

func (s *ForVarStatementContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *ForVarStatementContext) VarModifier() IVarModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVarModifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVarModifierContext)
}

func (s *ForVarStatementContext) VariableDeclarationList() IVariableDeclarationListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclarationListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclarationListContext)
}

func (s *ForVarStatementContext) AllSemiColon() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserSemiColon)
}

func (s *ForVarStatementContext) SemiColon(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, i)
}

func (s *ForVarStatementContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *ForVarStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *ForVarStatementContext) AllExpressionSequence() []IExpressionSequenceContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem())
	var tst = make([]IExpressionSequenceContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IExpressionSequenceContext)
		}
	}

	return tst
}

func (s *ForVarStatementContext) ExpressionSequence(i int) IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *ForVarStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterForVarStatement(s)
	}
}

func (s *ForVarStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitForVarStatement(s)
	}
}

type ForVarInStatementContext struct {
	*IterationStatementContext
}

func NewForVarInStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForVarInStatementContext {
	var p = new(ForVarInStatementContext)

	p.IterationStatementContext = NewEmptyIterationStatementContext()
	p.parser = parser
	p.CopyFrom(ctx.(*IterationStatementContext))

	return p
}

func (s *ForVarInStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ForVarInStatementContext) For() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserFor, 0)
}

func (s *ForVarInStatementContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *ForVarInStatementContext) VarModifier() IVarModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVarModifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVarModifierContext)
}

func (s *ForVarInStatementContext) VariableDeclaration() IVariableDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariableDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariableDeclarationContext)
}

func (s *ForVarInStatementContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *ForVarInStatementContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *ForVarInStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *ForVarInStatementContext) In() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIn, 0)
}

func (s *ForVarInStatementContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *ForVarInStatementContext) Await() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAwait, 0)
}

func (s *ForVarInStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterForVarInStatement(s)
	}
}

func (s *ForVarInStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitForVarInStatement(s)
	}
}

type WhileStatementContext struct {
	*IterationStatementContext
}

func NewWhileStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WhileStatementContext {
	var p = new(WhileStatementContext)

	p.IterationStatementContext = NewEmptyIterationStatementContext()
	p.parser = parser
	p.CopyFrom(ctx.(*IterationStatementContext))

	return p
}

func (s *WhileStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *WhileStatementContext) While() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserWhile, 0)
}

func (s *WhileStatementContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *WhileStatementContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *WhileStatementContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *WhileStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *WhileStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterWhileStatement(s)
	}
}

func (s *WhileStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitWhileStatement(s)
	}
}

type ForStatementContext struct {
	*IterationStatementContext
}

func NewForStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForStatementContext {
	var p = new(ForStatementContext)

	p.IterationStatementContext = NewEmptyIterationStatementContext()
	p.parser = parser
	p.CopyFrom(ctx.(*IterationStatementContext))

	return p
}

func (s *ForStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ForStatementContext) For() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserFor, 0)
}

func (s *ForStatementContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *ForStatementContext) AllSemiColon() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserSemiColon)
}

func (s *ForStatementContext) SemiColon(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, i)
}

func (s *ForStatementContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *ForStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *ForStatementContext) AllExpressionSequence() []IExpressionSequenceContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem())
	var tst = make([]IExpressionSequenceContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IExpressionSequenceContext)
		}
	}

	return tst
}

func (s *ForStatementContext) ExpressionSequence(i int) IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *ForStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterForStatement(s)
	}
}

func (s *ForStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitForStatement(s)
	}
}

type ForInStatementContext struct {
	*IterationStatementContext
}

func NewForInStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ForInStatementContext {
	var p = new(ForInStatementContext)

	p.IterationStatementContext = NewEmptyIterationStatementContext()
	p.parser = parser
	p.CopyFrom(ctx.(*IterationStatementContext))

	return p
}

func (s *ForInStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ForInStatementContext) For() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserFor, 0)
}

func (s *ForInStatementContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *ForInStatementContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *ForInStatementContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *ForInStatementContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *ForInStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *ForInStatementContext) In() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIn, 0)
}

func (s *ForInStatementContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *ForInStatementContext) Await() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAwait, 0)
}

func (s *ForInStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterForInStatement(s)
	}
}

func (s *ForInStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitForInStatement(s)
	}
}

func (p *TypeScriptParser) IterationStatement() (localctx IIterationStatementContext) {
	localctx = NewIterationStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 150, TypeScriptParserRULE_iterationStatement)
	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(1009)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 114, p.GetParserRuleContext()) {
	case 1:
		localctx = NewDoStatementContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(934)
			p.Match(TypeScriptParserDo)
		}
		{
			p.SetState(935)
			p.Statement()
		}
		{
			p.SetState(936)
			p.Match(TypeScriptParserWhile)
		}
		{
			p.SetState(937)
			p.Match(TypeScriptParserOpenParen)
		}
		{
			p.SetState(938)
			p.ExpressionSequence()
		}
		{
			p.SetState(939)
			p.Match(TypeScriptParserCloseParen)
		}
		{
			p.SetState(940)
			p.Eos()
		}

	case 2:
		localctx = NewWhileStatementContext(p, localctx)
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(942)
			p.Match(TypeScriptParserWhile)
		}
		{
			p.SetState(943)
			p.Match(TypeScriptParserOpenParen)
		}
		{
			p.SetState(944)
			p.ExpressionSequence()
		}
		{
			p.SetState(945)
			p.Match(TypeScriptParserCloseParen)
		}
		{
			p.SetState(946)
			p.Statement()
		}

	case 3:
		localctx = NewForStatementContext(p, localctx)
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(948)
			p.Match(TypeScriptParserFor)
		}
		{
			p.SetState(949)
			p.Match(TypeScriptParserOpenParen)
		}
		p.SetState(951)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la-4)&-(0x1f+1)) == 0 && ((1<<uint((_la-4)))&((1<<(TypeScriptParserRegularExpressionLiteral-4))|(1<<(TypeScriptParserOpenBracket-4))|(1<<(TypeScriptParserOpenParen-4))|(1<<(TypeScriptParserOpenBrace-4))|(1<<(TypeScriptParserPlusPlus-4))|(1<<(TypeScriptParserMinusMinus-4))|(1<<(TypeScriptParserPlus-4))|(1<<(TypeScriptParserMinus-4))|(1<<(TypeScriptParserBitNot-4))|(1<<(TypeScriptParserNot-4))|(1<<(TypeScriptParserLessThan-4)))) != 0) || (((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(TypeScriptParserNullLiteral-61))|(1<<(TypeScriptParserBooleanLiteral-61))|(1<<(TypeScriptParserDecimalLiteral-61))|(1<<(TypeScriptParserHexIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral2-61))|(1<<(TypeScriptParserBinaryIntegerLiteral-61))|(1<<(TypeScriptParserBreak-61))|(1<<(TypeScriptParserDo-61))|(1<<(TypeScriptParserInstanceof-61))|(1<<(TypeScriptParserTypeof-61))|(1<<(TypeScriptParserCase-61))|(1<<(TypeScriptParserElse-61))|(1<<(TypeScriptParserNew-61))|(1<<(TypeScriptParserVar-61))|(1<<(TypeScriptParserCatch-61))|(1<<(TypeScriptParserFinally-61))|(1<<(TypeScriptParserReturn-61))|(1<<(TypeScriptParserVoid-61))|(1<<(TypeScriptParserContinue-61))|(1<<(TypeScriptParserFor-61))|(1<<(TypeScriptParserSwitch-61))|(1<<(TypeScriptParserWhile-61))|(1<<(TypeScriptParserDebugger-61))|(1<<(TypeScriptParserFunction-61))|(1<<(TypeScriptParserThis-61))|(1<<(TypeScriptParserWith-61))|(1<<(TypeScriptParserDefault-61))|(1<<(TypeScriptParserIf-61))|(1<<(TypeScriptParserThrow-61))|(1<<(TypeScriptParserDelete-61))|(1<<(TypeScriptParserIn-61)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(TypeScriptParserTry-93))|(1<<(TypeScriptParserAs-93))|(1<<(TypeScriptParserFrom-93))|(1<<(TypeScriptParserReadOnly-93))|(1<<(TypeScriptParserAsync-93))|(1<<(TypeScriptParserClass-93))|(1<<(TypeScriptParserEnum-93))|(1<<(TypeScriptParserExtends-93))|(1<<(TypeScriptParserSuper-93))|(1<<(TypeScriptParserConst-93))|(1<<(TypeScriptParserExport-93))|(1<<(TypeScriptParserImport-93))|(1<<(TypeScriptParserAwait-93))|(1<<(TypeScriptParserImplements-93))|(1<<(TypeScriptParserLet-93))|(1<<(TypeScriptParserPrivate-93))|(1<<(TypeScriptParserPublic-93))|(1<<(TypeScriptParserInterface-93))|(1<<(TypeScriptParserPackage-93))|(1<<(TypeScriptParserProtected-93))|(1<<(TypeScriptParserStatic-93))|(1<<(TypeScriptParserYield-93)))) != 0) || (((_la-131)&-(0x1f+1)) == 0 && ((1<<uint((_la-131)))&((1<<(TypeScriptParserIdentifier-131))|(1<<(TypeScriptParserStringLiteral-131))|(1<<(TypeScriptParserTemplateStringLiteral-131)))) != 0) {
			{
				p.SetState(950)
				p.ExpressionSequence()
			}

		}
		{
			p.SetState(953)
			p.Match(TypeScriptParserSemiColon)
		}
		p.SetState(955)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la-4)&-(0x1f+1)) == 0 && ((1<<uint((_la-4)))&((1<<(TypeScriptParserRegularExpressionLiteral-4))|(1<<(TypeScriptParserOpenBracket-4))|(1<<(TypeScriptParserOpenParen-4))|(1<<(TypeScriptParserOpenBrace-4))|(1<<(TypeScriptParserPlusPlus-4))|(1<<(TypeScriptParserMinusMinus-4))|(1<<(TypeScriptParserPlus-4))|(1<<(TypeScriptParserMinus-4))|(1<<(TypeScriptParserBitNot-4))|(1<<(TypeScriptParserNot-4))|(1<<(TypeScriptParserLessThan-4)))) != 0) || (((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(TypeScriptParserNullLiteral-61))|(1<<(TypeScriptParserBooleanLiteral-61))|(1<<(TypeScriptParserDecimalLiteral-61))|(1<<(TypeScriptParserHexIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral2-61))|(1<<(TypeScriptParserBinaryIntegerLiteral-61))|(1<<(TypeScriptParserBreak-61))|(1<<(TypeScriptParserDo-61))|(1<<(TypeScriptParserInstanceof-61))|(1<<(TypeScriptParserTypeof-61))|(1<<(TypeScriptParserCase-61))|(1<<(TypeScriptParserElse-61))|(1<<(TypeScriptParserNew-61))|(1<<(TypeScriptParserVar-61))|(1<<(TypeScriptParserCatch-61))|(1<<(TypeScriptParserFinally-61))|(1<<(TypeScriptParserReturn-61))|(1<<(TypeScriptParserVoid-61))|(1<<(TypeScriptParserContinue-61))|(1<<(TypeScriptParserFor-61))|(1<<(TypeScriptParserSwitch-61))|(1<<(TypeScriptParserWhile-61))|(1<<(TypeScriptParserDebugger-61))|(1<<(TypeScriptParserFunction-61))|(1<<(TypeScriptParserThis-61))|(1<<(TypeScriptParserWith-61))|(1<<(TypeScriptParserDefault-61))|(1<<(TypeScriptParserIf-61))|(1<<(TypeScriptParserThrow-61))|(1<<(TypeScriptParserDelete-61))|(1<<(TypeScriptParserIn-61)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(TypeScriptParserTry-93))|(1<<(TypeScriptParserAs-93))|(1<<(TypeScriptParserFrom-93))|(1<<(TypeScriptParserReadOnly-93))|(1<<(TypeScriptParserAsync-93))|(1<<(TypeScriptParserClass-93))|(1<<(TypeScriptParserEnum-93))|(1<<(TypeScriptParserExtends-93))|(1<<(TypeScriptParserSuper-93))|(1<<(TypeScriptParserConst-93))|(1<<(TypeScriptParserExport-93))|(1<<(TypeScriptParserImport-93))|(1<<(TypeScriptParserAwait-93))|(1<<(TypeScriptParserImplements-93))|(1<<(TypeScriptParserLet-93))|(1<<(TypeScriptParserPrivate-93))|(1<<(TypeScriptParserPublic-93))|(1<<(TypeScriptParserInterface-93))|(1<<(TypeScriptParserPackage-93))|(1<<(TypeScriptParserProtected-93))|(1<<(TypeScriptParserStatic-93))|(1<<(TypeScriptParserYield-93)))) != 0) || (((_la-131)&-(0x1f+1)) == 0 && ((1<<uint((_la-131)))&((1<<(TypeScriptParserIdentifier-131))|(1<<(TypeScriptParserStringLiteral-131))|(1<<(TypeScriptParserTemplateStringLiteral-131)))) != 0) {
			{
				p.SetState(954)
				p.ExpressionSequence()
			}

		}
		{
			p.SetState(957)
			p.Match(TypeScriptParserSemiColon)
		}
		p.SetState(959)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la-4)&-(0x1f+1)) == 0 && ((1<<uint((_la-4)))&((1<<(TypeScriptParserRegularExpressionLiteral-4))|(1<<(TypeScriptParserOpenBracket-4))|(1<<(TypeScriptParserOpenParen-4))|(1<<(TypeScriptParserOpenBrace-4))|(1<<(TypeScriptParserPlusPlus-4))|(1<<(TypeScriptParserMinusMinus-4))|(1<<(TypeScriptParserPlus-4))|(1<<(TypeScriptParserMinus-4))|(1<<(TypeScriptParserBitNot-4))|(1<<(TypeScriptParserNot-4))|(1<<(TypeScriptParserLessThan-4)))) != 0) || (((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(TypeScriptParserNullLiteral-61))|(1<<(TypeScriptParserBooleanLiteral-61))|(1<<(TypeScriptParserDecimalLiteral-61))|(1<<(TypeScriptParserHexIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral2-61))|(1<<(TypeScriptParserBinaryIntegerLiteral-61))|(1<<(TypeScriptParserBreak-61))|(1<<(TypeScriptParserDo-61))|(1<<(TypeScriptParserInstanceof-61))|(1<<(TypeScriptParserTypeof-61))|(1<<(TypeScriptParserCase-61))|(1<<(TypeScriptParserElse-61))|(1<<(TypeScriptParserNew-61))|(1<<(TypeScriptParserVar-61))|(1<<(TypeScriptParserCatch-61))|(1<<(TypeScriptParserFinally-61))|(1<<(TypeScriptParserReturn-61))|(1<<(TypeScriptParserVoid-61))|(1<<(TypeScriptParserContinue-61))|(1<<(TypeScriptParserFor-61))|(1<<(TypeScriptParserSwitch-61))|(1<<(TypeScriptParserWhile-61))|(1<<(TypeScriptParserDebugger-61))|(1<<(TypeScriptParserFunction-61))|(1<<(TypeScriptParserThis-61))|(1<<(TypeScriptParserWith-61))|(1<<(TypeScriptParserDefault-61))|(1<<(TypeScriptParserIf-61))|(1<<(TypeScriptParserThrow-61))|(1<<(TypeScriptParserDelete-61))|(1<<(TypeScriptParserIn-61)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(TypeScriptParserTry-93))|(1<<(TypeScriptParserAs-93))|(1<<(TypeScriptParserFrom-93))|(1<<(TypeScriptParserReadOnly-93))|(1<<(TypeScriptParserAsync-93))|(1<<(TypeScriptParserClass-93))|(1<<(TypeScriptParserEnum-93))|(1<<(TypeScriptParserExtends-93))|(1<<(TypeScriptParserSuper-93))|(1<<(TypeScriptParserConst-93))|(1<<(TypeScriptParserExport-93))|(1<<(TypeScriptParserImport-93))|(1<<(TypeScriptParserAwait-93))|(1<<(TypeScriptParserImplements-93))|(1<<(TypeScriptParserLet-93))|(1<<(TypeScriptParserPrivate-93))|(1<<(TypeScriptParserPublic-93))|(1<<(TypeScriptParserInterface-93))|(1<<(TypeScriptParserPackage-93))|(1<<(TypeScriptParserProtected-93))|(1<<(TypeScriptParserStatic-93))|(1<<(TypeScriptParserYield-93)))) != 0) || (((_la-131)&-(0x1f+1)) == 0 && ((1<<uint((_la-131)))&((1<<(TypeScriptParserIdentifier-131))|(1<<(TypeScriptParserStringLiteral-131))|(1<<(TypeScriptParserTemplateStringLiteral-131)))) != 0) {
			{
				p.SetState(958)
				p.ExpressionSequence()
			}

		}
		{
			p.SetState(961)
			p.Match(TypeScriptParserCloseParen)
		}
		{
			p.SetState(962)
			p.Statement()
		}

	case 4:
		localctx = NewForVarStatementContext(p, localctx)
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(963)
			p.Match(TypeScriptParserFor)
		}
		{
			p.SetState(964)
			p.Match(TypeScriptParserOpenParen)
		}
		{
			p.SetState(965)
			p.VarModifier()
		}
		{
			p.SetState(966)
			p.VariableDeclarationList()
		}
		{
			p.SetState(967)
			p.Match(TypeScriptParserSemiColon)
		}
		p.SetState(969)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la-4)&-(0x1f+1)) == 0 && ((1<<uint((_la-4)))&((1<<(TypeScriptParserRegularExpressionLiteral-4))|(1<<(TypeScriptParserOpenBracket-4))|(1<<(TypeScriptParserOpenParen-4))|(1<<(TypeScriptParserOpenBrace-4))|(1<<(TypeScriptParserPlusPlus-4))|(1<<(TypeScriptParserMinusMinus-4))|(1<<(TypeScriptParserPlus-4))|(1<<(TypeScriptParserMinus-4))|(1<<(TypeScriptParserBitNot-4))|(1<<(TypeScriptParserNot-4))|(1<<(TypeScriptParserLessThan-4)))) != 0) || (((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(TypeScriptParserNullLiteral-61))|(1<<(TypeScriptParserBooleanLiteral-61))|(1<<(TypeScriptParserDecimalLiteral-61))|(1<<(TypeScriptParserHexIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral2-61))|(1<<(TypeScriptParserBinaryIntegerLiteral-61))|(1<<(TypeScriptParserBreak-61))|(1<<(TypeScriptParserDo-61))|(1<<(TypeScriptParserInstanceof-61))|(1<<(TypeScriptParserTypeof-61))|(1<<(TypeScriptParserCase-61))|(1<<(TypeScriptParserElse-61))|(1<<(TypeScriptParserNew-61))|(1<<(TypeScriptParserVar-61))|(1<<(TypeScriptParserCatch-61))|(1<<(TypeScriptParserFinally-61))|(1<<(TypeScriptParserReturn-61))|(1<<(TypeScriptParserVoid-61))|(1<<(TypeScriptParserContinue-61))|(1<<(TypeScriptParserFor-61))|(1<<(TypeScriptParserSwitch-61))|(1<<(TypeScriptParserWhile-61))|(1<<(TypeScriptParserDebugger-61))|(1<<(TypeScriptParserFunction-61))|(1<<(TypeScriptParserThis-61))|(1<<(TypeScriptParserWith-61))|(1<<(TypeScriptParserDefault-61))|(1<<(TypeScriptParserIf-61))|(1<<(TypeScriptParserThrow-61))|(1<<(TypeScriptParserDelete-61))|(1<<(TypeScriptParserIn-61)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(TypeScriptParserTry-93))|(1<<(TypeScriptParserAs-93))|(1<<(TypeScriptParserFrom-93))|(1<<(TypeScriptParserReadOnly-93))|(1<<(TypeScriptParserAsync-93))|(1<<(TypeScriptParserClass-93))|(1<<(TypeScriptParserEnum-93))|(1<<(TypeScriptParserExtends-93))|(1<<(TypeScriptParserSuper-93))|(1<<(TypeScriptParserConst-93))|(1<<(TypeScriptParserExport-93))|(1<<(TypeScriptParserImport-93))|(1<<(TypeScriptParserAwait-93))|(1<<(TypeScriptParserImplements-93))|(1<<(TypeScriptParserLet-93))|(1<<(TypeScriptParserPrivate-93))|(1<<(TypeScriptParserPublic-93))|(1<<(TypeScriptParserInterface-93))|(1<<(TypeScriptParserPackage-93))|(1<<(TypeScriptParserProtected-93))|(1<<(TypeScriptParserStatic-93))|(1<<(TypeScriptParserYield-93)))) != 0) || (((_la-131)&-(0x1f+1)) == 0 && ((1<<uint((_la-131)))&((1<<(TypeScriptParserIdentifier-131))|(1<<(TypeScriptParserStringLiteral-131))|(1<<(TypeScriptParserTemplateStringLiteral-131)))) != 0) {
			{
				p.SetState(968)
				p.ExpressionSequence()
			}

		}
		{
			p.SetState(971)
			p.Match(TypeScriptParserSemiColon)
		}
		p.SetState(973)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la-4)&-(0x1f+1)) == 0 && ((1<<uint((_la-4)))&((1<<(TypeScriptParserRegularExpressionLiteral-4))|(1<<(TypeScriptParserOpenBracket-4))|(1<<(TypeScriptParserOpenParen-4))|(1<<(TypeScriptParserOpenBrace-4))|(1<<(TypeScriptParserPlusPlus-4))|(1<<(TypeScriptParserMinusMinus-4))|(1<<(TypeScriptParserPlus-4))|(1<<(TypeScriptParserMinus-4))|(1<<(TypeScriptParserBitNot-4))|(1<<(TypeScriptParserNot-4))|(1<<(TypeScriptParserLessThan-4)))) != 0) || (((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(TypeScriptParserNullLiteral-61))|(1<<(TypeScriptParserBooleanLiteral-61))|(1<<(TypeScriptParserDecimalLiteral-61))|(1<<(TypeScriptParserHexIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral2-61))|(1<<(TypeScriptParserBinaryIntegerLiteral-61))|(1<<(TypeScriptParserBreak-61))|(1<<(TypeScriptParserDo-61))|(1<<(TypeScriptParserInstanceof-61))|(1<<(TypeScriptParserTypeof-61))|(1<<(TypeScriptParserCase-61))|(1<<(TypeScriptParserElse-61))|(1<<(TypeScriptParserNew-61))|(1<<(TypeScriptParserVar-61))|(1<<(TypeScriptParserCatch-61))|(1<<(TypeScriptParserFinally-61))|(1<<(TypeScriptParserReturn-61))|(1<<(TypeScriptParserVoid-61))|(1<<(TypeScriptParserContinue-61))|(1<<(TypeScriptParserFor-61))|(1<<(TypeScriptParserSwitch-61))|(1<<(TypeScriptParserWhile-61))|(1<<(TypeScriptParserDebugger-61))|(1<<(TypeScriptParserFunction-61))|(1<<(TypeScriptParserThis-61))|(1<<(TypeScriptParserWith-61))|(1<<(TypeScriptParserDefault-61))|(1<<(TypeScriptParserIf-61))|(1<<(TypeScriptParserThrow-61))|(1<<(TypeScriptParserDelete-61))|(1<<(TypeScriptParserIn-61)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(TypeScriptParserTry-93))|(1<<(TypeScriptParserAs-93))|(1<<(TypeScriptParserFrom-93))|(1<<(TypeScriptParserReadOnly-93))|(1<<(TypeScriptParserAsync-93))|(1<<(TypeScriptParserClass-93))|(1<<(TypeScriptParserEnum-93))|(1<<(TypeScriptParserExtends-93))|(1<<(TypeScriptParserSuper-93))|(1<<(TypeScriptParserConst-93))|(1<<(TypeScriptParserExport-93))|(1<<(TypeScriptParserImport-93))|(1<<(TypeScriptParserAwait-93))|(1<<(TypeScriptParserImplements-93))|(1<<(TypeScriptParserLet-93))|(1<<(TypeScriptParserPrivate-93))|(1<<(TypeScriptParserPublic-93))|(1<<(TypeScriptParserInterface-93))|(1<<(TypeScriptParserPackage-93))|(1<<(TypeScriptParserProtected-93))|(1<<(TypeScriptParserStatic-93))|(1<<(TypeScriptParserYield-93)))) != 0) || (((_la-131)&-(0x1f+1)) == 0 && ((1<<uint((_la-131)))&((1<<(TypeScriptParserIdentifier-131))|(1<<(TypeScriptParserStringLiteral-131))|(1<<(TypeScriptParserTemplateStringLiteral-131)))) != 0) {
			{
				p.SetState(972)
				p.ExpressionSequence()
			}

		}
		{
			p.SetState(975)
			p.Match(TypeScriptParserCloseParen)
		}
		{
			p.SetState(976)
			p.Statement()
		}

	case 5:
		localctx = NewForInStatementContext(p, localctx)
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(978)
			p.Match(TypeScriptParserFor)
		}
		p.SetState(980)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserAwait {
			{
				p.SetState(979)
				p.Match(TypeScriptParserAwait)
			}

		}
		{
			p.SetState(982)
			p.Match(TypeScriptParserOpenParen)
		}
		{
			p.SetState(983)
			p.singleExpression(0)
		}
		p.SetState(987)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case TypeScriptParserIn:
			{
				p.SetState(984)
				p.Match(TypeScriptParserIn)
			}

		case TypeScriptParserIdentifier:
			{
				p.SetState(985)
				p.Match(TypeScriptParserIdentifier)
			}
			p.SetState(986)

			if !(p.p("of")) {
				panic(antlr.NewFailedPredicateException(p, "p.p(\"of\")", ""))
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}
		{
			p.SetState(989)
			p.ExpressionSequence()
		}
		{
			p.SetState(990)
			p.Match(TypeScriptParserCloseParen)
		}
		{
			p.SetState(991)
			p.Statement()
		}

	case 6:
		localctx = NewForVarInStatementContext(p, localctx)
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(993)
			p.Match(TypeScriptParserFor)
		}
		p.SetState(995)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserAwait {
			{
				p.SetState(994)
				p.Match(TypeScriptParserAwait)
			}

		}
		{
			p.SetState(997)
			p.Match(TypeScriptParserOpenParen)
		}
		{
			p.SetState(998)
			p.VarModifier()
		}
		{
			p.SetState(999)
			p.VariableDeclaration()
		}
		p.SetState(1003)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case TypeScriptParserIn:
			{
				p.SetState(1000)
				p.Match(TypeScriptParserIn)
			}

		case TypeScriptParserIdentifier:
			{
				p.SetState(1001)
				p.Match(TypeScriptParserIdentifier)
			}
			p.SetState(1002)

			if !(p.p("of")) {
				panic(antlr.NewFailedPredicateException(p, "p.p(\"of\")", ""))
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}
		{
			p.SetState(1005)
			p.ExpressionSequence()
		}
		{
			p.SetState(1006)
			p.Match(TypeScriptParserCloseParen)
		}
		{
			p.SetState(1007)
			p.Statement()
		}

	}

	return localctx
}

// IVarModifierContext is an interface to support dynamic dispatch.
type IVarModifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsVarModifierContext differentiates from other interfaces.
	IsVarModifierContext()
}

type VarModifierContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyVarModifierContext() *VarModifierContext {
	var p = new(VarModifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_varModifier
	return p
}

func (*VarModifierContext) IsVarModifierContext() {}

func NewVarModifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VarModifierContext {
	var p = new(VarModifierContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_varModifier

	return p
}

func (s *VarModifierContext) GetParser() antlr.Parser { return s.parser }

func (s *VarModifierContext) Var() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserVar, 0)
}

func (s *VarModifierContext) Let() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserLet, 0)
}

func (s *VarModifierContext) Const() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserConst, 0)
}

func (s *VarModifierContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VarModifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *VarModifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterVarModifier(s)
	}
}

func (s *VarModifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitVarModifier(s)
	}
}

func (p *TypeScriptParser) VarModifier() (localctx IVarModifierContext) {
	localctx = NewVarModifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 152, TypeScriptParserRULE_varModifier)
	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(1011)
		_la = p.GetTokenStream().LA(1)

		if !(_la == TypeScriptParserVar || _la == TypeScriptParserConst || _la == TypeScriptParserLet) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IContinueStatementContext is an interface to support dynamic dispatch.
type IContinueStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsContinueStatementContext differentiates from other interfaces.
	IsContinueStatementContext()
}

type ContinueStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyContinueStatementContext() *ContinueStatementContext {
	var p = new(ContinueStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_continueStatement
	return p
}

func (*ContinueStatementContext) IsContinueStatementContext() {}

func NewContinueStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ContinueStatementContext {
	var p = new(ContinueStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_continueStatement

	return p
}

func (s *ContinueStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *ContinueStatementContext) Continue() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserContinue, 0)
}

func (s *ContinueStatementContext) Eos() IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

func (s *ContinueStatementContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *ContinueStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ContinueStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ContinueStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterContinueStatement(s)
	}
}

func (s *ContinueStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitContinueStatement(s)
	}
}

func (p *TypeScriptParser) ContinueStatement() (localctx IContinueStatementContext) {
	localctx = NewContinueStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 154, TypeScriptParserRULE_continueStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(TypeScriptParserContinue)
	}
	p.SetState(1016)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 115, p.GetParserRuleContext()) == 1 {
		p.SetState(1014)

		if !(p.notLineTerminator()) {
			panic(antlr.NewFailedPredicateException(p, "p.notLineTerminator()", ""))
		}
		{
			p.SetState(1015)
			p.Match(TypeScriptParserIdentifier)
		}

	}
	{
		p.SetState(1018)
		p.Eos()
	}

	return localctx
}

// IBreakStatementContext is an interface to support dynamic dispatch.
type IBreakStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBreakStatementContext differentiates from other interfaces.
	IsBreakStatementContext()
}

type BreakStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBreakStatementContext() *BreakStatementContext {
	var p = new(BreakStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_breakStatement
	return p
}

func (*BreakStatementContext) IsBreakStatementContext() {}

func NewBreakStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BreakStatementContext {
	var p = new(BreakStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_breakStatement

	return p
}

func (s *BreakStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *BreakStatementContext) Break() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBreak, 0)
}

func (s *BreakStatementContext) Eos() IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

func (s *BreakStatementContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *BreakStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BreakStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BreakStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterBreakStatement(s)
	}
}

func (s *BreakStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitBreakStatement(s)
	}
}

func (p *TypeScriptParser) BreakStatement() (localctx IBreakStatementContext) {
	localctx = NewBreakStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 156, TypeScriptParserRULE_breakStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1020)
		p.Match(TypeScriptParserBreak)
	}
	p.SetState(1023)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 116, p.GetParserRuleContext()) == 1 {
		p.SetState(1021)

		if !(p.notLineTerminator()) {
			panic(antlr.NewFailedPredicateException(p, "p.notLineTerminator()", ""))
		}
		{
			p.SetState(1022)
			p.Match(TypeScriptParserIdentifier)
		}

	}
	{
		p.SetState(1025)
		p.Eos()
	}

	return localctx
}

// IReturnStatementContext is an interface to support dynamic dispatch.
type IReturnStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsReturnStatementContext differentiates from other interfaces.
	IsReturnStatementContext()
}

type ReturnStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReturnStatementContext() *ReturnStatementContext {
	var p = new(ReturnStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_returnStatement
	return p
}

func (*ReturnStatementContext) IsReturnStatementContext() {}

func NewReturnStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnStatementContext {
	var p = new(ReturnStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_returnStatement

	return p
}

func (s *ReturnStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *ReturnStatementContext) Return() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserReturn, 0)
}

func (s *ReturnStatementContext) Eos() IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

func (s *ReturnStatementContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *ReturnStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ReturnStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ReturnStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterReturnStatement(s)
	}
}

func (s *ReturnStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitReturnStatement(s)
	}
}

func (p *TypeScriptParser) ReturnStatement() (localctx IReturnStatementContext) {
	localctx = NewReturnStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 158, TypeScriptParserRULE_returnStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1027)
		p.Match(TypeScriptParserReturn)
	}
	p.SetState(1030)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 117, p.GetParserRuleContext()) == 1 {
		p.SetState(1028)

		if !(p.notLineTerminator()) {
			panic(antlr.NewFailedPredicateException(p, "p.notLineTerminator()", ""))
		}
		{
			p.SetState(1029)
			p.ExpressionSequence()
		}

	}
	{
		p.SetState(1032)
		p.Eos()
	}

	return localctx
}

// IYieldStatementContext is an interface to support dynamic dispatch.
type IYieldStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsYieldStatementContext differentiates from other interfaces.
	IsYieldStatementContext()
}

type YieldStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyYieldStatementContext() *YieldStatementContext {
	var p = new(YieldStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_yieldStatement
	return p
}

func (*YieldStatementContext) IsYieldStatementContext() {}

func NewYieldStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *YieldStatementContext {
	var p = new(YieldStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_yieldStatement

	return p
}

func (s *YieldStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *YieldStatementContext) Yield() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserYield, 0)
}

func (s *YieldStatementContext) Eos() IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

func (s *YieldStatementContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *YieldStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *YieldStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *YieldStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterYieldStatement(s)
	}
}

func (s *YieldStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitYieldStatement(s)
	}
}

func (p *TypeScriptParser) YieldStatement() (localctx IYieldStatementContext) {
	localctx = NewYieldStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 160, TypeScriptParserRULE_yieldStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1034)
		p.Match(TypeScriptParserYield)
	}
	p.SetState(1037)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 118, p.GetParserRuleContext()) == 1 {
		p.SetState(1035)

		if !(p.notLineTerminator()) {
			panic(antlr.NewFailedPredicateException(p, "p.notLineTerminator()", ""))
		}
		{
			p.SetState(1036)
			p.ExpressionSequence()
		}

	}
	{
		p.SetState(1039)
		p.Eos()
	}

	return localctx
}

// IWithStatementContext is an interface to support dynamic dispatch.
type IWithStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWithStatementContext differentiates from other interfaces.
	IsWithStatementContext()
}

type WithStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWithStatementContext() *WithStatementContext {
	var p = new(WithStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_withStatement
	return p
}

func (*WithStatementContext) IsWithStatementContext() {}

func NewWithStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WithStatementContext {
	var p = new(WithStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_withStatement

	return p
}

func (s *WithStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *WithStatementContext) With() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserWith, 0)
}

func (s *WithStatementContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *WithStatementContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *WithStatementContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *WithStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *WithStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *WithStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *WithStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterWithStatement(s)
	}
}

func (s *WithStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitWithStatement(s)
	}
}

func (p *TypeScriptParser) WithStatement() (localctx IWithStatementContext) {
	localctx = NewWithStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 162, TypeScriptParserRULE_withStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1041)
		p.Match(TypeScriptParserWith)
	}
	{
		p.SetState(1042)
		p.Match(TypeScriptParserOpenParen)
	}
	{
		p.SetState(1043)
		p.ExpressionSequence()
	}
	{
		p.SetState(1044)
		p.Match(TypeScriptParserCloseParen)
	}
	{
		p.SetState(1045)
		p.Statement()
	}

	return localctx
}

// ISwitchStatementContext is an interface to support dynamic dispatch.
type ISwitchStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSwitchStatementContext differentiates from other interfaces.
	IsSwitchStatementContext()
}

type SwitchStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySwitchStatementContext() *SwitchStatementContext {
	var p = new(SwitchStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_switchStatement
	return p
}

func (*SwitchStatementContext) IsSwitchStatementContext() {}

func NewSwitchStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SwitchStatementContext {
	var p = new(SwitchStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_switchStatement

	return p
}

func (s *SwitchStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *SwitchStatementContext) Switch() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSwitch, 0)
}

func (s *SwitchStatementContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *SwitchStatementContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *SwitchStatementContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *SwitchStatementContext) CaseBlock() ICaseBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICaseBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICaseBlockContext)
}

func (s *SwitchStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SwitchStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SwitchStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterSwitchStatement(s)
	}
}

func (s *SwitchStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitSwitchStatement(s)
	}
}

func (p *TypeScriptParser) SwitchStatement() (localctx ISwitchStatementContext) {
	localctx = NewSwitchStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 164, TypeScriptParserRULE_switchStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1047)
		p.Match(TypeScriptParserSwitch)
	}
	{
		p.SetState(1048)
		p.Match(TypeScriptParserOpenParen)
	}
	{
		p.SetState(1049)
		p.ExpressionSequence()
	}
	{
		p.SetState(1050)
		p.Match(TypeScriptParserCloseParen)
	}
	{
		p.SetState(1051)
		p.CaseBlock()
	}

	return localctx
}

// ICaseBlockContext is an interface to support dynamic dispatch.
type ICaseBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCaseBlockContext differentiates from other interfaces.
	IsCaseBlockContext()
}

type CaseBlockContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCaseBlockContext() *CaseBlockContext {
	var p = new(CaseBlockContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_caseBlock
	return p
}

func (*CaseBlockContext) IsCaseBlockContext() {}

func NewCaseBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseBlockContext {
	var p = new(CaseBlockContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_caseBlock

	return p
}

func (s *CaseBlockContext) GetParser() antlr.Parser { return s.parser }

func (s *CaseBlockContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *CaseBlockContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *CaseBlockContext) AllCaseClauses() []ICaseClausesContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICaseClausesContext)(nil)).Elem())
	var tst = make([]ICaseClausesContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ICaseClausesContext)
		}
	}

	return tst
}

func (s *CaseBlockContext) CaseClauses(i int) ICaseClausesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICaseClausesContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICaseClausesContext)
}

func (s *CaseBlockContext) DefaultClause() IDefaultClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDefaultClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDefaultClauseContext)
}

func (s *CaseBlockContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CaseBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CaseBlockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterCaseBlock(s)
	}
}

func (s *CaseBlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitCaseBlock(s)
	}
}

func (p *TypeScriptParser) CaseBlock() (localctx ICaseBlockContext) {
	localctx = NewCaseBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 166, TypeScriptParserRULE_caseBlock)
	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(1053)
		p.Match(TypeScriptParserOpenBrace)
	}
	p.SetState(1055)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserCase {
		{
			p.SetState(1054)
			p.CaseClauses()
		}

	}
	p.SetState(1061)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserDefault {
		{
			p.SetState(1057)
			p.DefaultClause()
		}
		p.SetState(1059)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserCase {
			{
				p.SetState(1058)
				p.CaseClauses()
			}

		}

	}
	{
		p.SetState(1063)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

// ICaseClausesContext is an interface to support dynamic dispatch.
type ICaseClausesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCaseClausesContext differentiates from other interfaces.
	IsCaseClausesContext()
}

type CaseClausesContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCaseClausesContext() *CaseClausesContext {
	var p = new(CaseClausesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_caseClauses
	return p
}

func (*CaseClausesContext) IsCaseClausesContext() {}

func NewCaseClausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseClausesContext {
	var p = new(CaseClausesContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_caseClauses

	return p
}

func (s *CaseClausesContext) GetParser() antlr.Parser { return s.parser }

func (s *CaseClausesContext) AllCaseClause() []ICaseClauseContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICaseClauseContext)(nil)).Elem())
	var tst = make([]ICaseClauseContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ICaseClauseContext)
		}
	}

	return tst
}

func (s *CaseClausesContext) CaseClause(i int) ICaseClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICaseClauseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICaseClauseContext)
}

func (s *CaseClausesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CaseClausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CaseClausesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterCaseClauses(s)
	}
}

func (s *CaseClausesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitCaseClauses(s)
	}
}

func (p *TypeScriptParser) CaseClauses() (localctx ICaseClausesContext) {
	localctx = NewCaseClausesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 168, TypeScriptParserRULE_caseClauses)
	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(1066)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == TypeScriptParserCase {
		{
			p.SetState(1065)
			p.CaseClause()
		}

		p.SetState(1068)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// ICaseClauseContext is an interface to support dynamic dispatch.
type ICaseClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCaseClauseContext differentiates from other interfaces.
	IsCaseClauseContext()
}

type CaseClauseContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCaseClauseContext() *CaseClauseContext {
	var p = new(CaseClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_caseClause
	return p
}

func (*CaseClauseContext) IsCaseClauseContext() {}

func NewCaseClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseClauseContext {
	var p = new(CaseClauseContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_caseClause

	return p
}

func (s *CaseClauseContext) GetParser() antlr.Parser { return s.parser }

func (s *CaseClauseContext) Case() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCase, 0)
}

func (s *CaseClauseContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *CaseClauseContext) Colon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserColon, 0)
}

func (s *CaseClauseContext) StatementList() IStatementListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementListContext)
}

func (s *CaseClauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CaseClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CaseClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterCaseClause(s)
	}
}

func (s *CaseClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitCaseClause(s)
	}
}

func (p *TypeScriptParser) CaseClause() (localctx ICaseClauseContext) {
	localctx = NewCaseClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 170, TypeScriptParserRULE_caseClause)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1070)
		p.Match(TypeScriptParserCase)
	}
	{
		p.SetState(1071)
		p.ExpressionSequence()
	}
	{
		p.SetState(1072)
		p.Match(TypeScriptParserColon)
	}
	p.SetState(1074)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 123, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1073)
			p.StatementList()
		}

	}

	return localctx
}

// IDefaultClauseContext is an interface to support dynamic dispatch.
type IDefaultClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDefaultClauseContext differentiates from other interfaces.
	IsDefaultClauseContext()
}

type DefaultClauseContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDefaultClauseContext() *DefaultClauseContext {
	var p = new(DefaultClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_defaultClause
	return p
}

func (*DefaultClauseContext) IsDefaultClauseContext() {}

func NewDefaultClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefaultClauseContext {
	var p = new(DefaultClauseContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_defaultClause

	return p
}

func (s *DefaultClauseContext) GetParser() antlr.Parser { return s.parser }

func (s *DefaultClauseContext) Default() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDefault, 0)
}

func (s *DefaultClauseContext) Colon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserColon, 0)
}

func (s *DefaultClauseContext) StatementList() IStatementListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementListContext)
}

func (s *DefaultClauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DefaultClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DefaultClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterDefaultClause(s)
	}
}

func (s *DefaultClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitDefaultClause(s)
	}
}

func (p *TypeScriptParser) DefaultClause() (localctx IDefaultClauseContext) {
	localctx = NewDefaultClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 172, TypeScriptParserRULE_defaultClause)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1076)
		p.Match(TypeScriptParserDefault)
	}
	{
		p.SetState(1077)
		p.Match(TypeScriptParserColon)
	}
	p.SetState(1079)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 124, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1078)
			p.StatementList()
		}

	}

	return localctx
}

// ILabelledStatementContext is an interface to support dynamic dispatch.
type ILabelledStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLabelledStatementContext differentiates from other interfaces.
	IsLabelledStatementContext()
}

type LabelledStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLabelledStatementContext() *LabelledStatementContext {
	var p = new(LabelledStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_labelledStatement
	return p
}

func (*LabelledStatementContext) IsLabelledStatementContext() {}

func NewLabelledStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LabelledStatementContext {
	var p = new(LabelledStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_labelledStatement

	return p
}

func (s *LabelledStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *LabelledStatementContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *LabelledStatementContext) Colon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserColon, 0)
}

func (s *LabelledStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *LabelledStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LabelledStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LabelledStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterLabelledStatement(s)
	}
}

func (s *LabelledStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitLabelledStatement(s)
	}
}

func (p *TypeScriptParser) LabelledStatement() (localctx ILabelledStatementContext) {
	localctx = NewLabelledStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 174, TypeScriptParserRULE_labelledStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1081)
		p.Match(TypeScriptParserIdentifier)
	}
	{
		p.SetState(1082)
		p.Match(TypeScriptParserColon)
	}
	{
		p.SetState(1083)
		p.Statement()
	}

	return localctx
}

// IThrowStatementContext is an interface to support dynamic dispatch.
type IThrowStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsThrowStatementContext differentiates from other interfaces.
	IsThrowStatementContext()
}

type ThrowStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyThrowStatementContext() *ThrowStatementContext {
	var p = new(ThrowStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_throwStatement
	return p
}

func (*ThrowStatementContext) IsThrowStatementContext() {}

func NewThrowStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ThrowStatementContext {
	var p = new(ThrowStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_throwStatement

	return p
}

func (s *ThrowStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *ThrowStatementContext) Throw() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserThrow, 0)
}

func (s *ThrowStatementContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *ThrowStatementContext) Eos() IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

func (s *ThrowStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ThrowStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ThrowStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterThrowStatement(s)
	}
}

func (s *ThrowStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitThrowStatement(s)
	}
}

func (p *TypeScriptParser) ThrowStatement() (localctx IThrowStatementContext) {
	localctx = NewThrowStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 176, TypeScriptParserRULE_throwStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1085)
		p.Match(TypeScriptParserThrow)
	}
	p.SetState(1086)

	if !(p.notLineTerminator()) {
		panic(antlr.NewFailedPredicateException(p, "p.notLineTerminator()", ""))
	}
	{
		p.SetState(1087)
		p.ExpressionSequence()
	}
	{
		p.SetState(1088)
		p.Eos()
	}

	return localctx
}

// ITryStatementContext is an interface to support dynamic dispatch.
type ITryStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTryStatementContext differentiates from other interfaces.
	IsTryStatementContext()
}

type TryStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTryStatementContext() *TryStatementContext {
	var p = new(TryStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_tryStatement
	return p
}

func (*TryStatementContext) IsTryStatementContext() {}

func NewTryStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TryStatementContext {
	var p = new(TryStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_tryStatement

	return p
}

func (s *TryStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *TryStatementContext) Try() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserTry, 0)
}

func (s *TryStatementContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *TryStatementContext) CatchProduction() ICatchProductionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICatchProductionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICatchProductionContext)
}

func (s *TryStatementContext) FinallyProduction() IFinallyProductionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFinallyProductionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFinallyProductionContext)
}

func (s *TryStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TryStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TryStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTryStatement(s)
	}
}

func (s *TryStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTryStatement(s)
	}
}

func (p *TypeScriptParser) TryStatement() (localctx ITryStatementContext) {
	localctx = NewTryStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 178, TypeScriptParserRULE_tryStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1090)
		p.Match(TypeScriptParserTry)
	}
	{
		p.SetState(1091)
		p.Block()
	}
	p.SetState(1097)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserCatch:
		{
			p.SetState(1092)
			p.CatchProduction()
		}
		p.SetState(1094)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 125, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1093)
				p.FinallyProduction()
			}

		}

	case TypeScriptParserFinally:
		{
			p.SetState(1096)
			p.FinallyProduction()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// ICatchProductionContext is an interface to support dynamic dispatch.
type ICatchProductionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCatchProductionContext differentiates from other interfaces.
	IsCatchProductionContext()
}

type CatchProductionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCatchProductionContext() *CatchProductionContext {
	var p = new(CatchProductionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_catchProduction
	return p
}

func (*CatchProductionContext) IsCatchProductionContext() {}

func NewCatchProductionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CatchProductionContext {
	var p = new(CatchProductionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_catchProduction

	return p
}

func (s *CatchProductionContext) GetParser() antlr.Parser { return s.parser }

func (s *CatchProductionContext) Catch() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCatch, 0)
}

func (s *CatchProductionContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *CatchProductionContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *CatchProductionContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *CatchProductionContext) Assignable() IAssignableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignableContext)
}

func (s *CatchProductionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CatchProductionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CatchProductionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterCatchProduction(s)
	}
}

func (s *CatchProductionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitCatchProduction(s)
	}
}

func (p *TypeScriptParser) CatchProduction() (localctx ICatchProductionContext) {
	localctx = NewCatchProductionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 180, TypeScriptParserRULE_catchProduction)
	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(1099)
		p.Match(TypeScriptParserCatch)
	}
	p.SetState(1105)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserOpenParen {
		{
			p.SetState(1100)
			p.Match(TypeScriptParserOpenParen)
		}
		p.SetState(1102)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserOpenBracket || _la == TypeScriptParserOpenBrace || _la == TypeScriptParserIdentifier {
			{
				p.SetState(1101)
				p.Assignable()
			}

		}
		{
			p.SetState(1104)
			p.Match(TypeScriptParserCloseParen)
		}

	}
	{
		p.SetState(1107)
		p.Block()
	}

	return localctx
}

// IAssignableContext is an interface to support dynamic dispatch.
type IAssignableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssignableContext differentiates from other interfaces.
	IsAssignableContext()
}

type AssignableContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssignableContext() *AssignableContext {
	var p = new(AssignableContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_assignable
	return p
}

func (*AssignableContext) IsAssignableContext() {}

func NewAssignableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignableContext {
	var p = new(AssignableContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_assignable

	return p
}

func (s *AssignableContext) GetParser() antlr.Parser { return s.parser }

func (s *AssignableContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *AssignableContext) ArrayLiteral() IArrayLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayLiteralContext)
}

func (s *AssignableContext) ObjectLiteral() IObjectLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IObjectLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IObjectLiteralContext)
}

func (s *AssignableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssignableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssignableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterAssignable(s)
	}
}

func (s *AssignableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitAssignable(s)
	}
}

func (p *TypeScriptParser) Assignable() (localctx IAssignableContext) {
	localctx = NewAssignableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 182, TypeScriptParserRULE_assignable)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1112)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserIdentifier:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1109)
			p.Match(TypeScriptParserIdentifier)
		}

	case TypeScriptParserOpenBracket:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1110)
			p.ArrayLiteral()
		}

	case TypeScriptParserOpenBrace:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1111)
			p.ObjectLiteral()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IFinallyProductionContext is an interface to support dynamic dispatch.
type IFinallyProductionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFinallyProductionContext differentiates from other interfaces.
	IsFinallyProductionContext()
}

type FinallyProductionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFinallyProductionContext() *FinallyProductionContext {
	var p = new(FinallyProductionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_finallyProduction
	return p
}

func (*FinallyProductionContext) IsFinallyProductionContext() {}

func NewFinallyProductionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FinallyProductionContext {
	var p = new(FinallyProductionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_finallyProduction

	return p
}

func (s *FinallyProductionContext) GetParser() antlr.Parser { return s.parser }

func (s *FinallyProductionContext) Finally() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserFinally, 0)
}

func (s *FinallyProductionContext) Block() IBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *FinallyProductionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FinallyProductionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FinallyProductionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterFinallyProduction(s)
	}
}

func (s *FinallyProductionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitFinallyProduction(s)
	}
}

func (p *TypeScriptParser) FinallyProduction() (localctx IFinallyProductionContext) {
	localctx = NewFinallyProductionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 184, TypeScriptParserRULE_finallyProduction)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1114)
		p.Match(TypeScriptParserFinally)
	}
	{
		p.SetState(1115)
		p.Block()
	}

	return localctx
}

// IDebuggerStatementContext is an interface to support dynamic dispatch.
type IDebuggerStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDebuggerStatementContext differentiates from other interfaces.
	IsDebuggerStatementContext()
}

type DebuggerStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDebuggerStatementContext() *DebuggerStatementContext {
	var p = new(DebuggerStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_debuggerStatement
	return p
}

func (*DebuggerStatementContext) IsDebuggerStatementContext() {}

func NewDebuggerStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DebuggerStatementContext {
	var p = new(DebuggerStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_debuggerStatement

	return p
}

func (s *DebuggerStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *DebuggerStatementContext) Debugger() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDebugger, 0)
}

func (s *DebuggerStatementContext) Eos() IEosContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEosContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEosContext)
}

func (s *DebuggerStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DebuggerStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DebuggerStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterDebuggerStatement(s)
	}
}

func (s *DebuggerStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitDebuggerStatement(s)
	}
}

func (p *TypeScriptParser) DebuggerStatement() (localctx IDebuggerStatementContext) {
	localctx = NewDebuggerStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 186, TypeScriptParserRULE_debuggerStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1117)
		p.Match(TypeScriptParserDebugger)
	}
	{
		p.SetState(1118)
		p.Eos()
	}

	return localctx
}

// IFunctionDeclarationContext is an interface to support dynamic dispatch.
type IFunctionDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunctionDeclarationContext differentiates from other interfaces.
	IsFunctionDeclarationContext()
}

type FunctionDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunctionDeclarationContext() *FunctionDeclarationContext {
	var p = new(FunctionDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_functionDeclaration
	return p
}

func (*FunctionDeclarationContext) IsFunctionDeclarationContext() {}

func NewFunctionDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionDeclarationContext {
	var p = new(FunctionDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_functionDeclaration

	return p
}

func (s *FunctionDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *FunctionDeclarationContext) Function() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserFunction, 0)
}

func (s *FunctionDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *FunctionDeclarationContext) CallSignature() ICallSignatureContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICallSignatureContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICallSignatureContext)
}

func (s *FunctionDeclarationContext) SemiColon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, 0)
}

func (s *FunctionDeclarationContext) Async() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAsync, 0)
}

func (s *FunctionDeclarationContext) Multiply() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMultiply, 0)
}

func (s *FunctionDeclarationContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *FunctionDeclarationContext) FunctionBody() IFunctionBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionBodyContext)
}

func (s *FunctionDeclarationContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *FunctionDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FunctionDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FunctionDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterFunctionDeclaration(s)
	}
}

func (s *FunctionDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitFunctionDeclaration(s)
	}
}

func (p *TypeScriptParser) FunctionDeclaration() (localctx IFunctionDeclarationContext) {
	localctx = NewFunctionDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 188, TypeScriptParserRULE_functionDeclaration)
	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(1121)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserAsync {
		{
			p.SetState(1120)
			p.Match(TypeScriptParserAsync)
		}

	}
	{
		p.SetState(1123)
		p.Match(TypeScriptParserFunction)
	}
	p.SetState(1125)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserMultiply {
		{
			p.SetState(1124)
			p.Match(TypeScriptParserMultiply)
		}

	}
	{
		p.SetState(1127)
		p.Match(TypeScriptParserIdentifier)
	}
	{
		p.SetState(1128)
		p.CallSignature()
	}
	p.SetState(1134)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserOpenBrace:
		{
			p.SetState(1129)
			p.Match(TypeScriptParserOpenBrace)
		}
		{
			p.SetState(1130)
			p.FunctionBody()
		}
		{
			p.SetState(1131)
			p.Match(TypeScriptParserCloseBrace)
		}

	case TypeScriptParserSemiColon:
		{
			p.SetState(1133)
			p.Match(TypeScriptParserSemiColon)
		}

	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 = TypeScriptParserRULE_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 = TypeScriptParserRULE_classDeclaration

	return p
}

func (s *ClassDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassDeclarationContext) Class() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserClass, 0)
}

func (s *ClassDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *ClassDeclarationContext) ClassHeritage() IClassHeritageContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassHeritageContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassHeritageContext)
}

func (s *ClassDeclarationContext) ClassTail() IClassTailContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassTailContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassTailContext)
}

func (s *ClassDeclarationContext) Abstract() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAbstract, 0)
}

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) 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.(TypeScriptParserListener); ok {
		listenerT.EnterClassDeclaration(s)
	}
}

func (s *ClassDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitClassDeclaration(s)
	}
}

func (p *TypeScriptParser) ClassDeclaration() (localctx IClassDeclarationContext) {
	localctx = NewClassDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 190, TypeScriptParserRULE_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(1137)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserAbstract {
		{
			p.SetState(1136)
			p.Match(TypeScriptParserAbstract)
		}

	}
	{
		p.SetState(1139)
		p.Match(TypeScriptParserClass)
	}
	{
		p.SetState(1140)
		p.Match(TypeScriptParserIdentifier)
	}
	p.SetState(1142)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserLessThan {
		{
			p.SetState(1141)
			p.TypeParameters()
		}

	}
	{
		p.SetState(1144)
		p.ClassHeritage()
	}
	{
		p.SetState(1145)
		p.ClassTail()
	}

	return localctx
}

// IClassHeritageContext is an interface to support dynamic dispatch.
type IClassHeritageContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassHeritageContext differentiates from other interfaces.
	IsClassHeritageContext()
}

type ClassHeritageContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassHeritageContext() *ClassHeritageContext {
	var p = new(ClassHeritageContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_classHeritage
	return p
}

func (*ClassHeritageContext) IsClassHeritageContext() {}

func NewClassHeritageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassHeritageContext {
	var p = new(ClassHeritageContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_classHeritage

	return p
}

func (s *ClassHeritageContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassHeritageContext) ClassExtendsClause() IClassExtendsClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassExtendsClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassExtendsClauseContext)
}

func (s *ClassHeritageContext) ImplementsClause() IImplementsClauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImplementsClauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IImplementsClauseContext)
}

func (s *ClassHeritageContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassHeritageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassHeritageContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterClassHeritage(s)
	}
}

func (s *ClassHeritageContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitClassHeritage(s)
	}
}

func (p *TypeScriptParser) ClassHeritage() (localctx IClassHeritageContext) {
	localctx = NewClassHeritageContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 192, TypeScriptParserRULE_classHeritage)
	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(1148)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserExtends {
		{
			p.SetState(1147)
			p.ClassExtendsClause()
		}

	}
	p.SetState(1151)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserImplements {
		{
			p.SetState(1150)
			p.ImplementsClause()
		}

	}

	return localctx
}

// IClassTailContext is an interface to support dynamic dispatch.
type IClassTailContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassTailContext differentiates from other interfaces.
	IsClassTailContext()
}

type ClassTailContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassTailContext() *ClassTailContext {
	var p = new(ClassTailContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_classTail
	return p
}

func (*ClassTailContext) IsClassTailContext() {}

func NewClassTailContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassTailContext {
	var p = new(ClassTailContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_classTail

	return p
}

func (s *ClassTailContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassTailContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *ClassTailContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *ClassTailContext) AllClassElement() []IClassElementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IClassElementContext)(nil)).Elem())
	var tst = make([]IClassElementContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IClassElementContext)
		}
	}

	return tst
}

func (s *ClassTailContext) ClassElement(i int) IClassElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassElementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IClassElementContext)
}

func (s *ClassTailContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassTailContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassTailContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterClassTail(s)
	}
}

func (s *ClassTailContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitClassTail(s)
	}
}

func (p *TypeScriptParser) ClassTail() (localctx IClassTailContext) {
	localctx = NewClassTailContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 194, TypeScriptParserRULE_classTail)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != 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(1153)
		p.Match(TypeScriptParserOpenBrace)
	}
	p.SetState(1157)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 137, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1154)
				p.ClassElement()
			}

		}
		p.SetState(1159)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 137, p.GetParserRuleContext())
	}
	{
		p.SetState(1160)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

// IClassExtendsClauseContext is an interface to support dynamic dispatch.
type IClassExtendsClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassExtendsClauseContext differentiates from other interfaces.
	IsClassExtendsClauseContext()
}

type ClassExtendsClauseContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassExtendsClauseContext() *ClassExtendsClauseContext {
	var p = new(ClassExtendsClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_classExtendsClause
	return p
}

func (*ClassExtendsClauseContext) IsClassExtendsClauseContext() {}

func NewClassExtendsClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassExtendsClauseContext {
	var p = new(ClassExtendsClauseContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_classExtendsClause

	return p
}

func (s *ClassExtendsClauseContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassExtendsClauseContext) Extends() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserExtends, 0)
}

func (s *ClassExtendsClauseContext) TypeReference() ITypeReferenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeReferenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeReferenceContext)
}

func (s *ClassExtendsClauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassExtendsClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassExtendsClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterClassExtendsClause(s)
	}
}

func (s *ClassExtendsClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitClassExtendsClause(s)
	}
}

func (p *TypeScriptParser) ClassExtendsClause() (localctx IClassExtendsClauseContext) {
	localctx = NewClassExtendsClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 196, TypeScriptParserRULE_classExtendsClause)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1162)
		p.Match(TypeScriptParserExtends)
	}
	{
		p.SetState(1163)
		p.TypeReference()
	}

	return localctx
}

// IImplementsClauseContext is an interface to support dynamic dispatch.
type IImplementsClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsImplementsClauseContext differentiates from other interfaces.
	IsImplementsClauseContext()
}

type ImplementsClauseContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyImplementsClauseContext() *ImplementsClauseContext {
	var p = new(ImplementsClauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_implementsClause
	return p
}

func (*ImplementsClauseContext) IsImplementsClauseContext() {}

func NewImplementsClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImplementsClauseContext {
	var p = new(ImplementsClauseContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_implementsClause

	return p
}

func (s *ImplementsClauseContext) GetParser() antlr.Parser { return s.parser }

func (s *ImplementsClauseContext) Implements() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserImplements, 0)
}

func (s *ImplementsClauseContext) ClassOrInterfaceTypeList() IClassOrInterfaceTypeListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassOrInterfaceTypeListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassOrInterfaceTypeListContext)
}

func (s *ImplementsClauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ImplementsClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ImplementsClauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterImplementsClause(s)
	}
}

func (s *ImplementsClauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitImplementsClause(s)
	}
}

func (p *TypeScriptParser) ImplementsClause() (localctx IImplementsClauseContext) {
	localctx = NewImplementsClauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 198, TypeScriptParserRULE_implementsClause)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1165)
		p.Match(TypeScriptParserImplements)
	}
	{
		p.SetState(1166)
		p.ClassOrInterfaceTypeList()
	}

	return localctx
}

// IClassElementContext is an interface to support dynamic dispatch.
type IClassElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClassElementContext differentiates from other interfaces.
	IsClassElementContext()
}

type ClassElementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClassElementContext() *ClassElementContext {
	var p = new(ClassElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_classElement
	return p
}

func (*ClassElementContext) IsClassElementContext() {}

func NewClassElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClassElementContext {
	var p = new(ClassElementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_classElement

	return p
}

func (s *ClassElementContext) GetParser() antlr.Parser { return s.parser }

func (s *ClassElementContext) ConstructorDeclaration() IConstructorDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstructorDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstructorDeclarationContext)
}

func (s *ClassElementContext) PropertyMemberDeclaration() IPropertyMemberDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertyMemberDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPropertyMemberDeclarationContext)
}

func (s *ClassElementContext) IndexMemberDeclaration() IIndexMemberDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexMemberDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndexMemberDeclarationContext)
}

func (s *ClassElementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *ClassElementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClassElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterClassElement(s)
	}
}

func (s *ClassElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitClassElement(s)
	}
}

func (p *TypeScriptParser) ClassElement() (localctx IClassElementContext) {
	localctx = NewClassElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 200, TypeScriptParserRULE_classElement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1172)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 138, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1168)
			p.ConstructorDeclaration()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1169)
			p.PropertyMemberDeclaration()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1170)
			p.IndexMemberDeclaration()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1171)
			p.Statement()
		}

	}

	return localctx
}

// IPropertyMemberDeclarationContext is an interface to support dynamic dispatch.
type IPropertyMemberDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPropertyMemberDeclarationContext differentiates from other interfaces.
	IsPropertyMemberDeclarationContext()
}

type PropertyMemberDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPropertyMemberDeclarationContext() *PropertyMemberDeclarationContext {
	var p = new(PropertyMemberDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_propertyMemberDeclaration
	return p
}

func (*PropertyMemberDeclarationContext) IsPropertyMemberDeclarationContext() {}

func NewPropertyMemberDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyMemberDeclarationContext {
	var p = new(PropertyMemberDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_propertyMemberDeclaration

	return p
}

func (s *PropertyMemberDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *PropertyMemberDeclarationContext) PropertyMemberBase() IPropertyMemberBaseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertyMemberBaseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPropertyMemberBaseContext)
}

func (s *PropertyMemberDeclarationContext) PropertyName() IPropertyNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertyNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPropertyNameContext)
}

func (s *PropertyMemberDeclarationContext) SemiColon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, 0)
}

func (s *PropertyMemberDeclarationContext) Multiply() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMultiply, 0)
}

func (s *PropertyMemberDeclarationContext) Hashtag() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserHashtag, 0)
}

func (s *PropertyMemberDeclarationContext) TypeAnnotation() ITypeAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAnnotationContext)
}

func (s *PropertyMemberDeclarationContext) Initializer() IInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitializerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInitializerContext)
}

func (s *PropertyMemberDeclarationContext) CallSignature() ICallSignatureContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICallSignatureContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICallSignatureContext)
}

func (s *PropertyMemberDeclarationContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *PropertyMemberDeclarationContext) FunctionBody() IFunctionBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionBodyContext)
}

func (s *PropertyMemberDeclarationContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *PropertyMemberDeclarationContext) GetAccessor() IGetAccessorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGetAccessorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGetAccessorContext)
}

func (s *PropertyMemberDeclarationContext) SetAccessor() ISetAccessorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISetAccessorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISetAccessorContext)
}

func (s *PropertyMemberDeclarationContext) AbstractDeclaration() IAbstractDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAbstractDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAbstractDeclarationContext)
}

func (s *PropertyMemberDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PropertyMemberDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PropertyMemberDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPropertyMemberDeclaration(s)
	}
}

func (s *PropertyMemberDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPropertyMemberDeclaration(s)
	}
}

func (p *TypeScriptParser) PropertyMemberDeclaration() (localctx IPropertyMemberDeclarationContext) {
	localctx = NewPropertyMemberDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 202, TypeScriptParserRULE_propertyMemberDeclaration)
	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(1218)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 149, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1174)
			p.PropertyMemberBase()
		}
		p.SetState(1176)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserMultiply {
			{
				p.SetState(1175)
				p.Match(TypeScriptParserMultiply)
			}

		}
		p.SetState(1179)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserHashtag {
			{
				p.SetState(1178)
				p.Match(TypeScriptParserHashtag)
			}

		}
		{
			p.SetState(1181)
			p.PropertyName()
		}
		p.SetState(1183)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserColon {
			{
				p.SetState(1182)
				p.TypeAnnotation()
			}

		}
		p.SetState(1186)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserAssign {
			{
				p.SetState(1185)
				p.Initializer()
			}

		}
		{
			p.SetState(1188)
			p.Match(TypeScriptParserSemiColon)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1190)
			p.PropertyMemberBase()
		}
		p.SetState(1192)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserMultiply {
			{
				p.SetState(1191)
				p.Match(TypeScriptParserMultiply)
			}

		}
		p.SetState(1195)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserHashtag {
			{
				p.SetState(1194)
				p.Match(TypeScriptParserHashtag)
			}

		}
		{
			p.SetState(1197)
			p.PropertyName()
		}
		{
			p.SetState(1198)
			p.CallSignature()
		}
		p.SetState(1204)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case TypeScriptParserOpenBrace:
			{
				p.SetState(1199)
				p.Match(TypeScriptParserOpenBrace)
			}
			{
				p.SetState(1200)
				p.FunctionBody()
			}
			{
				p.SetState(1201)
				p.Match(TypeScriptParserCloseBrace)
			}

		case TypeScriptParserSemiColon:
			{
				p.SetState(1203)
				p.Match(TypeScriptParserSemiColon)
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1206)
			p.PropertyMemberBase()
		}
		p.SetState(1208)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserMultiply {
			{
				p.SetState(1207)
				p.Match(TypeScriptParserMultiply)
			}

		}
		p.SetState(1211)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserHashtag {
			{
				p.SetState(1210)
				p.Match(TypeScriptParserHashtag)
			}

		}
		p.SetState(1215)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 148, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1213)
				p.GetAccessor()
			}

		case 2:
			{
				p.SetState(1214)
				p.SetAccessor()
			}

		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1217)
			p.AbstractDeclaration()
		}

	}

	return localctx
}

// IPropertyMemberBaseContext is an interface to support dynamic dispatch.
type IPropertyMemberBaseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPropertyMemberBaseContext differentiates from other interfaces.
	IsPropertyMemberBaseContext()
}

type PropertyMemberBaseContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPropertyMemberBaseContext() *PropertyMemberBaseContext {
	var p = new(PropertyMemberBaseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_propertyMemberBase
	return p
}

func (*PropertyMemberBaseContext) IsPropertyMemberBaseContext() {}

func NewPropertyMemberBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyMemberBaseContext {
	var p = new(PropertyMemberBaseContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_propertyMemberBase

	return p
}

func (s *PropertyMemberBaseContext) GetParser() antlr.Parser { return s.parser }

func (s *PropertyMemberBaseContext) Async() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAsync, 0)
}

func (s *PropertyMemberBaseContext) AccessibilityModifier() IAccessibilityModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAccessibilityModifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAccessibilityModifierContext)
}

func (s *PropertyMemberBaseContext) Static() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserStatic, 0)
}

func (s *PropertyMemberBaseContext) ReadOnly() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserReadOnly, 0)
}

func (s *PropertyMemberBaseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PropertyMemberBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PropertyMemberBaseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPropertyMemberBase(s)
	}
}

func (s *PropertyMemberBaseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPropertyMemberBase(s)
	}
}

func (p *TypeScriptParser) PropertyMemberBase() (localctx IPropertyMemberBaseContext) {
	localctx = NewPropertyMemberBaseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 204, TypeScriptParserRULE_propertyMemberBase)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1221)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 150, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1220)
			p.Match(TypeScriptParserAsync)
		}

	}
	p.SetState(1224)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 151, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1223)
			p.AccessibilityModifier()
		}

	}
	p.SetState(1227)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 152, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1226)
			p.Match(TypeScriptParserStatic)
		}

	}
	p.SetState(1230)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 153, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1229)
			p.Match(TypeScriptParserReadOnly)
		}

	}

	return localctx
}

// IIndexMemberDeclarationContext is an interface to support dynamic dispatch.
type IIndexMemberDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIndexMemberDeclarationContext differentiates from other interfaces.
	IsIndexMemberDeclarationContext()
}

type IndexMemberDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndexMemberDeclarationContext() *IndexMemberDeclarationContext {
	var p = new(IndexMemberDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_indexMemberDeclaration
	return p
}

func (*IndexMemberDeclarationContext) IsIndexMemberDeclarationContext() {}

func NewIndexMemberDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexMemberDeclarationContext {
	var p = new(IndexMemberDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_indexMemberDeclaration

	return p
}

func (s *IndexMemberDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *IndexMemberDeclarationContext) IndexSignature() IIndexSignatureContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexSignatureContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndexSignatureContext)
}

func (s *IndexMemberDeclarationContext) SemiColon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, 0)
}

func (s *IndexMemberDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IndexMemberDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IndexMemberDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterIndexMemberDeclaration(s)
	}
}

func (s *IndexMemberDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitIndexMemberDeclaration(s)
	}
}

func (p *TypeScriptParser) IndexMemberDeclaration() (localctx IIndexMemberDeclarationContext) {
	localctx = NewIndexMemberDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 206, TypeScriptParserRULE_indexMemberDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1232)
		p.IndexSignature()
	}
	{
		p.SetState(1233)
		p.Match(TypeScriptParserSemiColon)
	}

	return localctx
}

// IGeneratorMethodContext is an interface to support dynamic dispatch.
type IGeneratorMethodContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsGeneratorMethodContext differentiates from other interfaces.
	IsGeneratorMethodContext()
}

type GeneratorMethodContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGeneratorMethodContext() *GeneratorMethodContext {
	var p = new(GeneratorMethodContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_generatorMethod
	return p
}

func (*GeneratorMethodContext) IsGeneratorMethodContext() {}

func NewGeneratorMethodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GeneratorMethodContext {
	var p = new(GeneratorMethodContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_generatorMethod

	return p
}

func (s *GeneratorMethodContext) GetParser() antlr.Parser { return s.parser }

func (s *GeneratorMethodContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *GeneratorMethodContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *GeneratorMethodContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *GeneratorMethodContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *GeneratorMethodContext) FunctionBody() IFunctionBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionBodyContext)
}

func (s *GeneratorMethodContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *GeneratorMethodContext) Multiply() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMultiply, 0)
}

func (s *GeneratorMethodContext) FormalParameterList() IFormalParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterListContext)
}

func (s *GeneratorMethodContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GeneratorMethodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *GeneratorMethodContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterGeneratorMethod(s)
	}
}

func (s *GeneratorMethodContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitGeneratorMethod(s)
	}
}

func (p *TypeScriptParser) GeneratorMethod() (localctx IGeneratorMethodContext) {
	localctx = NewGeneratorMethodContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 208, TypeScriptParserRULE_generatorMethod)
	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(1236)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserMultiply {
		{
			p.SetState(1235)
			p.Match(TypeScriptParserMultiply)
		}

	}
	{
		p.SetState(1238)
		p.Match(TypeScriptParserIdentifier)
	}
	{
		p.SetState(1239)
		p.Match(TypeScriptParserOpenParen)
	}
	p.SetState(1241)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<TypeScriptParserOpenBracket)|(1<<TypeScriptParserOpenBrace)|(1<<TypeScriptParserEllipsis))) != 0) || (((_la-108)&-(0x1f+1)) == 0 && ((1<<uint((_la-108)))&((1<<(TypeScriptParserPrivate-108))|(1<<(TypeScriptParserPublic-108))|(1<<(TypeScriptParserProtected-108))|(1<<(TypeScriptParserIdentifier-108)))) != 0) {
		{
			p.SetState(1240)
			p.FormalParameterList()
		}

	}
	{
		p.SetState(1243)
		p.Match(TypeScriptParserCloseParen)
	}
	{
		p.SetState(1244)
		p.Match(TypeScriptParserOpenBrace)
	}
	{
		p.SetState(1245)
		p.FunctionBody()
	}
	{
		p.SetState(1246)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

// IGeneratorFunctionDeclarationContext is an interface to support dynamic dispatch.
type IGeneratorFunctionDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsGeneratorFunctionDeclarationContext differentiates from other interfaces.
	IsGeneratorFunctionDeclarationContext()
}

type GeneratorFunctionDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGeneratorFunctionDeclarationContext() *GeneratorFunctionDeclarationContext {
	var p = new(GeneratorFunctionDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_generatorFunctionDeclaration
	return p
}

func (*GeneratorFunctionDeclarationContext) IsGeneratorFunctionDeclarationContext() {}

func NewGeneratorFunctionDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GeneratorFunctionDeclarationContext {
	var p = new(GeneratorFunctionDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_generatorFunctionDeclaration

	return p
}

func (s *GeneratorFunctionDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *GeneratorFunctionDeclarationContext) Function() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserFunction, 0)
}

func (s *GeneratorFunctionDeclarationContext) Multiply() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMultiply, 0)
}

func (s *GeneratorFunctionDeclarationContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *GeneratorFunctionDeclarationContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *GeneratorFunctionDeclarationContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *GeneratorFunctionDeclarationContext) FunctionBody() IFunctionBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionBodyContext)
}

func (s *GeneratorFunctionDeclarationContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *GeneratorFunctionDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *GeneratorFunctionDeclarationContext) FormalParameterList() IFormalParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterListContext)
}

func (s *GeneratorFunctionDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GeneratorFunctionDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *GeneratorFunctionDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterGeneratorFunctionDeclaration(s)
	}
}

func (s *GeneratorFunctionDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitGeneratorFunctionDeclaration(s)
	}
}

func (p *TypeScriptParser) GeneratorFunctionDeclaration() (localctx IGeneratorFunctionDeclarationContext) {
	localctx = NewGeneratorFunctionDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 210, TypeScriptParserRULE_generatorFunctionDeclaration)
	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(1248)
		p.Match(TypeScriptParserFunction)
	}
	{
		p.SetState(1249)
		p.Match(TypeScriptParserMultiply)
	}
	p.SetState(1251)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserIdentifier {
		{
			p.SetState(1250)
			p.Match(TypeScriptParserIdentifier)
		}

	}
	{
		p.SetState(1253)
		p.Match(TypeScriptParserOpenParen)
	}
	p.SetState(1255)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<TypeScriptParserOpenBracket)|(1<<TypeScriptParserOpenBrace)|(1<<TypeScriptParserEllipsis))) != 0) || (((_la-108)&-(0x1f+1)) == 0 && ((1<<uint((_la-108)))&((1<<(TypeScriptParserPrivate-108))|(1<<(TypeScriptParserPublic-108))|(1<<(TypeScriptParserProtected-108))|(1<<(TypeScriptParserIdentifier-108)))) != 0) {
		{
			p.SetState(1254)
			p.FormalParameterList()
		}

	}
	{
		p.SetState(1257)
		p.Match(TypeScriptParserCloseParen)
	}
	{
		p.SetState(1258)
		p.Match(TypeScriptParserOpenBrace)
	}
	{
		p.SetState(1259)
		p.FunctionBody()
	}
	{
		p.SetState(1260)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

// IGeneratorBlockContext is an interface to support dynamic dispatch.
type IGeneratorBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsGeneratorBlockContext differentiates from other interfaces.
	IsGeneratorBlockContext()
}

type GeneratorBlockContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGeneratorBlockContext() *GeneratorBlockContext {
	var p = new(GeneratorBlockContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_generatorBlock
	return p
}

func (*GeneratorBlockContext) IsGeneratorBlockContext() {}

func NewGeneratorBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GeneratorBlockContext {
	var p = new(GeneratorBlockContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_generatorBlock

	return p
}

func (s *GeneratorBlockContext) GetParser() antlr.Parser { return s.parser }

func (s *GeneratorBlockContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *GeneratorBlockContext) AllGeneratorDefinition() []IGeneratorDefinitionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IGeneratorDefinitionContext)(nil)).Elem())
	var tst = make([]IGeneratorDefinitionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IGeneratorDefinitionContext)
		}
	}

	return tst
}

func (s *GeneratorBlockContext) GeneratorDefinition(i int) IGeneratorDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGeneratorDefinitionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IGeneratorDefinitionContext)
}

func (s *GeneratorBlockContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *GeneratorBlockContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *GeneratorBlockContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

func (s *GeneratorBlockContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GeneratorBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *GeneratorBlockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterGeneratorBlock(s)
	}
}

func (s *GeneratorBlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitGeneratorBlock(s)
	}
}

func (p *TypeScriptParser) GeneratorBlock() (localctx IGeneratorBlockContext) {
	localctx = NewGeneratorBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 212, TypeScriptParserRULE_generatorBlock)
	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(1262)
		p.Match(TypeScriptParserOpenBrace)
	}
	{
		p.SetState(1263)
		p.GeneratorDefinition()
	}
	p.SetState(1268)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 158, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1264)
				p.Match(TypeScriptParserComma)
			}
			{
				p.SetState(1265)
				p.GeneratorDefinition()
			}

		}
		p.SetState(1270)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 158, p.GetParserRuleContext())
	}
	p.SetState(1272)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserComma {
		{
			p.SetState(1271)
			p.Match(TypeScriptParserComma)
		}

	}
	{
		p.SetState(1274)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

// IGeneratorDefinitionContext is an interface to support dynamic dispatch.
type IGeneratorDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsGeneratorDefinitionContext differentiates from other interfaces.
	IsGeneratorDefinitionContext()
}

type GeneratorDefinitionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGeneratorDefinitionContext() *GeneratorDefinitionContext {
	var p = new(GeneratorDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_generatorDefinition
	return p
}

func (*GeneratorDefinitionContext) IsGeneratorDefinitionContext() {}

func NewGeneratorDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GeneratorDefinitionContext {
	var p = new(GeneratorDefinitionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_generatorDefinition

	return p
}

func (s *GeneratorDefinitionContext) GetParser() antlr.Parser { return s.parser }

func (s *GeneratorDefinitionContext) Multiply() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMultiply, 0)
}

func (s *GeneratorDefinitionContext) IteratorDefinition() IIteratorDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIteratorDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIteratorDefinitionContext)
}

func (s *GeneratorDefinitionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GeneratorDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *GeneratorDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterGeneratorDefinition(s)
	}
}

func (s *GeneratorDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitGeneratorDefinition(s)
	}
}

func (p *TypeScriptParser) GeneratorDefinition() (localctx IGeneratorDefinitionContext) {
	localctx = NewGeneratorDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 214, TypeScriptParserRULE_generatorDefinition)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1276)
		p.Match(TypeScriptParserMultiply)
	}
	{
		p.SetState(1277)
		p.IteratorDefinition()
	}

	return localctx
}

// IIteratorBlockContext is an interface to support dynamic dispatch.
type IIteratorBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIteratorBlockContext differentiates from other interfaces.
	IsIteratorBlockContext()
}

type IteratorBlockContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIteratorBlockContext() *IteratorBlockContext {
	var p = new(IteratorBlockContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_iteratorBlock
	return p
}

func (*IteratorBlockContext) IsIteratorBlockContext() {}

func NewIteratorBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IteratorBlockContext {
	var p = new(IteratorBlockContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_iteratorBlock

	return p
}

func (s *IteratorBlockContext) GetParser() antlr.Parser { return s.parser }

func (s *IteratorBlockContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *IteratorBlockContext) AllIteratorDefinition() []IIteratorDefinitionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIteratorDefinitionContext)(nil)).Elem())
	var tst = make([]IIteratorDefinitionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IIteratorDefinitionContext)
		}
	}

	return tst
}

func (s *IteratorBlockContext) IteratorDefinition(i int) IIteratorDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIteratorDefinitionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIteratorDefinitionContext)
}

func (s *IteratorBlockContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *IteratorBlockContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *IteratorBlockContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

func (s *IteratorBlockContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IteratorBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IteratorBlockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterIteratorBlock(s)
	}
}

func (s *IteratorBlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitIteratorBlock(s)
	}
}

func (p *TypeScriptParser) IteratorBlock() (localctx IIteratorBlockContext) {
	localctx = NewIteratorBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 216, TypeScriptParserRULE_iteratorBlock)
	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(1279)
		p.Match(TypeScriptParserOpenBrace)
	}
	{
		p.SetState(1280)
		p.IteratorDefinition()
	}
	p.SetState(1285)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 160, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1281)
				p.Match(TypeScriptParserComma)
			}
			{
				p.SetState(1282)
				p.IteratorDefinition()
			}

		}
		p.SetState(1287)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 160, p.GetParserRuleContext())
	}
	p.SetState(1289)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserComma {
		{
			p.SetState(1288)
			p.Match(TypeScriptParserComma)
		}

	}
	{
		p.SetState(1291)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

// IIteratorDefinitionContext is an interface to support dynamic dispatch.
type IIteratorDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIteratorDefinitionContext differentiates from other interfaces.
	IsIteratorDefinitionContext()
}

type IteratorDefinitionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIteratorDefinitionContext() *IteratorDefinitionContext {
	var p = new(IteratorDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_iteratorDefinition
	return p
}

func (*IteratorDefinitionContext) IsIteratorDefinitionContext() {}

func NewIteratorDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IteratorDefinitionContext {
	var p = new(IteratorDefinitionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_iteratorDefinition

	return p
}

func (s *IteratorDefinitionContext) GetParser() antlr.Parser { return s.parser }

func (s *IteratorDefinitionContext) OpenBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBracket, 0)
}

func (s *IteratorDefinitionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *IteratorDefinitionContext) CloseBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBracket, 0)
}

func (s *IteratorDefinitionContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *IteratorDefinitionContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *IteratorDefinitionContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *IteratorDefinitionContext) FunctionBody() IFunctionBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionBodyContext)
}

func (s *IteratorDefinitionContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *IteratorDefinitionContext) FormalParameterList() IFormalParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterListContext)
}

func (s *IteratorDefinitionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IteratorDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IteratorDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterIteratorDefinition(s)
	}
}

func (s *IteratorDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitIteratorDefinition(s)
	}
}

func (p *TypeScriptParser) IteratorDefinition() (localctx IIteratorDefinitionContext) {
	localctx = NewIteratorDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 218, TypeScriptParserRULE_iteratorDefinition)
	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.Match(TypeScriptParserOpenBracket)
	}
	{
		p.SetState(1294)
		p.singleExpression(0)
	}
	{
		p.SetState(1295)
		p.Match(TypeScriptParserCloseBracket)
	}
	{
		p.SetState(1296)
		p.Match(TypeScriptParserOpenParen)
	}
	p.SetState(1298)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<TypeScriptParserOpenBracket)|(1<<TypeScriptParserOpenBrace)|(1<<TypeScriptParserEllipsis))) != 0) || (((_la-108)&-(0x1f+1)) == 0 && ((1<<uint((_la-108)))&((1<<(TypeScriptParserPrivate-108))|(1<<(TypeScriptParserPublic-108))|(1<<(TypeScriptParserProtected-108))|(1<<(TypeScriptParserIdentifier-108)))) != 0) {
		{
			p.SetState(1297)
			p.FormalParameterList()
		}

	}
	{
		p.SetState(1300)
		p.Match(TypeScriptParserCloseParen)
	}
	{
		p.SetState(1301)
		p.Match(TypeScriptParserOpenBrace)
	}
	{
		p.SetState(1302)
		p.FunctionBody()
	}
	{
		p.SetState(1303)
		p.Match(TypeScriptParserCloseBrace)
	}

	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 = TypeScriptParserRULE_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 = TypeScriptParserRULE_formalParameterList

	return p
}

func (s *FormalParameterListContext) GetParser() antlr.Parser { return s.parser }

func (s *FormalParameterListContext) AllFormalParameterArg() []IFormalParameterArgContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFormalParameterArgContext)(nil)).Elem())
	var tst = make([]IFormalParameterArgContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IFormalParameterArgContext)
		}
	}

	return tst
}

func (s *FormalParameterListContext) FormalParameterArg(i int) IFormalParameterArgContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterArgContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterArgContext)
}

func (s *FormalParameterListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *FormalParameterListContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

func (s *FormalParameterListContext) LastFormalParameterArg() ILastFormalParameterArgContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILastFormalParameterArgContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILastFormalParameterArgContext)
}

func (s *FormalParameterListContext) ArrayLiteral() IArrayLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayLiteralContext)
}

func (s *FormalParameterListContext) ObjectLiteral() IObjectLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IObjectLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IObjectLiteralContext)
}

func (s *FormalParameterListContext) Colon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserColon, 0)
}

func (s *FormalParameterListContext) FormalParameterList() IFormalParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterListContext)
}

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.(TypeScriptParserListener); ok {
		listenerT.EnterFormalParameterList(s)
	}
}

func (s *FormalParameterListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitFormalParameterList(s)
	}
}

func (p *TypeScriptParser) FormalParameterList() (localctx IFormalParameterListContext) {
	localctx = NewFormalParameterListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 220, TypeScriptParserRULE_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(1324)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserPrivate, TypeScriptParserPublic, TypeScriptParserProtected, TypeScriptParserIdentifier:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1305)
			p.FormalParameterArg()
		}
		p.SetState(1310)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 163, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(1306)
					p.Match(TypeScriptParserComma)
				}
				{
					p.SetState(1307)
					p.FormalParameterArg()
				}

			}
			p.SetState(1312)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 163, p.GetParserRuleContext())
		}
		p.SetState(1315)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserComma {
			{
				p.SetState(1313)
				p.Match(TypeScriptParserComma)
			}
			{
				p.SetState(1314)
				p.LastFormalParameterArg()
			}

		}

	case TypeScriptParserEllipsis:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1317)
			p.LastFormalParameterArg()
		}

	case TypeScriptParserOpenBracket:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1318)
			p.ArrayLiteral()
		}

	case TypeScriptParserOpenBrace:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1319)
			p.ObjectLiteral()
		}
		p.SetState(1322)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserColon {
			{
				p.SetState(1320)
				p.Match(TypeScriptParserColon)
			}
			{
				p.SetState(1321)
				p.FormalParameterList()
			}

		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IFormalParameterArgContext is an interface to support dynamic dispatch.
type IFormalParameterArgContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFormalParameterArgContext differentiates from other interfaces.
	IsFormalParameterArgContext()
}

type FormalParameterArgContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFormalParameterArgContext() *FormalParameterArgContext {
	var p = new(FormalParameterArgContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_formalParameterArg
	return p
}

func (*FormalParameterArgContext) IsFormalParameterArgContext() {}

func NewFormalParameterArgContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FormalParameterArgContext {
	var p = new(FormalParameterArgContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_formalParameterArg

	return p
}

func (s *FormalParameterArgContext) GetParser() antlr.Parser { return s.parser }

func (s *FormalParameterArgContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *FormalParameterArgContext) AccessibilityModifier() IAccessibilityModifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAccessibilityModifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAccessibilityModifierContext)
}

func (s *FormalParameterArgContext) TypeAnnotation() ITypeAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAnnotationContext)
}

func (s *FormalParameterArgContext) Assign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAssign, 0)
}

func (s *FormalParameterArgContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *FormalParameterArgContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FormalParameterArgContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FormalParameterArgContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterFormalParameterArg(s)
	}
}

func (s *FormalParameterArgContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitFormalParameterArg(s)
	}
}

func (p *TypeScriptParser) FormalParameterArg() (localctx IFormalParameterArgContext) {
	localctx = NewFormalParameterArgContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 222, TypeScriptParserRULE_formalParameterArg)
	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(1327)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-108)&-(0x1f+1)) == 0 && ((1<<uint((_la-108)))&((1<<(TypeScriptParserPrivate-108))|(1<<(TypeScriptParserPublic-108))|(1<<(TypeScriptParserProtected-108)))) != 0 {
		{
			p.SetState(1326)
			p.AccessibilityModifier()
		}

	}
	{
		p.SetState(1329)
		p.Match(TypeScriptParserIdentifier)
	}
	p.SetState(1331)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserColon {
		{
			p.SetState(1330)
			p.TypeAnnotation()
		}

	}
	p.SetState(1335)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserAssign {
		{
			p.SetState(1333)
			p.Match(TypeScriptParserAssign)
		}
		{
			p.SetState(1334)
			p.singleExpression(0)
		}

	}

	return localctx
}

// ILastFormalParameterArgContext is an interface to support dynamic dispatch.
type ILastFormalParameterArgContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLastFormalParameterArgContext differentiates from other interfaces.
	IsLastFormalParameterArgContext()
}

type LastFormalParameterArgContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLastFormalParameterArgContext() *LastFormalParameterArgContext {
	var p = new(LastFormalParameterArgContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_lastFormalParameterArg
	return p
}

func (*LastFormalParameterArgContext) IsLastFormalParameterArgContext() {}

func NewLastFormalParameterArgContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LastFormalParameterArgContext {
	var p = new(LastFormalParameterArgContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_lastFormalParameterArg

	return p
}

func (s *LastFormalParameterArgContext) GetParser() antlr.Parser { return s.parser }

func (s *LastFormalParameterArgContext) Ellipsis() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserEllipsis, 0)
}

func (s *LastFormalParameterArgContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *LastFormalParameterArgContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LastFormalParameterArgContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LastFormalParameterArgContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterLastFormalParameterArg(s)
	}
}

func (s *LastFormalParameterArgContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitLastFormalParameterArg(s)
	}
}

func (p *TypeScriptParser) LastFormalParameterArg() (localctx ILastFormalParameterArgContext) {
	localctx = NewLastFormalParameterArgContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 224, TypeScriptParserRULE_lastFormalParameterArg)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1337)
		p.Match(TypeScriptParserEllipsis)
	}
	{
		p.SetState(1338)
		p.Match(TypeScriptParserIdentifier)
	}

	return localctx
}

// IFunctionBodyContext is an interface to support dynamic dispatch.
type IFunctionBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunctionBodyContext differentiates from other interfaces.
	IsFunctionBodyContext()
}

type FunctionBodyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunctionBodyContext() *FunctionBodyContext {
	var p = new(FunctionBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_functionBody
	return p
}

func (*FunctionBodyContext) IsFunctionBodyContext() {}

func NewFunctionBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionBodyContext {
	var p = new(FunctionBodyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_functionBody

	return p
}

func (s *FunctionBodyContext) GetParser() antlr.Parser { return s.parser }

func (s *FunctionBodyContext) SourceElements() ISourceElementsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISourceElementsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISourceElementsContext)
}

func (s *FunctionBodyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FunctionBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FunctionBodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterFunctionBody(s)
	}
}

func (s *FunctionBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitFunctionBody(s)
	}
}

func (p *TypeScriptParser) FunctionBody() (localctx IFunctionBodyContext) {
	localctx = NewFunctionBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 226, TypeScriptParserRULE_functionBody)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1341)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 170, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1340)
			p.SourceElements()
		}

	}

	return localctx
}

// ISourceElementsContext is an interface to support dynamic dispatch.
type ISourceElementsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSourceElementsContext differentiates from other interfaces.
	IsSourceElementsContext()
}

type SourceElementsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySourceElementsContext() *SourceElementsContext {
	var p = new(SourceElementsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_sourceElements
	return p
}

func (*SourceElementsContext) IsSourceElementsContext() {}

func NewSourceElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SourceElementsContext {
	var p = new(SourceElementsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_sourceElements

	return p
}

func (s *SourceElementsContext) GetParser() antlr.Parser { return s.parser }

func (s *SourceElementsContext) AllSourceElement() []ISourceElementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISourceElementContext)(nil)).Elem())
	var tst = make([]ISourceElementContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISourceElementContext)
		}
	}

	return tst
}

func (s *SourceElementsContext) SourceElement(i int) ISourceElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISourceElementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISourceElementContext)
}

func (s *SourceElementsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SourceElementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SourceElementsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterSourceElements(s)
	}
}

func (s *SourceElementsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitSourceElements(s)
	}
}

func (p *TypeScriptParser) SourceElements() (localctx ISourceElementsContext) {
	localctx = NewSourceElementsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 228, TypeScriptParserRULE_sourceElements)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != 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(1344)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(1343)
				p.SourceElement()
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}

		p.SetState(1346)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 171, p.GetParserRuleContext())
	}

	return localctx
}

// IArrayLiteralContext is an interface to support dynamic dispatch.
type IArrayLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArrayLiteralContext differentiates from other interfaces.
	IsArrayLiteralContext()
}

type ArrayLiteralContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArrayLiteralContext() *ArrayLiteralContext {
	var p = new(ArrayLiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_arrayLiteral
	return p
}

func (*ArrayLiteralContext) IsArrayLiteralContext() {}

func NewArrayLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayLiteralContext {
	var p = new(ArrayLiteralContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_arrayLiteral

	return p
}

func (s *ArrayLiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *ArrayLiteralContext) OpenBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBracket, 0)
}

func (s *ArrayLiteralContext) CloseBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBracket, 0)
}

func (s *ArrayLiteralContext) ElementList() IElementListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElementListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElementListContext)
}

func (s *ArrayLiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArrayLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArrayLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterArrayLiteral(s)
	}
}

func (s *ArrayLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitArrayLiteral(s)
	}
}

func (p *TypeScriptParser) ArrayLiteral() (localctx IArrayLiteralContext) {
	localctx = NewArrayLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 230, TypeScriptParserRULE_arrayLiteral)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1348)
		p.Match(TypeScriptParserOpenBracket)
	}
	p.SetState(1350)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la-4)&-(0x1f+1)) == 0 && ((1<<uint((_la-4)))&((1<<(TypeScriptParserRegularExpressionLiteral-4))|(1<<(TypeScriptParserOpenBracket-4))|(1<<(TypeScriptParserOpenParen-4))|(1<<(TypeScriptParserOpenBrace-4))|(1<<(TypeScriptParserEllipsis-4))|(1<<(TypeScriptParserPlusPlus-4))|(1<<(TypeScriptParserMinusMinus-4))|(1<<(TypeScriptParserPlus-4))|(1<<(TypeScriptParserMinus-4))|(1<<(TypeScriptParserBitNot-4))|(1<<(TypeScriptParserNot-4))|(1<<(TypeScriptParserLessThan-4)))) != 0) || (((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(TypeScriptParserNullLiteral-61))|(1<<(TypeScriptParserBooleanLiteral-61))|(1<<(TypeScriptParserDecimalLiteral-61))|(1<<(TypeScriptParserHexIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral2-61))|(1<<(TypeScriptParserBinaryIntegerLiteral-61))|(1<<(TypeScriptParserBreak-61))|(1<<(TypeScriptParserDo-61))|(1<<(TypeScriptParserInstanceof-61))|(1<<(TypeScriptParserTypeof-61))|(1<<(TypeScriptParserCase-61))|(1<<(TypeScriptParserElse-61))|(1<<(TypeScriptParserNew-61))|(1<<(TypeScriptParserVar-61))|(1<<(TypeScriptParserCatch-61))|(1<<(TypeScriptParserFinally-61))|(1<<(TypeScriptParserReturn-61))|(1<<(TypeScriptParserVoid-61))|(1<<(TypeScriptParserContinue-61))|(1<<(TypeScriptParserFor-61))|(1<<(TypeScriptParserSwitch-61))|(1<<(TypeScriptParserWhile-61))|(1<<(TypeScriptParserDebugger-61))|(1<<(TypeScriptParserFunction-61))|(1<<(TypeScriptParserThis-61))|(1<<(TypeScriptParserWith-61))|(1<<(TypeScriptParserDefault-61))|(1<<(TypeScriptParserIf-61))|(1<<(TypeScriptParserThrow-61))|(1<<(TypeScriptParserDelete-61))|(1<<(TypeScriptParserIn-61)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(TypeScriptParserTry-93))|(1<<(TypeScriptParserAs-93))|(1<<(TypeScriptParserFrom-93))|(1<<(TypeScriptParserReadOnly-93))|(1<<(TypeScriptParserAsync-93))|(1<<(TypeScriptParserClass-93))|(1<<(TypeScriptParserEnum-93))|(1<<(TypeScriptParserExtends-93))|(1<<(TypeScriptParserSuper-93))|(1<<(TypeScriptParserConst-93))|(1<<(TypeScriptParserExport-93))|(1<<(TypeScriptParserImport-93))|(1<<(TypeScriptParserAwait-93))|(1<<(TypeScriptParserImplements-93))|(1<<(TypeScriptParserLet-93))|(1<<(TypeScriptParserPrivate-93))|(1<<(TypeScriptParserPublic-93))|(1<<(TypeScriptParserInterface-93))|(1<<(TypeScriptParserPackage-93))|(1<<(TypeScriptParserProtected-93))|(1<<(TypeScriptParserStatic-93))|(1<<(TypeScriptParserYield-93)))) != 0) || (((_la-131)&-(0x1f+1)) == 0 && ((1<<uint((_la-131)))&((1<<(TypeScriptParserIdentifier-131))|(1<<(TypeScriptParserStringLiteral-131))|(1<<(TypeScriptParserTemplateStringLiteral-131)))) != 0) {
		{
			p.SetState(1349)
			p.ElementList()
		}

	}
	{
		p.SetState(1352)
		p.Match(TypeScriptParserCloseBracket)
	}

	return localctx
}

// IElementListContext is an interface to support dynamic dispatch.
type IElementListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsElementListContext differentiates from other interfaces.
	IsElementListContext()
}

type ElementListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyElementListContext() *ElementListContext {
	var p = new(ElementListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_elementList
	return p
}

func (*ElementListContext) IsElementListContext() {}

func NewElementListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementListContext {
	var p = new(ElementListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_elementList

	return p
}

func (s *ElementListContext) GetParser() antlr.Parser { return s.parser }

func (s *ElementListContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *ElementListContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *ElementListContext) LastElement() ILastElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILastElementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILastElementContext)
}

func (s *ElementListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *ElementListContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

func (s *ElementListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ElementListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ElementListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterElementList(s)
	}
}

func (s *ElementListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitElementList(s)
	}
}

func (p *TypeScriptParser) ElementList() (localctx IElementListContext) {
	localctx = NewElementListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 232, TypeScriptParserRULE_elementList)
	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(1375)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserRegularExpressionLiteral, TypeScriptParserOpenBracket, TypeScriptParserOpenParen, TypeScriptParserOpenBrace, TypeScriptParserPlusPlus, TypeScriptParserMinusMinus, TypeScriptParserPlus, TypeScriptParserMinus, TypeScriptParserBitNot, TypeScriptParserNot, TypeScriptParserLessThan, TypeScriptParserNullLiteral, TypeScriptParserBooleanLiteral, TypeScriptParserDecimalLiteral, TypeScriptParserHexIntegerLiteral, TypeScriptParserOctalIntegerLiteral, TypeScriptParserOctalIntegerLiteral2, TypeScriptParserBinaryIntegerLiteral, TypeScriptParserBreak, TypeScriptParserDo, TypeScriptParserInstanceof, TypeScriptParserTypeof, TypeScriptParserCase, TypeScriptParserElse, TypeScriptParserNew, TypeScriptParserVar, TypeScriptParserCatch, TypeScriptParserFinally, TypeScriptParserReturn, TypeScriptParserVoid, TypeScriptParserContinue, TypeScriptParserFor, TypeScriptParserSwitch, TypeScriptParserWhile, TypeScriptParserDebugger, TypeScriptParserFunction, TypeScriptParserThis, TypeScriptParserWith, TypeScriptParserDefault, TypeScriptParserIf, TypeScriptParserThrow, TypeScriptParserDelete, TypeScriptParserIn, TypeScriptParserTry, TypeScriptParserAs, TypeScriptParserFrom, TypeScriptParserReadOnly, TypeScriptParserAsync, TypeScriptParserClass, TypeScriptParserEnum, TypeScriptParserExtends, TypeScriptParserSuper, TypeScriptParserConst, TypeScriptParserExport, TypeScriptParserImport, TypeScriptParserAwait, TypeScriptParserImplements, TypeScriptParserLet, TypeScriptParserPrivate, TypeScriptParserPublic, TypeScriptParserInterface, TypeScriptParserPackage, TypeScriptParserProtected, TypeScriptParserStatic, TypeScriptParserYield, TypeScriptParserIdentifier, TypeScriptParserStringLiteral, TypeScriptParserTemplateStringLiteral:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1354)
			p.singleExpression(0)
		}
		p.SetState(1363)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 174, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				p.SetState(1356)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				for ok := true; ok; ok = _la == TypeScriptParserComma {
					{
						p.SetState(1355)
						p.Match(TypeScriptParserComma)
					}

					p.SetState(1358)
					p.GetErrorHandler().Sync(p)
					_la = p.GetTokenStream().LA(1)
				}
				{
					p.SetState(1360)
					p.singleExpression(0)
				}

			}
			p.SetState(1365)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 174, p.GetParserRuleContext())
		}
		p.SetState(1372)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserComma {
			p.SetState(1367)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for ok := true; ok; ok = _la == TypeScriptParserComma {
				{
					p.SetState(1366)
					p.Match(TypeScriptParserComma)
				}

				p.SetState(1369)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(1371)
				p.LastElement()
			}

		}

	case TypeScriptParserEllipsis:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1374)
			p.LastElement()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// ILastElementContext is an interface to support dynamic dispatch.
type ILastElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLastElementContext differentiates from other interfaces.
	IsLastElementContext()
}

type LastElementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLastElementContext() *LastElementContext {
	var p = new(LastElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_lastElement
	return p
}

func (*LastElementContext) IsLastElementContext() {}

func NewLastElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LastElementContext {
	var p = new(LastElementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_lastElement

	return p
}

func (s *LastElementContext) GetParser() antlr.Parser { return s.parser }

func (s *LastElementContext) Ellipsis() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserEllipsis, 0)
}

func (s *LastElementContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *LastElementContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *LastElementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LastElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LastElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterLastElement(s)
	}
}

func (s *LastElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitLastElement(s)
	}
}

func (p *TypeScriptParser) LastElement() (localctx ILastElementContext) {
	localctx = NewLastElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 234, TypeScriptParserRULE_lastElement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1377)
		p.Match(TypeScriptParserEllipsis)
	}
	p.SetState(1380)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 178, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1378)
			p.Match(TypeScriptParserIdentifier)
		}

	case 2:
		{
			p.SetState(1379)
			p.singleExpression(0)
		}

	}

	return localctx
}

// IObjectLiteralContext is an interface to support dynamic dispatch.
type IObjectLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsObjectLiteralContext differentiates from other interfaces.
	IsObjectLiteralContext()
}

type ObjectLiteralContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyObjectLiteralContext() *ObjectLiteralContext {
	var p = new(ObjectLiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_objectLiteral
	return p
}

func (*ObjectLiteralContext) IsObjectLiteralContext() {}

func NewObjectLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ObjectLiteralContext {
	var p = new(ObjectLiteralContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_objectLiteral

	return p
}

func (s *ObjectLiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *ObjectLiteralContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *ObjectLiteralContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *ObjectLiteralContext) AllPropertyAssignment() []IPropertyAssignmentContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IPropertyAssignmentContext)(nil)).Elem())
	var tst = make([]IPropertyAssignmentContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IPropertyAssignmentContext)
		}
	}

	return tst
}

func (s *ObjectLiteralContext) PropertyAssignment(i int) IPropertyAssignmentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertyAssignmentContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IPropertyAssignmentContext)
}

func (s *ObjectLiteralContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *ObjectLiteralContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

func (s *ObjectLiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ObjectLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ObjectLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterObjectLiteral(s)
	}
}

func (s *ObjectLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitObjectLiteral(s)
	}
}

func (p *TypeScriptParser) ObjectLiteral() (localctx IObjectLiteralContext) {
	localctx = NewObjectLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 236, TypeScriptParserRULE_objectLiteral)
	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(1382)
		p.Match(TypeScriptParserOpenBrace)
	}
	p.SetState(1391)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<TypeScriptParserOpenBracket)|(1<<TypeScriptParserEllipsis)|(1<<TypeScriptParserMultiply))) != 0) || (((_la-61)&-(0x1f+1)) == 0 && ((1<<uint((_la-61)))&((1<<(TypeScriptParserNullLiteral-61))|(1<<(TypeScriptParserBooleanLiteral-61))|(1<<(TypeScriptParserDecimalLiteral-61))|(1<<(TypeScriptParserHexIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral-61))|(1<<(TypeScriptParserOctalIntegerLiteral2-61))|(1<<(TypeScriptParserBinaryIntegerLiteral-61))|(1<<(TypeScriptParserBreak-61))|(1<<(TypeScriptParserDo-61))|(1<<(TypeScriptParserInstanceof-61))|(1<<(TypeScriptParserTypeof-61))|(1<<(TypeScriptParserCase-61))|(1<<(TypeScriptParserElse-61))|(1<<(TypeScriptParserNew-61))|(1<<(TypeScriptParserVar-61))|(1<<(TypeScriptParserCatch-61))|(1<<(TypeScriptParserFinally-61))|(1<<(TypeScriptParserReturn-61))|(1<<(TypeScriptParserVoid-61))|(1<<(TypeScriptParserContinue-61))|(1<<(TypeScriptParserFor-61))|(1<<(TypeScriptParserSwitch-61))|(1<<(TypeScriptParserWhile-61))|(1<<(TypeScriptParserDebugger-61))|(1<<(TypeScriptParserFunction-61))|(1<<(TypeScriptParserThis-61))|(1<<(TypeScriptParserWith-61))|(1<<(TypeScriptParserDefault-61))|(1<<(TypeScriptParserIf-61))|(1<<(TypeScriptParserThrow-61))|(1<<(TypeScriptParserDelete-61))|(1<<(TypeScriptParserIn-61)))) != 0) || (((_la-93)&-(0x1f+1)) == 0 && ((1<<uint((_la-93)))&((1<<(TypeScriptParserTry-93))|(1<<(TypeScriptParserAs-93))|(1<<(TypeScriptParserFrom-93))|(1<<(TypeScriptParserReadOnly-93))|(1<<(TypeScriptParserAsync-93))|(1<<(TypeScriptParserClass-93))|(1<<(TypeScriptParserEnum-93))|(1<<(TypeScriptParserExtends-93))|(1<<(TypeScriptParserSuper-93))|(1<<(TypeScriptParserConst-93))|(1<<(TypeScriptParserExport-93))|(1<<(TypeScriptParserImport-93))|(1<<(TypeScriptParserAwait-93))|(1<<(TypeScriptParserImplements-93))|(1<<(TypeScriptParserLet-93))|(1<<(TypeScriptParserPrivate-93))|(1<<(TypeScriptParserPublic-93))|(1<<(TypeScriptParserInterface-93))|(1<<(TypeScriptParserPackage-93))|(1<<(TypeScriptParserProtected-93))|(1<<(TypeScriptParserStatic-93))|(1<<(TypeScriptParserYield-93)))) != 0) || _la == TypeScriptParserIdentifier || _la == TypeScriptParserStringLiteral {
		{
			p.SetState(1383)
			p.PropertyAssignment()
		}
		p.SetState(1388)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 179, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(1384)
					p.Match(TypeScriptParserComma)
				}
				{
					p.SetState(1385)
					p.PropertyAssignment()
				}

			}
			p.SetState(1390)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 179, p.GetParserRuleContext())
		}

	}
	p.SetState(1394)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserComma {
		{
			p.SetState(1393)
			p.Match(TypeScriptParserComma)
		}

	}
	{
		p.SetState(1396)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

// IPropertyAssignmentContext is an interface to support dynamic dispatch.
type IPropertyAssignmentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPropertyAssignmentContext differentiates from other interfaces.
	IsPropertyAssignmentContext()
}

type PropertyAssignmentContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPropertyAssignmentContext() *PropertyAssignmentContext {
	var p = new(PropertyAssignmentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_propertyAssignment
	return p
}

func (*PropertyAssignmentContext) IsPropertyAssignmentContext() {}

func NewPropertyAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyAssignmentContext {
	var p = new(PropertyAssignmentContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_propertyAssignment

	return p
}

func (s *PropertyAssignmentContext) GetParser() antlr.Parser { return s.parser }

func (s *PropertyAssignmentContext) CopyFrom(ctx *PropertyAssignmentContext) {
	s.BaseParserRuleContext.CopyFrom(ctx.BaseParserRuleContext)
}

func (s *PropertyAssignmentContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PropertyAssignmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

type PropertyExpressionAssignmentContext struct {
	*PropertyAssignmentContext
}

func NewPropertyExpressionAssignmentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertyExpressionAssignmentContext {
	var p = new(PropertyExpressionAssignmentContext)

	p.PropertyAssignmentContext = NewEmptyPropertyAssignmentContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PropertyAssignmentContext))

	return p
}

func (s *PropertyExpressionAssignmentContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PropertyExpressionAssignmentContext) PropertyName() IPropertyNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertyNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPropertyNameContext)
}

func (s *PropertyExpressionAssignmentContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *PropertyExpressionAssignmentContext) Colon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserColon, 0)
}

func (s *PropertyExpressionAssignmentContext) Assign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAssign, 0)
}

func (s *PropertyExpressionAssignmentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPropertyExpressionAssignment(s)
	}
}

func (s *PropertyExpressionAssignmentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPropertyExpressionAssignment(s)
	}
}

type ComputedPropertyExpressionAssignmentContext struct {
	*PropertyAssignmentContext
}

func NewComputedPropertyExpressionAssignmentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ComputedPropertyExpressionAssignmentContext {
	var p = new(ComputedPropertyExpressionAssignmentContext)

	p.PropertyAssignmentContext = NewEmptyPropertyAssignmentContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PropertyAssignmentContext))

	return p
}

func (s *ComputedPropertyExpressionAssignmentContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ComputedPropertyExpressionAssignmentContext) OpenBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBracket, 0)
}

func (s *ComputedPropertyExpressionAssignmentContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *ComputedPropertyExpressionAssignmentContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *ComputedPropertyExpressionAssignmentContext) CloseBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBracket, 0)
}

func (s *ComputedPropertyExpressionAssignmentContext) Colon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserColon, 0)
}

func (s *ComputedPropertyExpressionAssignmentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterComputedPropertyExpressionAssignment(s)
	}
}

func (s *ComputedPropertyExpressionAssignmentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitComputedPropertyExpressionAssignment(s)
	}
}

type PropertyShorthandContext struct {
	*PropertyAssignmentContext
}

func NewPropertyShorthandContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertyShorthandContext {
	var p = new(PropertyShorthandContext)

	p.PropertyAssignmentContext = NewEmptyPropertyAssignmentContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PropertyAssignmentContext))

	return p
}

func (s *PropertyShorthandContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PropertyShorthandContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *PropertyShorthandContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPropertyShorthand(s)
	}
}

func (s *PropertyShorthandContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPropertyShorthand(s)
	}
}

type PropertySetterContext struct {
	*PropertyAssignmentContext
}

func NewPropertySetterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertySetterContext {
	var p = new(PropertySetterContext)

	p.PropertyAssignmentContext = NewEmptyPropertyAssignmentContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PropertyAssignmentContext))

	return p
}

func (s *PropertySetterContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PropertySetterContext) SetAccessor() ISetAccessorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISetAccessorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISetAccessorContext)
}

func (s *PropertySetterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPropertySetter(s)
	}
}

func (s *PropertySetterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPropertySetter(s)
	}
}

type PropertyGetterContext struct {
	*PropertyAssignmentContext
}

func NewPropertyGetterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PropertyGetterContext {
	var p = new(PropertyGetterContext)

	p.PropertyAssignmentContext = NewEmptyPropertyAssignmentContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PropertyAssignmentContext))

	return p
}

func (s *PropertyGetterContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PropertyGetterContext) GetAccessor() IGetAccessorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGetAccessorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGetAccessorContext)
}

func (s *PropertyGetterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPropertyGetter(s)
	}
}

func (s *PropertyGetterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPropertyGetter(s)
	}
}

type FunctionPropertyContext struct {
	*PropertyAssignmentContext
}

func NewFunctionPropertyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FunctionPropertyContext {
	var p = new(FunctionPropertyContext)

	p.PropertyAssignmentContext = NewEmptyPropertyAssignmentContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PropertyAssignmentContext))

	return p
}

func (s *FunctionPropertyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FunctionPropertyContext) PropertyName() IPropertyNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertyNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPropertyNameContext)
}

func (s *FunctionPropertyContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *FunctionPropertyContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *FunctionPropertyContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *FunctionPropertyContext) FunctionBody() IFunctionBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionBodyContext)
}

func (s *FunctionPropertyContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *FunctionPropertyContext) Async() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAsync, 0)
}

func (s *FunctionPropertyContext) Multiply() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMultiply, 0)
}

func (s *FunctionPropertyContext) FormalParameterList() IFormalParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterListContext)
}

func (s *FunctionPropertyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterFunctionProperty(s)
	}
}

func (s *FunctionPropertyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitFunctionProperty(s)
	}
}

type RestParameterInObjectContext struct {
	*PropertyAssignmentContext
}

func NewRestParameterInObjectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RestParameterInObjectContext {
	var p = new(RestParameterInObjectContext)

	p.PropertyAssignmentContext = NewEmptyPropertyAssignmentContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PropertyAssignmentContext))

	return p
}

func (s *RestParameterInObjectContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RestParameterInObjectContext) RestParameter() IRestParameterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRestParameterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRestParameterContext)
}

func (s *RestParameterInObjectContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterRestParameterInObject(s)
	}
}

func (s *RestParameterInObjectContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitRestParameterInObject(s)
	}
}

type MethodPropertyContext struct {
	*PropertyAssignmentContext
}

func NewMethodPropertyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MethodPropertyContext {
	var p = new(MethodPropertyContext)

	p.PropertyAssignmentContext = NewEmptyPropertyAssignmentContext()
	p.parser = parser
	p.CopyFrom(ctx.(*PropertyAssignmentContext))

	return p
}

func (s *MethodPropertyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MethodPropertyContext) GeneratorMethod() IGeneratorMethodContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGeneratorMethodContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGeneratorMethodContext)
}

func (s *MethodPropertyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterMethodProperty(s)
	}
}

func (s *MethodPropertyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitMethodProperty(s)
	}
}

func (p *TypeScriptParser) PropertyAssignment() (localctx IPropertyAssignmentContext) {
	localctx = NewPropertyAssignmentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 238, TypeScriptParserRULE_propertyAssignment)
	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(1429)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 185, p.GetParserRuleContext()) {
	case 1:
		localctx = NewPropertyExpressionAssignmentContext(p, localctx)
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1398)
			p.PropertyName()
		}
		{
			p.SetState(1399)
			_la = p.GetTokenStream().LA(1)

			if !(_la == TypeScriptParserAssign || _la == TypeScriptParserColon) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1400)
			p.singleExpression(0)
		}

	case 2:
		localctx = NewComputedPropertyExpressionAssignmentContext(p, localctx)
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1402)
			p.Match(TypeScriptParserOpenBracket)
		}
		{
			p.SetState(1403)
			p.singleExpression(0)
		}
		{
			p.SetState(1404)
			p.Match(TypeScriptParserCloseBracket)
		}
		{
			p.SetState(1405)
			p.Match(TypeScriptParserColon)
		}
		{
			p.SetState(1406)
			p.singleExpression(0)
		}

	case 3:
		localctx = NewFunctionPropertyContext(p, localctx)
		p.EnterOuterAlt(localctx, 3)
		p.SetState(1409)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 182, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1408)
				p.Match(TypeScriptParserAsync)
			}

		}
		p.SetState(1412)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserMultiply {
			{
				p.SetState(1411)
				p.Match(TypeScriptParserMultiply)
			}

		}
		{
			p.SetState(1414)
			p.PropertyName()
		}
		{
			p.SetState(1415)
			p.Match(TypeScriptParserOpenParen)
		}
		p.SetState(1417)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<TypeScriptParserOpenBracket)|(1<<TypeScriptParserOpenBrace)|(1<<TypeScriptParserEllipsis))) != 0) || (((_la-108)&-(0x1f+1)) == 0 && ((1<<uint((_la-108)))&((1<<(TypeScriptParserPrivate-108))|(1<<(TypeScriptParserPublic-108))|(1<<(TypeScriptParserProtected-108))|(1<<(TypeScriptParserIdentifier-108)))) != 0) {
			{
				p.SetState(1416)
				p.FormalParameterList()
			}

		}
		{
			p.SetState(1419)
			p.Match(TypeScriptParserCloseParen)
		}
		{
			p.SetState(1420)
			p.Match(TypeScriptParserOpenBrace)
		}
		{
			p.SetState(1421)
			p.FunctionBody()
		}
		{
			p.SetState(1422)
			p.Match(TypeScriptParserCloseBrace)
		}

	case 4:
		localctx = NewPropertyGetterContext(p, localctx)
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1424)
			p.GetAccessor()
		}

	case 5:
		localctx = NewPropertySetterContext(p, localctx)
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1425)
			p.SetAccessor()
		}

	case 6:
		localctx = NewMethodPropertyContext(p, localctx)
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1426)
			p.GeneratorMethod()
		}

	case 7:
		localctx = NewPropertyShorthandContext(p, localctx)
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1427)
			p.Match(TypeScriptParserIdentifier)
		}

	case 8:
		localctx = NewRestParameterInObjectContext(p, localctx)
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(1428)
			p.RestParameter()
		}

	}

	return localctx
}

// IGetAccessorContext is an interface to support dynamic dispatch.
type IGetAccessorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsGetAccessorContext differentiates from other interfaces.
	IsGetAccessorContext()
}

type GetAccessorContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGetAccessorContext() *GetAccessorContext {
	var p = new(GetAccessorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_getAccessor
	return p
}

func (*GetAccessorContext) IsGetAccessorContext() {}

func NewGetAccessorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GetAccessorContext {
	var p = new(GetAccessorContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_getAccessor

	return p
}

func (s *GetAccessorContext) GetParser() antlr.Parser { return s.parser }

func (s *GetAccessorContext) Getter() IGetterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGetterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGetterContext)
}

func (s *GetAccessorContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *GetAccessorContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *GetAccessorContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *GetAccessorContext) FunctionBody() IFunctionBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionBodyContext)
}

func (s *GetAccessorContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *GetAccessorContext) TypeAnnotation() ITypeAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAnnotationContext)
}

func (s *GetAccessorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GetAccessorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *GetAccessorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterGetAccessor(s)
	}
}

func (s *GetAccessorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitGetAccessor(s)
	}
}

func (p *TypeScriptParser) GetAccessor() (localctx IGetAccessorContext) {
	localctx = NewGetAccessorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 240, TypeScriptParserRULE_getAccessor)
	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(1431)
		p.Getter()
	}
	{
		p.SetState(1432)
		p.Match(TypeScriptParserOpenParen)
	}
	{
		p.SetState(1433)
		p.Match(TypeScriptParserCloseParen)
	}
	p.SetState(1435)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserColon {
		{
			p.SetState(1434)
			p.TypeAnnotation()
		}

	}
	{
		p.SetState(1437)
		p.Match(TypeScriptParserOpenBrace)
	}
	{
		p.SetState(1438)
		p.FunctionBody()
	}
	{
		p.SetState(1439)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

// ISetAccessorContext is an interface to support dynamic dispatch.
type ISetAccessorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSetAccessorContext differentiates from other interfaces.
	IsSetAccessorContext()
}

type SetAccessorContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySetAccessorContext() *SetAccessorContext {
	var p = new(SetAccessorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_setAccessor
	return p
}

func (*SetAccessorContext) IsSetAccessorContext() {}

func NewSetAccessorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetAccessorContext {
	var p = new(SetAccessorContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_setAccessor

	return p
}

func (s *SetAccessorContext) GetParser() antlr.Parser { return s.parser }

func (s *SetAccessorContext) Setter() ISetterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISetterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISetterContext)
}

func (s *SetAccessorContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *SetAccessorContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *SetAccessorContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *SetAccessorContext) FunctionBody() IFunctionBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionBodyContext)
}

func (s *SetAccessorContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *SetAccessorContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *SetAccessorContext) BindingPattern() IBindingPatternContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBindingPatternContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBindingPatternContext)
}

func (s *SetAccessorContext) TypeAnnotation() ITypeAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAnnotationContext)
}

func (s *SetAccessorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SetAccessorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SetAccessorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterSetAccessor(s)
	}
}

func (s *SetAccessorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitSetAccessor(s)
	}
}

func (p *TypeScriptParser) SetAccessor() (localctx ISetAccessorContext) {
	localctx = NewSetAccessorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 242, TypeScriptParserRULE_setAccessor)
	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(1441)
		p.Setter()
	}
	{
		p.SetState(1442)
		p.Match(TypeScriptParserOpenParen)
	}
	p.SetState(1445)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserIdentifier:
		{
			p.SetState(1443)
			p.Match(TypeScriptParserIdentifier)
		}

	case TypeScriptParserOpenBracket, TypeScriptParserOpenBrace:
		{
			p.SetState(1444)
			p.BindingPattern()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	p.SetState(1448)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserColon {
		{
			p.SetState(1447)
			p.TypeAnnotation()
		}

	}
	{
		p.SetState(1450)
		p.Match(TypeScriptParserCloseParen)
	}
	{
		p.SetState(1451)
		p.Match(TypeScriptParserOpenBrace)
	}
	{
		p.SetState(1452)
		p.FunctionBody()
	}
	{
		p.SetState(1453)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

// IPropertyNameContext is an interface to support dynamic dispatch.
type IPropertyNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPropertyNameContext differentiates from other interfaces.
	IsPropertyNameContext()
}

type PropertyNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPropertyNameContext() *PropertyNameContext {
	var p = new(PropertyNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_propertyName
	return p
}

func (*PropertyNameContext) IsPropertyNameContext() {}

func NewPropertyNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyNameContext {
	var p = new(PropertyNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_propertyName

	return p
}

func (s *PropertyNameContext) GetParser() antlr.Parser { return s.parser }

func (s *PropertyNameContext) IdentifierName() IIdentifierNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierNameContext)
}

func (s *PropertyNameContext) StringLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserStringLiteral, 0)
}

func (s *PropertyNameContext) NumericLiteral() INumericLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INumericLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INumericLiteralContext)
}

func (s *PropertyNameContext) OpenBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBracket, 0)
}

func (s *PropertyNameContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *PropertyNameContext) CloseBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBracket, 0)
}

func (s *PropertyNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PropertyNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PropertyNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPropertyName(s)
	}
}

func (s *PropertyNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPropertyName(s)
	}
}

func (p *TypeScriptParser) PropertyName() (localctx IPropertyNameContext) {
	localctx = NewPropertyNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 244, TypeScriptParserRULE_propertyName)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1462)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserNullLiteral, TypeScriptParserBooleanLiteral, TypeScriptParserBreak, TypeScriptParserDo, TypeScriptParserInstanceof, TypeScriptParserTypeof, TypeScriptParserCase, TypeScriptParserElse, TypeScriptParserNew, TypeScriptParserVar, TypeScriptParserCatch, TypeScriptParserFinally, TypeScriptParserReturn, TypeScriptParserVoid, TypeScriptParserContinue, TypeScriptParserFor, TypeScriptParserSwitch, TypeScriptParserWhile, TypeScriptParserDebugger, TypeScriptParserFunction, TypeScriptParserThis, TypeScriptParserWith, TypeScriptParserDefault, TypeScriptParserIf, TypeScriptParserThrow, TypeScriptParserDelete, TypeScriptParserIn, TypeScriptParserTry, TypeScriptParserAs, TypeScriptParserFrom, TypeScriptParserReadOnly, TypeScriptParserAsync, TypeScriptParserClass, TypeScriptParserEnum, TypeScriptParserExtends, TypeScriptParserSuper, TypeScriptParserConst, TypeScriptParserExport, TypeScriptParserImport, TypeScriptParserAwait, TypeScriptParserImplements, TypeScriptParserLet, TypeScriptParserPrivate, TypeScriptParserPublic, TypeScriptParserInterface, TypeScriptParserPackage, TypeScriptParserProtected, TypeScriptParserStatic, TypeScriptParserYield, TypeScriptParserIdentifier:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1455)
			p.IdentifierName()
		}

	case TypeScriptParserStringLiteral:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1456)
			p.Match(TypeScriptParserStringLiteral)
		}

	case TypeScriptParserDecimalLiteral, TypeScriptParserHexIntegerLiteral, TypeScriptParserOctalIntegerLiteral, TypeScriptParserOctalIntegerLiteral2, TypeScriptParserBinaryIntegerLiteral:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1457)
			p.NumericLiteral()
		}

	case TypeScriptParserOpenBracket:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1458)
			p.Match(TypeScriptParserOpenBracket)
		}
		{
			p.SetState(1459)
			p.singleExpression(0)
		}
		{
			p.SetState(1460)
			p.Match(TypeScriptParserCloseBracket)
		}

	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 = TypeScriptParserRULE_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 = TypeScriptParserRULE_arguments

	return p
}

func (s *ArgumentsContext) GetParser() antlr.Parser { return s.parser }

func (s *ArgumentsContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *ArgumentsContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *ArgumentsContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *ArgumentsContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *ArgumentsContext) LastArgument() ILastArgumentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILastArgumentContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILastArgumentContext)
}

func (s *ArgumentsContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *ArgumentsContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

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.(TypeScriptParserListener); ok {
		listenerT.EnterArguments(s)
	}
}

func (s *ArgumentsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitArguments(s)
	}
}

func (p *TypeScriptParser) Arguments() (localctx IArgumentsContext) {
	localctx = NewArgumentsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 246, TypeScriptParserRULE_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)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1464)
		p.Match(TypeScriptParserOpenParen)
	}
	p.SetState(1478)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserRegularExpressionLiteral, TypeScriptParserOpenBracket, TypeScriptParserOpenParen, TypeScriptParserOpenBrace, TypeScriptParserPlusPlus, TypeScriptParserMinusMinus, TypeScriptParserPlus, TypeScriptParserMinus, TypeScriptParserBitNot, TypeScriptParserNot, TypeScriptParserLessThan, TypeScriptParserNullLiteral, TypeScriptParserBooleanLiteral, TypeScriptParserDecimalLiteral, TypeScriptParserHexIntegerLiteral, TypeScriptParserOctalIntegerLiteral, TypeScriptParserOctalIntegerLiteral2, TypeScriptParserBinaryIntegerLiteral, TypeScriptParserBreak, TypeScriptParserDo, TypeScriptParserInstanceof, TypeScriptParserTypeof, TypeScriptParserCase, TypeScriptParserElse, TypeScriptParserNew, TypeScriptParserVar, TypeScriptParserCatch, TypeScriptParserFinally, TypeScriptParserReturn, TypeScriptParserVoid, TypeScriptParserContinue, TypeScriptParserFor, TypeScriptParserSwitch, TypeScriptParserWhile, TypeScriptParserDebugger, TypeScriptParserFunction, TypeScriptParserThis, TypeScriptParserWith, TypeScriptParserDefault, TypeScriptParserIf, TypeScriptParserThrow, TypeScriptParserDelete, TypeScriptParserIn, TypeScriptParserTry, TypeScriptParserAs, TypeScriptParserFrom, TypeScriptParserReadOnly, TypeScriptParserAsync, TypeScriptParserClass, TypeScriptParserEnum, TypeScriptParserExtends, TypeScriptParserSuper, TypeScriptParserConst, TypeScriptParserExport, TypeScriptParserImport, TypeScriptParserAwait, TypeScriptParserImplements, TypeScriptParserLet, TypeScriptParserPrivate, TypeScriptParserPublic, TypeScriptParserInterface, TypeScriptParserPackage, TypeScriptParserProtected, TypeScriptParserStatic, TypeScriptParserYield, TypeScriptParserIdentifier, TypeScriptParserStringLiteral, TypeScriptParserTemplateStringLiteral:
		{
			p.SetState(1465)
			p.singleExpression(0)
		}
		p.SetState(1470)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 190, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(1466)
					p.Match(TypeScriptParserComma)
				}
				{
					p.SetState(1467)
					p.singleExpression(0)
				}

			}
			p.SetState(1472)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 190, p.GetParserRuleContext())
		}
		p.SetState(1475)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserComma {
			{
				p.SetState(1473)
				p.Match(TypeScriptParserComma)
			}
			{
				p.SetState(1474)
				p.LastArgument()
			}

		}

	case TypeScriptParserEllipsis:
		{
			p.SetState(1477)
			p.LastArgument()
		}

	case TypeScriptParserCloseParen:

	default:
	}
	{
		p.SetState(1480)
		p.Match(TypeScriptParserCloseParen)
	}

	return localctx
}

// ILastArgumentContext is an interface to support dynamic dispatch.
type ILastArgumentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLastArgumentContext differentiates from other interfaces.
	IsLastArgumentContext()
}

type LastArgumentContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLastArgumentContext() *LastArgumentContext {
	var p = new(LastArgumentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_lastArgument
	return p
}

func (*LastArgumentContext) IsLastArgumentContext() {}

func NewLastArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LastArgumentContext {
	var p = new(LastArgumentContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_lastArgument

	return p
}

func (s *LastArgumentContext) GetParser() antlr.Parser { return s.parser }

func (s *LastArgumentContext) Ellipsis() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserEllipsis, 0)
}

func (s *LastArgumentContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *LastArgumentContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LastArgumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LastArgumentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterLastArgument(s)
	}
}

func (s *LastArgumentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitLastArgument(s)
	}
}

func (p *TypeScriptParser) LastArgument() (localctx ILastArgumentContext) {
	localctx = NewLastArgumentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 248, TypeScriptParserRULE_lastArgument)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1482)
		p.Match(TypeScriptParserEllipsis)
	}
	{
		p.SetState(1483)
		p.Match(TypeScriptParserIdentifier)
	}

	return localctx
}

// IExpressionSequenceContext is an interface to support dynamic dispatch.
type IExpressionSequenceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExpressionSequenceContext differentiates from other interfaces.
	IsExpressionSequenceContext()
}

type ExpressionSequenceContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExpressionSequenceContext() *ExpressionSequenceContext {
	var p = new(ExpressionSequenceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_expressionSequence
	return p
}

func (*ExpressionSequenceContext) IsExpressionSequenceContext() {}

func NewExpressionSequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionSequenceContext {
	var p = new(ExpressionSequenceContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_expressionSequence

	return p
}

func (s *ExpressionSequenceContext) GetParser() antlr.Parser { return s.parser }

func (s *ExpressionSequenceContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *ExpressionSequenceContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *ExpressionSequenceContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(TypeScriptParserComma)
}

func (s *ExpressionSequenceContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(TypeScriptParserComma, i)
}

func (s *ExpressionSequenceContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExpressionSequenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExpressionSequenceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterExpressionSequence(s)
	}
}

func (s *ExpressionSequenceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitExpressionSequence(s)
	}
}

func (p *TypeScriptParser) ExpressionSequence() (localctx IExpressionSequenceContext) {
	localctx = NewExpressionSequenceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 250, TypeScriptParserRULE_expressionSequence)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != 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(1485)
		p.singleExpression(0)
	}
	p.SetState(1490)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 193, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1486)
				p.Match(TypeScriptParserComma)
			}
			{
				p.SetState(1487)
				p.singleExpression(0)
			}

		}
		p.SetState(1492)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 193, p.GetParserRuleContext())
	}
	p.SetState(1494)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 194, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1493)
			p.Match(TypeScriptParserComma)
		}

	}

	return localctx
}

// IFunctionExpressionDeclarationContext is an interface to support dynamic dispatch.
type IFunctionExpressionDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunctionExpressionDeclarationContext differentiates from other interfaces.
	IsFunctionExpressionDeclarationContext()
}

type FunctionExpressionDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunctionExpressionDeclarationContext() *FunctionExpressionDeclarationContext {
	var p = new(FunctionExpressionDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_functionExpressionDeclaration
	return p
}

func (*FunctionExpressionDeclarationContext) IsFunctionExpressionDeclarationContext() {}

func NewFunctionExpressionDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionExpressionDeclarationContext {
	var p = new(FunctionExpressionDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_functionExpressionDeclaration

	return p
}

func (s *FunctionExpressionDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *FunctionExpressionDeclarationContext) Function() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserFunction, 0)
}

func (s *FunctionExpressionDeclarationContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *FunctionExpressionDeclarationContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *FunctionExpressionDeclarationContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *FunctionExpressionDeclarationContext) FunctionBody() IFunctionBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionBodyContext)
}

func (s *FunctionExpressionDeclarationContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *FunctionExpressionDeclarationContext) Async() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAsync, 0)
}

func (s *FunctionExpressionDeclarationContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *FunctionExpressionDeclarationContext) FormalParameterList() IFormalParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterListContext)
}

func (s *FunctionExpressionDeclarationContext) TypeAnnotation() ITypeAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAnnotationContext)
}

func (s *FunctionExpressionDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FunctionExpressionDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FunctionExpressionDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterFunctionExpressionDeclaration(s)
	}
}

func (s *FunctionExpressionDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitFunctionExpressionDeclaration(s)
	}
}

func (p *TypeScriptParser) FunctionExpressionDeclaration() (localctx IFunctionExpressionDeclarationContext) {
	localctx = NewFunctionExpressionDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 252, TypeScriptParserRULE_functionExpressionDeclaration)
	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(1497)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserAsync {
		{
			p.SetState(1496)
			p.Match(TypeScriptParserAsync)
		}

	}
	{
		p.SetState(1499)
		p.Match(TypeScriptParserFunction)
	}
	p.SetState(1501)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserIdentifier {
		{
			p.SetState(1500)
			p.Match(TypeScriptParserIdentifier)
		}

	}
	{
		p.SetState(1503)
		p.Match(TypeScriptParserOpenParen)
	}
	p.SetState(1505)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<TypeScriptParserOpenBracket)|(1<<TypeScriptParserOpenBrace)|(1<<TypeScriptParserEllipsis))) != 0) || (((_la-108)&-(0x1f+1)) == 0 && ((1<<uint((_la-108)))&((1<<(TypeScriptParserPrivate-108))|(1<<(TypeScriptParserPublic-108))|(1<<(TypeScriptParserProtected-108))|(1<<(TypeScriptParserIdentifier-108)))) != 0) {
		{
			p.SetState(1504)
			p.FormalParameterList()
		}

	}
	{
		p.SetState(1507)
		p.Match(TypeScriptParserCloseParen)
	}
	p.SetState(1509)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserColon {
		{
			p.SetState(1508)
			p.TypeAnnotation()
		}

	}
	{
		p.SetState(1511)
		p.Match(TypeScriptParserOpenBrace)
	}
	{
		p.SetState(1512)
		p.FunctionBody()
	}
	{
		p.SetState(1513)
		p.Match(TypeScriptParserCloseBrace)
	}

	return localctx
}

// ISingleExpressionContext is an interface to support dynamic dispatch.
type ISingleExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSingleExpressionContext differentiates from other interfaces.
	IsSingleExpressionContext()
}

type SingleExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySingleExpressionContext() *SingleExpressionContext {
	var p = new(SingleExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_singleExpression
	return p
}

func (*SingleExpressionContext) IsSingleExpressionContext() {}

func NewSingleExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleExpressionContext {
	var p = new(SingleExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_singleExpression

	return p
}

func (s *SingleExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *SingleExpressionContext) CopyFrom(ctx *SingleExpressionContext) {
	s.BaseParserRuleContext.CopyFrom(ctx.BaseParserRuleContext)
}

func (s *SingleExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SingleExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

type TemplateStringExpressionContext struct {
	*SingleExpressionContext
}

func NewTemplateStringExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TemplateStringExpressionContext {
	var p = new(TemplateStringExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *TemplateStringExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TemplateStringExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *TemplateStringExpressionContext) TemplateStringLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserTemplateStringLiteral, 0)
}

func (s *TemplateStringExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTemplateStringExpression(s)
	}
}

func (s *TemplateStringExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTemplateStringExpression(s)
	}
}

type GeneratorsExpressionContext struct {
	*SingleExpressionContext
}

func NewGeneratorsExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GeneratorsExpressionContext {
	var p = new(GeneratorsExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *GeneratorsExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GeneratorsExpressionContext) GeneratorBlock() IGeneratorBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGeneratorBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGeneratorBlockContext)
}

func (s *GeneratorsExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterGeneratorsExpression(s)
	}
}

func (s *GeneratorsExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitGeneratorsExpression(s)
	}
}

type PowerExpressionContext struct {
	*SingleExpressionContext
}

func NewPowerExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PowerExpressionContext {
	var p = new(PowerExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *PowerExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PowerExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *PowerExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *PowerExpressionContext) Power() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserPower, 0)
}

func (s *PowerExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPowerExpression(s)
	}
}

func (s *PowerExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPowerExpression(s)
	}
}

type InExpressionContext struct {
	*SingleExpressionContext
}

func NewInExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InExpressionContext {
	var p = new(InExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *InExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *InExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *InExpressionContext) In() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIn, 0)
}

func (s *InExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterInExpression(s)
	}
}

func (s *InExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitInExpression(s)
	}
}

type GenericTypesContext struct {
	*SingleExpressionContext
}

func NewGenericTypesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GenericTypesContext {
	var p = new(GenericTypesContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *GenericTypesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GenericTypesContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *GenericTypesContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *GenericTypesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterGenericTypes(s)
	}
}

func (s *GenericTypesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitGenericTypes(s)
	}
}

type ArgumentsExpressionContext struct {
	*SingleExpressionContext
}

func NewArgumentsExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArgumentsExpressionContext {
	var p = new(ArgumentsExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *ArgumentsExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArgumentsExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *ArgumentsExpressionContext) Arguments() IArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentsContext)
}

func (s *ArgumentsExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterArgumentsExpression(s)
	}
}

func (s *ArgumentsExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitArgumentsExpression(s)
	}
}

type ThisExpressionContext struct {
	*SingleExpressionContext
}

func NewThisExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ThisExpressionContext {
	var p = new(ThisExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *ThisExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ThisExpressionContext) This() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserThis, 0)
}

func (s *ThisExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterThisExpression(s)
	}
}

func (s *ThisExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitThisExpression(s)
	}
}

type TypeofExpressionContext struct {
	*SingleExpressionContext
}

func NewTypeofExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TypeofExpressionContext {
	var p = new(TypeofExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *TypeofExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypeofExpressionContext) Typeof() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserTypeof, 0)
}

func (s *TypeofExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *TypeofExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTypeofExpression(s)
	}
}

func (s *TypeofExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTypeofExpression(s)
	}
}

type GeneratorsFunctionExpressionContext struct {
	*SingleExpressionContext
}

func NewGeneratorsFunctionExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GeneratorsFunctionExpressionContext {
	var p = new(GeneratorsFunctionExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *GeneratorsFunctionExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GeneratorsFunctionExpressionContext) GeneratorFunctionDeclaration() IGeneratorFunctionDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGeneratorFunctionDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGeneratorFunctionDeclarationContext)
}

func (s *GeneratorsFunctionExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterGeneratorsFunctionExpression(s)
	}
}

func (s *GeneratorsFunctionExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitGeneratorsFunctionExpression(s)
	}
}

type EqualityExpressionContext struct {
	*SingleExpressionContext
}

func NewEqualityExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EqualityExpressionContext {
	var p = new(EqualityExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *EqualityExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EqualityExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *EqualityExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *EqualityExpressionContext) Equals_() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserEquals_, 0)
}

func (s *EqualityExpressionContext) NotEquals() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserNotEquals, 0)
}

func (s *EqualityExpressionContext) IdentityEquals() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentityEquals, 0)
}

func (s *EqualityExpressionContext) IdentityNotEquals() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentityNotEquals, 0)
}

func (s *EqualityExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterEqualityExpression(s)
	}
}

func (s *EqualityExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitEqualityExpression(s)
	}
}

type BitXOrExpressionContext struct {
	*SingleExpressionContext
}

func NewBitXOrExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitXOrExpressionContext {
	var p = new(BitXOrExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *BitXOrExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BitXOrExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *BitXOrExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *BitXOrExpressionContext) BitXOr() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBitXOr, 0)
}

func (s *BitXOrExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterBitXOrExpression(s)
	}
}

func (s *BitXOrExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitBitXOrExpression(s)
	}
}

type MultiplicativeExpressionContext struct {
	*SingleExpressionContext
}

func NewMultiplicativeExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MultiplicativeExpressionContext {
	var p = new(MultiplicativeExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *MultiplicativeExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MultiplicativeExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *MultiplicativeExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *MultiplicativeExpressionContext) Multiply() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMultiply, 0)
}

func (s *MultiplicativeExpressionContext) Divide() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDivide, 0)
}

func (s *MultiplicativeExpressionContext) Modulus() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserModulus, 0)
}

func (s *MultiplicativeExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterMultiplicativeExpression(s)
	}
}

func (s *MultiplicativeExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitMultiplicativeExpression(s)
	}
}

type BitShiftExpressionContext struct {
	*SingleExpressionContext
}

func NewBitShiftExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitShiftExpressionContext {
	var p = new(BitShiftExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *BitShiftExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BitShiftExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *BitShiftExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *BitShiftExpressionContext) LeftShiftArithmetic() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserLeftShiftArithmetic, 0)
}

func (s *BitShiftExpressionContext) RightShiftArithmetic() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserRightShiftArithmetic, 0)
}

func (s *BitShiftExpressionContext) RightShiftLogical() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserRightShiftLogical, 0)
}

func (s *BitShiftExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterBitShiftExpression(s)
	}
}

func (s *BitShiftExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitBitShiftExpression(s)
	}
}

type AdditiveExpressionContext struct {
	*SingleExpressionContext
}

func NewAdditiveExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdditiveExpressionContext {
	var p = new(AdditiveExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *AdditiveExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AdditiveExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *AdditiveExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *AdditiveExpressionContext) Plus() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserPlus, 0)
}

func (s *AdditiveExpressionContext) Minus() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMinus, 0)
}

func (s *AdditiveExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterAdditiveExpression(s)
	}
}

func (s *AdditiveExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitAdditiveExpression(s)
	}
}

type RelationalExpressionContext struct {
	*SingleExpressionContext
}

func NewRelationalExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RelationalExpressionContext {
	var p = new(RelationalExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *RelationalExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RelationalExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *RelationalExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *RelationalExpressionContext) LessThan() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserLessThan, 0)
}

func (s *RelationalExpressionContext) MoreThan() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMoreThan, 0)
}

func (s *RelationalExpressionContext) LessThanEquals() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserLessThanEquals, 0)
}

func (s *RelationalExpressionContext) GreaterThanEquals() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserGreaterThanEquals, 0)
}

func (s *RelationalExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterRelationalExpression(s)
	}
}

func (s *RelationalExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitRelationalExpression(s)
	}
}

type BitNotExpressionContext struct {
	*SingleExpressionContext
}

func NewBitNotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitNotExpressionContext {
	var p = new(BitNotExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *BitNotExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BitNotExpressionContext) BitNot() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBitNot, 0)
}

func (s *BitNotExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *BitNotExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterBitNotExpression(s)
	}
}

func (s *BitNotExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitBitNotExpression(s)
	}
}

type NewExpressionContext struct {
	*SingleExpressionContext
}

func NewNewExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NewExpressionContext {
	var p = new(NewExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *NewExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NewExpressionContext) New() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserNew, 0)
}

func (s *NewExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *NewExpressionContext) TypeArguments() ITypeArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeArgumentsContext)
}

func (s *NewExpressionContext) Arguments() IArgumentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentsContext)
}

func (s *NewExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterNewExpression(s)
	}
}

func (s *NewExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitNewExpression(s)
	}
}

type LiteralExpressionContext struct {
	*SingleExpressionContext
}

func NewLiteralExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LiteralExpressionContext {
	var p = new(LiteralExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *LiteralExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LiteralExpressionContext) Literal() ILiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteralContext)
}

func (s *LiteralExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterLiteralExpression(s)
	}
}

func (s *LiteralExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitLiteralExpression(s)
	}
}

type ArrayLiteralExpressionContext struct {
	*SingleExpressionContext
}

func NewArrayLiteralExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrayLiteralExpressionContext {
	var p = new(ArrayLiteralExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *ArrayLiteralExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArrayLiteralExpressionContext) ArrayLiteral() IArrayLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayLiteralContext)
}

func (s *ArrayLiteralExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterArrayLiteralExpression(s)
	}
}

func (s *ArrayLiteralExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitArrayLiteralExpression(s)
	}
}

type MemberDotExpressionContext struct {
	*SingleExpressionContext
}

func NewMemberDotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberDotExpressionContext {
	var p = new(MemberDotExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *MemberDotExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MemberDotExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *MemberDotExpressionContext) Dot() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDot, 0)
}

func (s *MemberDotExpressionContext) IdentifierName() IIdentifierNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierNameContext)
}

func (s *MemberDotExpressionContext) QuestionMark() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserQuestionMark, 0)
}

func (s *MemberDotExpressionContext) Hashtag() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserHashtag, 0)
}

func (s *MemberDotExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterMemberDotExpression(s)
	}
}

func (s *MemberDotExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitMemberDotExpression(s)
	}
}

type MemberIndexExpressionContext struct {
	*SingleExpressionContext
}

func NewMemberIndexExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberIndexExpressionContext {
	var p = new(MemberIndexExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *MemberIndexExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MemberIndexExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *MemberIndexExpressionContext) OpenBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBracket, 0)
}

func (s *MemberIndexExpressionContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *MemberIndexExpressionContext) CloseBracket() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBracket, 0)
}

func (s *MemberIndexExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterMemberIndexExpression(s)
	}
}

func (s *MemberIndexExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitMemberIndexExpression(s)
	}
}

type BitAndExpressionContext struct {
	*SingleExpressionContext
}

func NewBitAndExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitAndExpressionContext {
	var p = new(BitAndExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *BitAndExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BitAndExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *BitAndExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *BitAndExpressionContext) BitAnd() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBitAnd, 0)
}

func (s *BitAndExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterBitAndExpression(s)
	}
}

func (s *BitAndExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitBitAndExpression(s)
	}
}

type BitOrExpressionContext struct {
	*SingleExpressionContext
}

func NewBitOrExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitOrExpressionContext {
	var p = new(BitOrExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *BitOrExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BitOrExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *BitOrExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *BitOrExpressionContext) BitOr() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBitOr, 0)
}

func (s *BitOrExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterBitOrExpression(s)
	}
}

func (s *BitOrExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitBitOrExpression(s)
	}
}

type AssignmentOperatorExpressionContext struct {
	*SingleExpressionContext
}

func NewAssignmentOperatorExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignmentOperatorExpressionContext {
	var p = new(AssignmentOperatorExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *AssignmentOperatorExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssignmentOperatorExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *AssignmentOperatorExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *AssignmentOperatorExpressionContext) AssignmentOperator() IAssignmentOperatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentOperatorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentOperatorContext)
}

func (s *AssignmentOperatorExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterAssignmentOperatorExpression(s)
	}
}

func (s *AssignmentOperatorExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitAssignmentOperatorExpression(s)
	}
}

type VoidExpressionContext struct {
	*SingleExpressionContext
}

func NewVoidExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VoidExpressionContext {
	var p = new(VoidExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *VoidExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *VoidExpressionContext) Void() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserVoid, 0)
}

func (s *VoidExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *VoidExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterVoidExpression(s)
	}
}

func (s *VoidExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitVoidExpression(s)
	}
}

type TernaryExpressionContext struct {
	*SingleExpressionContext
}

func NewTernaryExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TernaryExpressionContext {
	var p = new(TernaryExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *TernaryExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TernaryExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *TernaryExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *TernaryExpressionContext) QuestionMark() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserQuestionMark, 0)
}

func (s *TernaryExpressionContext) Colon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserColon, 0)
}

func (s *TernaryExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterTernaryExpression(s)
	}
}

func (s *TernaryExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitTernaryExpression(s)
	}
}

type LogicalAndExpressionContext struct {
	*SingleExpressionContext
}

func NewLogicalAndExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalAndExpressionContext {
	var p = new(LogicalAndExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *LogicalAndExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LogicalAndExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *LogicalAndExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *LogicalAndExpressionContext) And() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAnd, 0)
}

func (s *LogicalAndExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterLogicalAndExpression(s)
	}
}

func (s *LogicalAndExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitLogicalAndExpression(s)
	}
}

type PreIncrementExpressionContext struct {
	*SingleExpressionContext
}

func NewPreIncrementExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PreIncrementExpressionContext {
	var p = new(PreIncrementExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *PreIncrementExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PreIncrementExpressionContext) PlusPlus() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserPlusPlus, 0)
}

func (s *PreIncrementExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *PreIncrementExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPreIncrementExpression(s)
	}
}

func (s *PreIncrementExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPreIncrementExpression(s)
	}
}

type ObjectLiteralExpressionContext struct {
	*SingleExpressionContext
}

func NewObjectLiteralExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ObjectLiteralExpressionContext {
	var p = new(ObjectLiteralExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *ObjectLiteralExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ObjectLiteralExpressionContext) ObjectLiteral() IObjectLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IObjectLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IObjectLiteralContext)
}

func (s *ObjectLiteralExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterObjectLiteralExpression(s)
	}
}

func (s *ObjectLiteralExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitObjectLiteralExpression(s)
	}
}

type LogicalOrExpressionContext struct {
	*SingleExpressionContext
}

func NewLogicalOrExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalOrExpressionContext {
	var p = new(LogicalOrExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *LogicalOrExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LogicalOrExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *LogicalOrExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *LogicalOrExpressionContext) Or() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOr, 0)
}

func (s *LogicalOrExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterLogicalOrExpression(s)
	}
}

func (s *LogicalOrExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitLogicalOrExpression(s)
	}
}

type NotExpressionContext struct {
	*SingleExpressionContext
}

func NewNotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NotExpressionContext {
	var p = new(NotExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *NotExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NotExpressionContext) Not() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserNot, 0)
}

func (s *NotExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *NotExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterNotExpression(s)
	}
}

func (s *NotExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitNotExpression(s)
	}
}

type PreDecreaseExpressionContext struct {
	*SingleExpressionContext
}

func NewPreDecreaseExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PreDecreaseExpressionContext {
	var p = new(PreDecreaseExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *PreDecreaseExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PreDecreaseExpressionContext) MinusMinus() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMinusMinus, 0)
}

func (s *PreDecreaseExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *PreDecreaseExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPreDecreaseExpression(s)
	}
}

func (s *PreDecreaseExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPreDecreaseExpression(s)
	}
}

type AwaitExpressionContext struct {
	*SingleExpressionContext
}

func NewAwaitExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AwaitExpressionContext {
	var p = new(AwaitExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *AwaitExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AwaitExpressionContext) Await() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAwait, 0)
}

func (s *AwaitExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *AwaitExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterAwaitExpression(s)
	}
}

func (s *AwaitExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitAwaitExpression(s)
	}
}

type FunctionExpressionContext struct {
	*SingleExpressionContext
}

func NewFunctionExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FunctionExpressionContext {
	var p = new(FunctionExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *FunctionExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FunctionExpressionContext) FunctionExpressionDeclaration() IFunctionExpressionDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionExpressionDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionExpressionDeclarationContext)
}

func (s *FunctionExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterFunctionExpression(s)
	}
}

func (s *FunctionExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitFunctionExpression(s)
	}
}

type UnaryMinusExpressionContext struct {
	*SingleExpressionContext
}

func NewUnaryMinusExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryMinusExpressionContext {
	var p = new(UnaryMinusExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *UnaryMinusExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnaryMinusExpressionContext) Minus() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMinus, 0)
}

func (s *UnaryMinusExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *UnaryMinusExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterUnaryMinusExpression(s)
	}
}

func (s *UnaryMinusExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitUnaryMinusExpression(s)
	}
}

type AssignmentExpressionContext struct {
	*SingleExpressionContext
}

func NewAssignmentExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AssignmentExpressionContext {
	var p = new(AssignmentExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *AssignmentExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssignmentExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *AssignmentExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *AssignmentExpressionContext) Assign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAssign, 0)
}

func (s *AssignmentExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterAssignmentExpression(s)
	}
}

func (s *AssignmentExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitAssignmentExpression(s)
	}
}

type PostDecreaseExpressionContext struct {
	*SingleExpressionContext
}

func NewPostDecreaseExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PostDecreaseExpressionContext {
	var p = new(PostDecreaseExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *PostDecreaseExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PostDecreaseExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *PostDecreaseExpressionContext) MinusMinus() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMinusMinus, 0)
}

func (s *PostDecreaseExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPostDecreaseExpression(s)
	}
}

func (s *PostDecreaseExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPostDecreaseExpression(s)
	}
}

type InstanceofExpressionContext struct {
	*SingleExpressionContext
}

func NewInstanceofExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InstanceofExpressionContext {
	var p = new(InstanceofExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *InstanceofExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InstanceofExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *InstanceofExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *InstanceofExpressionContext) Instanceof() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserInstanceof, 0)
}

func (s *InstanceofExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterInstanceofExpression(s)
	}
}

func (s *InstanceofExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitInstanceofExpression(s)
	}
}

type UnaryPlusExpressionContext struct {
	*SingleExpressionContext
}

func NewUnaryPlusExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnaryPlusExpressionContext {
	var p = new(UnaryPlusExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *UnaryPlusExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnaryPlusExpressionContext) Plus() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserPlus, 0)
}

func (s *UnaryPlusExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *UnaryPlusExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterUnaryPlusExpression(s)
	}
}

func (s *UnaryPlusExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitUnaryPlusExpression(s)
	}
}

type DeleteExpressionContext struct {
	*SingleExpressionContext
}

func NewDeleteExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DeleteExpressionContext {
	var p = new(DeleteExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *DeleteExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DeleteExpressionContext) Delete() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDelete, 0)
}

func (s *DeleteExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *DeleteExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterDeleteExpression(s)
	}
}

func (s *DeleteExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitDeleteExpression(s)
	}
}

type ArrowFunctionExpressionContext struct {
	*SingleExpressionContext
}

func NewArrowFunctionExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrowFunctionExpressionContext {
	var p = new(ArrowFunctionExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *ArrowFunctionExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArrowFunctionExpressionContext) ArrowFunctionDeclaration() IArrowFunctionDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrowFunctionDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrowFunctionDeclarationContext)
}

func (s *ArrowFunctionExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterArrowFunctionExpression(s)
	}
}

func (s *ArrowFunctionExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitArrowFunctionExpression(s)
	}
}

type IteratorsExpressionContext struct {
	*SingleExpressionContext
}

func NewIteratorsExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IteratorsExpressionContext {
	var p = new(IteratorsExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *IteratorsExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IteratorsExpressionContext) IteratorBlock() IIteratorBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIteratorBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIteratorBlockContext)
}

func (s *IteratorsExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterIteratorsExpression(s)
	}
}

func (s *IteratorsExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitIteratorsExpression(s)
	}
}

type SuperExpressionContext struct {
	*SingleExpressionContext
}

func NewSuperExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SuperExpressionContext {
	var p = new(SuperExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *SuperExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SuperExpressionContext) Super() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSuper, 0)
}

func (s *SuperExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterSuperExpression(s)
	}
}

func (s *SuperExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitSuperExpression(s)
	}
}

type ParenthesizedExpressionContext struct {
	*SingleExpressionContext
}

func NewParenthesizedExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParenthesizedExpressionContext {
	var p = new(ParenthesizedExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *ParenthesizedExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ParenthesizedExpressionContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *ParenthesizedExpressionContext) ExpressionSequence() IExpressionSequenceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionSequenceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionSequenceContext)
}

func (s *ParenthesizedExpressionContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *ParenthesizedExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterParenthesizedExpression(s)
	}
}

func (s *ParenthesizedExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitParenthesizedExpression(s)
	}
}

type PostIncrementExpressionContext struct {
	*SingleExpressionContext
}

func NewPostIncrementExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PostIncrementExpressionContext {
	var p = new(PostIncrementExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *PostIncrementExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PostIncrementExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *PostIncrementExpressionContext) PlusPlus() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserPlusPlus, 0)
}

func (s *PostIncrementExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterPostIncrementExpression(s)
	}
}

func (s *PostIncrementExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitPostIncrementExpression(s)
	}
}

type YieldExpressionContext struct {
	*SingleExpressionContext
}

func NewYieldExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *YieldExpressionContext {
	var p = new(YieldExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *YieldExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *YieldExpressionContext) YieldStatement() IYieldStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IYieldStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IYieldStatementContext)
}

func (s *YieldExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterYieldExpression(s)
	}
}

func (s *YieldExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitYieldExpression(s)
	}
}

type ClassExpressionContext struct {
	*SingleExpressionContext
}

func NewClassExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ClassExpressionContext {
	var p = new(ClassExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *ClassExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClassExpressionContext) Class() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserClass, 0)
}

func (s *ClassExpressionContext) ClassTail() IClassTailContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClassTailContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClassTailContext)
}

func (s *ClassExpressionContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *ClassExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterClassExpression(s)
	}
}

func (s *ClassExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitClassExpression(s)
	}
}

type IdentifierExpressionContext struct {
	*SingleExpressionContext
}

func NewIdentifierExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentifierExpressionContext {
	var p = new(IdentifierExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *IdentifierExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IdentifierExpressionContext) IdentifierName() IIdentifierNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierNameContext)
}

func (s *IdentifierExpressionContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *IdentifierExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterIdentifierExpression(s)
	}
}

func (s *IdentifierExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitIdentifierExpression(s)
	}
}

type CoalesceExpressionContext struct {
	*SingleExpressionContext
}

func NewCoalesceExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CoalesceExpressionContext {
	var p = new(CoalesceExpressionContext)

	p.SingleExpressionContext = NewEmptySingleExpressionContext()
	p.parser = parser
	p.CopyFrom(ctx.(*SingleExpressionContext))

	return p
}

func (s *CoalesceExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CoalesceExpressionContext) AllSingleExpression() []ISingleExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem())
	var tst = make([]ISingleExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISingleExpressionContext)
		}
	}

	return tst
}

func (s *CoalesceExpressionContext) SingleExpression(i int) ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *CoalesceExpressionContext) NullCoalesce() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserNullCoalesce, 0)
}

func (s *CoalesceExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterCoalesceExpression(s)
	}
}

func (s *CoalesceExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitCoalesceExpression(s)
	}
}

func (p *TypeScriptParser) SingleExpression() (localctx ISingleExpressionContext) {
	return p.singleExpression(0)
}

func (p *TypeScriptParser) singleExpression(_p int) (localctx ISingleExpressionContext) {
	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewSingleExpressionContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx ISingleExpressionContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 254
	p.EnterRecursionRule(localctx, 254, TypeScriptParserRULE_singleExpression, _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(1572)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 204, p.GetParserRuleContext()) {
	case 1:
		localctx = NewFunctionExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx

		{
			p.SetState(1516)
			p.FunctionExpressionDeclaration()
		}

	case 2:
		localctx = NewArrowFunctionExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1517)
			p.ArrowFunctionDeclaration()
		}

	case 3:
		localctx = NewClassExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1518)
			p.Match(TypeScriptParserClass)
		}
		p.SetState(1520)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == TypeScriptParserIdentifier {
			{
				p.SetState(1519)
				p.Match(TypeScriptParserIdentifier)
			}

		}
		{
			p.SetState(1522)
			p.ClassTail()
		}

	case 4:
		localctx = NewNewExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1523)
			p.Match(TypeScriptParserNew)
		}
		{
			p.SetState(1524)
			p.singleExpression(0)
		}
		p.SetState(1526)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 200, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1525)
				p.TypeArguments()
			}

		}
		p.SetState(1529)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 201, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1528)
				p.Arguments()
			}

		}

	case 5:
		localctx = NewDeleteExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1531)
			p.Match(TypeScriptParserDelete)
		}
		{
			p.SetState(1532)
			p.singleExpression(40)
		}

	case 6:
		localctx = NewVoidExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1533)
			p.Match(TypeScriptParserVoid)
		}
		{
			p.SetState(1534)
			p.singleExpression(39)
		}

	case 7:
		localctx = NewTypeofExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1535)
			p.Match(TypeScriptParserTypeof)
		}
		{
			p.SetState(1536)
			p.singleExpression(38)
		}

	case 8:
		localctx = NewPreIncrementExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1537)
			p.Match(TypeScriptParserPlusPlus)
		}
		{
			p.SetState(1538)
			p.singleExpression(37)
		}

	case 9:
		localctx = NewPreDecreaseExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1539)
			p.Match(TypeScriptParserMinusMinus)
		}
		{
			p.SetState(1540)
			p.singleExpression(36)
		}

	case 10:
		localctx = NewUnaryPlusExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1541)
			p.Match(TypeScriptParserPlus)
		}
		{
			p.SetState(1542)
			p.singleExpression(35)
		}

	case 11:
		localctx = NewUnaryMinusExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1543)
			p.Match(TypeScriptParserMinus)
		}
		{
			p.SetState(1544)
			p.singleExpression(34)
		}

	case 12:
		localctx = NewBitNotExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1545)
			p.Match(TypeScriptParserBitNot)
		}
		{
			p.SetState(1546)
			p.singleExpression(33)
		}

	case 13:
		localctx = NewNotExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1547)
			p.Match(TypeScriptParserNot)
		}
		{
			p.SetState(1548)
			p.singleExpression(32)
		}

	case 14:
		localctx = NewAwaitExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1549)
			p.Match(TypeScriptParserAwait)
		}
		{
			p.SetState(1550)
			p.singleExpression(31)
		}

	case 15:
		localctx = NewIteratorsExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1551)
			p.IteratorBlock()
		}

	case 16:
		localctx = NewGeneratorsExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1552)
			p.GeneratorBlock()
		}

	case 17:
		localctx = NewGeneratorsFunctionExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1553)
			p.GeneratorFunctionDeclaration()
		}

	case 18:
		localctx = NewYieldExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1554)
			p.YieldStatement()
		}

	case 19:
		localctx = NewThisExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1555)
			p.Match(TypeScriptParserThis)
		}

	case 20:
		localctx = NewIdentifierExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1556)
			p.IdentifierName()
		}
		p.SetState(1558)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 202, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1557)
				p.singleExpression(0)
			}

		}

	case 21:
		localctx = NewSuperExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1560)
			p.Match(TypeScriptParserSuper)
		}

	case 22:
		localctx = NewLiteralExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1561)
			p.Literal()
		}

	case 23:
		localctx = NewArrayLiteralExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1562)
			p.ArrayLiteral()
		}

	case 24:
		localctx = NewObjectLiteralExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1563)
			p.ObjectLiteral()
		}

	case 25:
		localctx = NewParenthesizedExpressionContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1564)
			p.Match(TypeScriptParserOpenParen)
		}
		{
			p.SetState(1565)
			p.ExpressionSequence()
		}
		{
			p.SetState(1566)
			p.Match(TypeScriptParserCloseParen)
		}

	case 26:
		localctx = NewGenericTypesContext(p, localctx)
		p.SetParserRuleContext(localctx)
		_prevctx = localctx
		{
			p.SetState(1568)
			p.TypeArguments()
		}
		p.SetState(1570)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 203, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1569)
				p.ExpressionSequence()
			}

		}

	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(1655)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 208, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(1653)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 207, p.GetParserRuleContext()) {
			case 1:
				localctx = NewPowerExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1574)

				if !(p.Precpred(p.GetParserRuleContext(), 30)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 30)", ""))
				}
				{
					p.SetState(1575)
					p.Match(TypeScriptParserPower)
				}
				{
					p.SetState(1576)
					p.singleExpression(30)
				}

			case 2:
				localctx = NewMultiplicativeExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1577)

				if !(p.Precpred(p.GetParserRuleContext(), 29)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 29)", ""))
				}
				{
					p.SetState(1578)
					_la = p.GetTokenStream().LA(1)

					if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<TypeScriptParserMultiply)|(1<<TypeScriptParserDivide)|(1<<TypeScriptParserModulus))) != 0) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1579)
					p.singleExpression(30)
				}

			case 3:
				localctx = NewAdditiveExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1580)

				if !(p.Precpred(p.GetParserRuleContext(), 28)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 28)", ""))
				}
				{
					p.SetState(1581)
					_la = p.GetTokenStream().LA(1)

					if !(_la == TypeScriptParserPlus || _la == TypeScriptParserMinus) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1582)
					p.singleExpression(29)
				}

			case 4:
				localctx = NewBitShiftExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1583)

				if !(p.Precpred(p.GetParserRuleContext(), 27)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 27)", ""))
				}
				{
					p.SetState(1584)
					_la = p.GetTokenStream().LA(1)

					if !(((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(TypeScriptParserRightShiftArithmetic-32))|(1<<(TypeScriptParserLeftShiftArithmetic-32))|(1<<(TypeScriptParserRightShiftLogical-32)))) != 0) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1585)
					p.singleExpression(28)
				}

			case 5:
				localctx = NewRelationalExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1586)

				if !(p.Precpred(p.GetParserRuleContext(), 26)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 26)", ""))
				}
				{
					p.SetState(1587)
					_la = p.GetTokenStream().LA(1)

					if !(((_la-35)&-(0x1f+1)) == 0 && ((1<<uint((_la-35)))&((1<<(TypeScriptParserLessThan-35))|(1<<(TypeScriptParserMoreThan-35))|(1<<(TypeScriptParserLessThanEquals-35))|(1<<(TypeScriptParserGreaterThanEquals-35)))) != 0) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1588)
					p.singleExpression(27)
				}

			case 6:
				localctx = NewInstanceofExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1589)

				if !(p.Precpred(p.GetParserRuleContext(), 25)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 25)", ""))
				}
				{
					p.SetState(1590)
					p.Match(TypeScriptParserInstanceof)
				}
				{
					p.SetState(1591)
					p.singleExpression(26)
				}

			case 7:
				localctx = NewInExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1592)

				if !(p.Precpred(p.GetParserRuleContext(), 24)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 24)", ""))
				}
				{
					p.SetState(1593)
					p.Match(TypeScriptParserIn)
				}
				{
					p.SetState(1594)
					p.singleExpression(25)
				}

			case 8:
				localctx = NewEqualityExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1595)

				if !(p.Precpred(p.GetParserRuleContext(), 23)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 23)", ""))
				}
				{
					p.SetState(1596)
					_la = p.GetTokenStream().LA(1)

					if !(((_la-39)&-(0x1f+1)) == 0 && ((1<<uint((_la-39)))&((1<<(TypeScriptParserEquals_-39))|(1<<(TypeScriptParserNotEquals-39))|(1<<(TypeScriptParserIdentityEquals-39))|(1<<(TypeScriptParserIdentityNotEquals-39)))) != 0) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1597)
					p.singleExpression(24)
				}

			case 9:
				localctx = NewBitAndExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1598)

				if !(p.Precpred(p.GetParserRuleContext(), 22)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 22)", ""))
				}
				{
					p.SetState(1599)
					p.Match(TypeScriptParserBitAnd)
				}
				{
					p.SetState(1600)
					p.singleExpression(23)
				}

			case 10:
				localctx = NewBitXOrExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1601)

				if !(p.Precpred(p.GetParserRuleContext(), 21)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 21)", ""))
				}
				{
					p.SetState(1602)
					p.Match(TypeScriptParserBitXOr)
				}
				{
					p.SetState(1603)
					p.singleExpression(22)
				}

			case 11:
				localctx = NewBitOrExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1604)

				if !(p.Precpred(p.GetParserRuleContext(), 20)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 20)", ""))
				}
				{
					p.SetState(1605)
					p.Match(TypeScriptParserBitOr)
				}
				{
					p.SetState(1606)
					p.singleExpression(21)
				}

			case 12:
				localctx = NewLogicalAndExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1607)

				if !(p.Precpred(p.GetParserRuleContext(), 19)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 19)", ""))
				}
				{
					p.SetState(1608)
					p.Match(TypeScriptParserAnd)
				}
				{
					p.SetState(1609)
					p.singleExpression(20)
				}

			case 13:
				localctx = NewLogicalOrExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1610)

				if !(p.Precpred(p.GetParserRuleContext(), 18)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 18)", ""))
				}
				{
					p.SetState(1611)
					p.Match(TypeScriptParserOr)
				}
				{
					p.SetState(1612)
					p.singleExpression(19)
				}

			case 14:
				localctx = NewTernaryExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1613)

				if !(p.Precpred(p.GetParserRuleContext(), 17)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 17)", ""))
				}
				{
					p.SetState(1614)
					p.Match(TypeScriptParserQuestionMark)
				}
				{
					p.SetState(1615)
					p.singleExpression(0)
				}
				{
					p.SetState(1616)
					p.Match(TypeScriptParserColon)
				}
				{
					p.SetState(1617)
					p.singleExpression(18)
				}

			case 15:
				localctx = NewCoalesceExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1619)

				if !(p.Precpred(p.GetParserRuleContext(), 16)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 16)", ""))
				}
				{
					p.SetState(1620)
					p.Match(TypeScriptParserNullCoalesce)
				}
				{
					p.SetState(1621)
					p.singleExpression(17)
				}

			case 16:
				localctx = NewAssignmentExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1622)

				if !(p.Precpred(p.GetParserRuleContext(), 15)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 15)", ""))
				}
				{
					p.SetState(1623)
					p.Match(TypeScriptParserAssign)
				}
				{
					p.SetState(1624)
					p.singleExpression(15)
				}

			case 17:
				localctx = NewAssignmentOperatorExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1625)

				if !(p.Precpred(p.GetParserRuleContext(), 14)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", ""))
				}
				{
					p.SetState(1626)
					p.AssignmentOperator()
				}
				{
					p.SetState(1627)
					p.singleExpression(14)
				}

			case 18:
				localctx = NewMemberIndexExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1629)

				if !(p.Precpred(p.GetParserRuleContext(), 46)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 46)", ""))
				}
				{
					p.SetState(1630)
					p.Match(TypeScriptParserOpenBracket)
				}
				{
					p.SetState(1631)
					p.ExpressionSequence()
				}
				{
					p.SetState(1632)
					p.Match(TypeScriptParserCloseBracket)
				}

			case 19:
				localctx = NewMemberDotExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1634)

				if !(p.Precpred(p.GetParserRuleContext(), 45)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 45)", ""))
				}
				p.SetState(1636)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == TypeScriptParserQuestionMark {
					{
						p.SetState(1635)
						p.Match(TypeScriptParserQuestionMark)
					}

				}
				{
					p.SetState(1638)
					p.Match(TypeScriptParserDot)
				}
				p.SetState(1640)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == TypeScriptParserHashtag {
					{
						p.SetState(1639)
						p.Match(TypeScriptParserHashtag)
					}

				}
				{
					p.SetState(1642)
					p.IdentifierName()
				}

			case 20:
				localctx = NewArgumentsExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1643)

				if !(p.Precpred(p.GetParserRuleContext(), 44)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 44)", ""))
				}
				{
					p.SetState(1644)
					p.Arguments()
				}

			case 21:
				localctx = NewPostIncrementExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1645)

				if !(p.Precpred(p.GetParserRuleContext(), 42)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 42)", ""))
				}
				p.SetState(1646)

				if !(p.notLineTerminator()) {
					panic(antlr.NewFailedPredicateException(p, "p.notLineTerminator()", ""))
				}
				{
					p.SetState(1647)
					p.Match(TypeScriptParserPlusPlus)
				}

			case 22:
				localctx = NewPostDecreaseExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1648)

				if !(p.Precpred(p.GetParserRuleContext(), 41)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 41)", ""))
				}
				p.SetState(1649)

				if !(p.notLineTerminator()) {
					panic(antlr.NewFailedPredicateException(p, "p.notLineTerminator()", ""))
				}
				{
					p.SetState(1650)
					p.Match(TypeScriptParserMinusMinus)
				}

			case 23:
				localctx = NewTemplateStringExpressionContext(p, NewSingleExpressionContext(p, _parentctx, _parentState))
				p.PushNewRecursionContext(localctx, _startState, TypeScriptParserRULE_singleExpression)
				p.SetState(1651)

				if !(p.Precpred(p.GetParserRuleContext(), 13)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 13)", ""))
				}
				{
					p.SetState(1652)
					p.Match(TypeScriptParserTemplateStringLiteral)
				}

			}

		}
		p.SetState(1657)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 208, p.GetParserRuleContext())
	}

	return localctx
}

// IArrowFunctionDeclarationContext is an interface to support dynamic dispatch.
type IArrowFunctionDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArrowFunctionDeclarationContext differentiates from other interfaces.
	IsArrowFunctionDeclarationContext()
}

type ArrowFunctionDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArrowFunctionDeclarationContext() *ArrowFunctionDeclarationContext {
	var p = new(ArrowFunctionDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_arrowFunctionDeclaration
	return p
}

func (*ArrowFunctionDeclarationContext) IsArrowFunctionDeclarationContext() {}

func NewArrowFunctionDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrowFunctionDeclarationContext {
	var p = new(ArrowFunctionDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_arrowFunctionDeclaration

	return p
}

func (s *ArrowFunctionDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *ArrowFunctionDeclarationContext) ArrowFunctionParameters() IArrowFunctionParametersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrowFunctionParametersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrowFunctionParametersContext)
}

func (s *ArrowFunctionDeclarationContext) ARROW() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserARROW, 0)
}

func (s *ArrowFunctionDeclarationContext) ArrowFunctionBody() IArrowFunctionBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrowFunctionBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrowFunctionBodyContext)
}

func (s *ArrowFunctionDeclarationContext) Async() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAsync, 0)
}

func (s *ArrowFunctionDeclarationContext) TypeAnnotation() ITypeAnnotationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAnnotationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeAnnotationContext)
}

func (s *ArrowFunctionDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArrowFunctionDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArrowFunctionDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterArrowFunctionDeclaration(s)
	}
}

func (s *ArrowFunctionDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitArrowFunctionDeclaration(s)
	}
}

func (p *TypeScriptParser) ArrowFunctionDeclaration() (localctx IArrowFunctionDeclarationContext) {
	localctx = NewArrowFunctionDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 256, TypeScriptParserRULE_arrowFunctionDeclaration)
	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(1659)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserAsync {
		{
			p.SetState(1658)
			p.Match(TypeScriptParserAsync)
		}

	}
	{
		p.SetState(1661)
		p.ArrowFunctionParameters()
	}
	p.SetState(1663)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == TypeScriptParserColon {
		{
			p.SetState(1662)
			p.TypeAnnotation()
		}

	}
	{
		p.SetState(1665)
		p.Match(TypeScriptParserARROW)
	}
	{
		p.SetState(1666)
		p.ArrowFunctionBody()
	}

	return localctx
}

// IArrowFunctionParametersContext is an interface to support dynamic dispatch.
type IArrowFunctionParametersContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArrowFunctionParametersContext differentiates from other interfaces.
	IsArrowFunctionParametersContext()
}

type ArrowFunctionParametersContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArrowFunctionParametersContext() *ArrowFunctionParametersContext {
	var p = new(ArrowFunctionParametersContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_arrowFunctionParameters
	return p
}

func (*ArrowFunctionParametersContext) IsArrowFunctionParametersContext() {}

func NewArrowFunctionParametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrowFunctionParametersContext {
	var p = new(ArrowFunctionParametersContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_arrowFunctionParameters

	return p
}

func (s *ArrowFunctionParametersContext) GetParser() antlr.Parser { return s.parser }

func (s *ArrowFunctionParametersContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *ArrowFunctionParametersContext) OpenParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenParen, 0)
}

func (s *ArrowFunctionParametersContext) CloseParen() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseParen, 0)
}

func (s *ArrowFunctionParametersContext) FormalParameterList() IFormalParameterListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFormalParameterListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFormalParameterListContext)
}

func (s *ArrowFunctionParametersContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArrowFunctionParametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArrowFunctionParametersContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterArrowFunctionParameters(s)
	}
}

func (s *ArrowFunctionParametersContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitArrowFunctionParameters(s)
	}
}

func (p *TypeScriptParser) ArrowFunctionParameters() (localctx IArrowFunctionParametersContext) {
	localctx = NewArrowFunctionParametersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 258, TypeScriptParserRULE_arrowFunctionParameters)
	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(1674)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserIdentifier:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1668)
			p.Match(TypeScriptParserIdentifier)
		}

	case TypeScriptParserOpenParen:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1669)
			p.Match(TypeScriptParserOpenParen)
		}
		p.SetState(1671)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<TypeScriptParserOpenBracket)|(1<<TypeScriptParserOpenBrace)|(1<<TypeScriptParserEllipsis))) != 0) || (((_la-108)&-(0x1f+1)) == 0 && ((1<<uint((_la-108)))&((1<<(TypeScriptParserPrivate-108))|(1<<(TypeScriptParserPublic-108))|(1<<(TypeScriptParserProtected-108))|(1<<(TypeScriptParserIdentifier-108)))) != 0) {
			{
				p.SetState(1670)
				p.FormalParameterList()
			}

		}
		{
			p.SetState(1673)
			p.Match(TypeScriptParserCloseParen)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IArrowFunctionBodyContext is an interface to support dynamic dispatch.
type IArrowFunctionBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArrowFunctionBodyContext differentiates from other interfaces.
	IsArrowFunctionBodyContext()
}

type ArrowFunctionBodyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyArrowFunctionBodyContext() *ArrowFunctionBodyContext {
	var p = new(ArrowFunctionBodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_arrowFunctionBody
	return p
}

func (*ArrowFunctionBodyContext) IsArrowFunctionBodyContext() {}

func NewArrowFunctionBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrowFunctionBodyContext {
	var p = new(ArrowFunctionBodyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_arrowFunctionBody

	return p
}

func (s *ArrowFunctionBodyContext) GetParser() antlr.Parser { return s.parser }

func (s *ArrowFunctionBodyContext) SingleExpression() ISingleExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISingleExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISingleExpressionContext)
}

func (s *ArrowFunctionBodyContext) OpenBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOpenBrace, 0)
}

func (s *ArrowFunctionBodyContext) FunctionBody() IFunctionBodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionBodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionBodyContext)
}

func (s *ArrowFunctionBodyContext) CloseBrace() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCloseBrace, 0)
}

func (s *ArrowFunctionBodyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ArrowFunctionBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ArrowFunctionBodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterArrowFunctionBody(s)
	}
}

func (s *ArrowFunctionBodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitArrowFunctionBody(s)
	}
}

func (p *TypeScriptParser) ArrowFunctionBody() (localctx IArrowFunctionBodyContext) {
	localctx = NewArrowFunctionBodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 260, TypeScriptParserRULE_arrowFunctionBody)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1681)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 213, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1676)
			p.singleExpression(0)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1677)
			p.Match(TypeScriptParserOpenBrace)
		}
		{
			p.SetState(1678)
			p.FunctionBody()
		}
		{
			p.SetState(1679)
			p.Match(TypeScriptParserCloseBrace)
		}

	}

	return localctx
}

// IAssignmentOperatorContext is an interface to support dynamic dispatch.
type IAssignmentOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssignmentOperatorContext differentiates from other interfaces.
	IsAssignmentOperatorContext()
}

type AssignmentOperatorContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssignmentOperatorContext() *AssignmentOperatorContext {
	var p = new(AssignmentOperatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_assignmentOperator
	return p
}

func (*AssignmentOperatorContext) IsAssignmentOperatorContext() {}

func NewAssignmentOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentOperatorContext {
	var p = new(AssignmentOperatorContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_assignmentOperator

	return p
}

func (s *AssignmentOperatorContext) GetParser() antlr.Parser { return s.parser }

func (s *AssignmentOperatorContext) MultiplyAssign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMultiplyAssign, 0)
}

func (s *AssignmentOperatorContext) DivideAssign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDivideAssign, 0)
}

func (s *AssignmentOperatorContext) ModulusAssign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserModulusAssign, 0)
}

func (s *AssignmentOperatorContext) PlusAssign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserPlusAssign, 0)
}

func (s *AssignmentOperatorContext) MinusAssign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserMinusAssign, 0)
}

func (s *AssignmentOperatorContext) LeftShiftArithmeticAssign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserLeftShiftArithmeticAssign, 0)
}

func (s *AssignmentOperatorContext) RightShiftArithmeticAssign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserRightShiftArithmeticAssign, 0)
}

func (s *AssignmentOperatorContext) RightShiftLogicalAssign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserRightShiftLogicalAssign, 0)
}

func (s *AssignmentOperatorContext) BitAndAssign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBitAndAssign, 0)
}

func (s *AssignmentOperatorContext) BitXorAssign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBitXorAssign, 0)
}

func (s *AssignmentOperatorContext) BitOrAssign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBitOrAssign, 0)
}

func (s *AssignmentOperatorContext) PowerAssign() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserPowerAssign, 0)
}

func (s *AssignmentOperatorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssignmentOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssignmentOperatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterAssignmentOperator(s)
	}
}

func (s *AssignmentOperatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitAssignmentOperator(s)
	}
}

func (p *TypeScriptParser) AssignmentOperator() (localctx IAssignmentOperatorContext) {
	localctx = NewAssignmentOperatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 262, TypeScriptParserRULE_assignmentOperator)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1683)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-48)&-(0x1f+1)) == 0 && ((1<<uint((_la-48)))&((1<<(TypeScriptParserMultiplyAssign-48))|(1<<(TypeScriptParserDivideAssign-48))|(1<<(TypeScriptParserModulusAssign-48))|(1<<(TypeScriptParserPlusAssign-48))|(1<<(TypeScriptParserMinusAssign-48))|(1<<(TypeScriptParserLeftShiftArithmeticAssign-48))|(1<<(TypeScriptParserRightShiftArithmeticAssign-48))|(1<<(TypeScriptParserRightShiftLogicalAssign-48))|(1<<(TypeScriptParserBitAndAssign-48))|(1<<(TypeScriptParserBitXorAssign-48))|(1<<(TypeScriptParserBitOrAssign-48))|(1<<(TypeScriptParserPowerAssign-48)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	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 = TypeScriptParserRULE_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 = TypeScriptParserRULE_literal

	return p
}

func (s *LiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *LiteralContext) NullLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserNullLiteral, 0)
}

func (s *LiteralContext) BooleanLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBooleanLiteral, 0)
}

func (s *LiteralContext) StringLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserStringLiteral, 0)
}

func (s *LiteralContext) TemplateStringLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserTemplateStringLiteral, 0)
}

func (s *LiteralContext) RegularExpressionLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserRegularExpressionLiteral, 0)
}

func (s *LiteralContext) NumericLiteral() INumericLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INumericLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INumericLiteralContext)
}

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.(TypeScriptParserListener); ok {
		listenerT.EnterLiteral(s)
	}
}

func (s *LiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitLiteral(s)
	}
}

func (p *TypeScriptParser) Literal() (localctx ILiteralContext) {
	localctx = NewLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 264, TypeScriptParserRULE_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(1691)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserNullLiteral:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1685)
			p.Match(TypeScriptParserNullLiteral)
		}

	case TypeScriptParserBooleanLiteral:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1686)
			p.Match(TypeScriptParserBooleanLiteral)
		}

	case TypeScriptParserStringLiteral:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1687)
			p.Match(TypeScriptParserStringLiteral)
		}

	case TypeScriptParserTemplateStringLiteral:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1688)
			p.Match(TypeScriptParserTemplateStringLiteral)
		}

	case TypeScriptParserRegularExpressionLiteral:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1689)
			p.Match(TypeScriptParserRegularExpressionLiteral)
		}

	case TypeScriptParserDecimalLiteral, TypeScriptParserHexIntegerLiteral, TypeScriptParserOctalIntegerLiteral, TypeScriptParserOctalIntegerLiteral2, TypeScriptParserBinaryIntegerLiteral:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1690)
			p.NumericLiteral()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// INumericLiteralContext is an interface to support dynamic dispatch.
type INumericLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNumericLiteralContext differentiates from other interfaces.
	IsNumericLiteralContext()
}

type NumericLiteralContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNumericLiteralContext() *NumericLiteralContext {
	var p = new(NumericLiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_numericLiteral
	return p
}

func (*NumericLiteralContext) IsNumericLiteralContext() {}

func NewNumericLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumericLiteralContext {
	var p = new(NumericLiteralContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_numericLiteral

	return p
}

func (s *NumericLiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *NumericLiteralContext) DecimalLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDecimalLiteral, 0)
}

func (s *NumericLiteralContext) HexIntegerLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserHexIntegerLiteral, 0)
}

func (s *NumericLiteralContext) OctalIntegerLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOctalIntegerLiteral, 0)
}

func (s *NumericLiteralContext) OctalIntegerLiteral2() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserOctalIntegerLiteral2, 0)
}

func (s *NumericLiteralContext) BinaryIntegerLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBinaryIntegerLiteral, 0)
}

func (s *NumericLiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NumericLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *NumericLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterNumericLiteral(s)
	}
}

func (s *NumericLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitNumericLiteral(s)
	}
}

func (p *TypeScriptParser) NumericLiteral() (localctx INumericLiteralContext) {
	localctx = NewNumericLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 266, TypeScriptParserRULE_numericLiteral)
	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(1693)
		_la = p.GetTokenStream().LA(1)

		if !(((_la-63)&-(0x1f+1)) == 0 && ((1<<uint((_la-63)))&((1<<(TypeScriptParserDecimalLiteral-63))|(1<<(TypeScriptParserHexIntegerLiteral-63))|(1<<(TypeScriptParserOctalIntegerLiteral-63))|(1<<(TypeScriptParserOctalIntegerLiteral2-63))|(1<<(TypeScriptParserBinaryIntegerLiteral-63)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IIdentifierNameContext is an interface to support dynamic dispatch.
type IIdentifierNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIdentifierNameContext differentiates from other interfaces.
	IsIdentifierNameContext()
}

type IdentifierNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIdentifierNameContext() *IdentifierNameContext {
	var p = new(IdentifierNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_identifierName
	return p
}

func (*IdentifierNameContext) IsIdentifierNameContext() {}

func NewIdentifierNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierNameContext {
	var p = new(IdentifierNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_identifierName

	return p
}

func (s *IdentifierNameContext) GetParser() antlr.Parser { return s.parser }

func (s *IdentifierNameContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *IdentifierNameContext) ReservedWord() IReservedWordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReservedWordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReservedWordContext)
}

func (s *IdentifierNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IdentifierNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IdentifierNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterIdentifierName(s)
	}
}

func (s *IdentifierNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitIdentifierName(s)
	}
}

func (p *TypeScriptParser) IdentifierName() (localctx IIdentifierNameContext) {
	localctx = NewIdentifierNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 268, TypeScriptParserRULE_identifierName)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1697)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserIdentifier:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1695)
			p.Match(TypeScriptParserIdentifier)
		}

	case TypeScriptParserNullLiteral, TypeScriptParserBooleanLiteral, TypeScriptParserBreak, TypeScriptParserDo, TypeScriptParserInstanceof, TypeScriptParserTypeof, TypeScriptParserCase, TypeScriptParserElse, TypeScriptParserNew, TypeScriptParserVar, TypeScriptParserCatch, TypeScriptParserFinally, TypeScriptParserReturn, TypeScriptParserVoid, TypeScriptParserContinue, TypeScriptParserFor, TypeScriptParserSwitch, TypeScriptParserWhile, TypeScriptParserDebugger, TypeScriptParserFunction, TypeScriptParserThis, TypeScriptParserWith, TypeScriptParserDefault, TypeScriptParserIf, TypeScriptParserThrow, TypeScriptParserDelete, TypeScriptParserIn, TypeScriptParserTry, TypeScriptParserAs, TypeScriptParserFrom, TypeScriptParserReadOnly, TypeScriptParserAsync, TypeScriptParserClass, TypeScriptParserEnum, TypeScriptParserExtends, TypeScriptParserSuper, TypeScriptParserConst, TypeScriptParserExport, TypeScriptParserImport, TypeScriptParserAwait, TypeScriptParserImplements, TypeScriptParserLet, TypeScriptParserPrivate, TypeScriptParserPublic, TypeScriptParserInterface, TypeScriptParserPackage, TypeScriptParserProtected, TypeScriptParserStatic, TypeScriptParserYield:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1696)
			p.ReservedWord()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IReservedWordContext is an interface to support dynamic dispatch.
type IReservedWordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsReservedWordContext differentiates from other interfaces.
	IsReservedWordContext()
}

type ReservedWordContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReservedWordContext() *ReservedWordContext {
	var p = new(ReservedWordContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_reservedWord
	return p
}

func (*ReservedWordContext) IsReservedWordContext() {}

func NewReservedWordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReservedWordContext {
	var p = new(ReservedWordContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_reservedWord

	return p
}

func (s *ReservedWordContext) GetParser() antlr.Parser { return s.parser }

func (s *ReservedWordContext) Keyword() IKeywordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeywordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeywordContext)
}

func (s *ReservedWordContext) NullLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserNullLiteral, 0)
}

func (s *ReservedWordContext) BooleanLiteral() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBooleanLiteral, 0)
}

func (s *ReservedWordContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ReservedWordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ReservedWordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterReservedWord(s)
	}
}

func (s *ReservedWordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitReservedWord(s)
	}
}

func (p *TypeScriptParser) ReservedWord() (localctx IReservedWordContext) {
	localctx = NewReservedWordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 270, TypeScriptParserRULE_reservedWord)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1702)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case TypeScriptParserBreak, TypeScriptParserDo, TypeScriptParserInstanceof, TypeScriptParserTypeof, TypeScriptParserCase, TypeScriptParserElse, TypeScriptParserNew, TypeScriptParserVar, TypeScriptParserCatch, TypeScriptParserFinally, TypeScriptParserReturn, TypeScriptParserVoid, TypeScriptParserContinue, TypeScriptParserFor, TypeScriptParserSwitch, TypeScriptParserWhile, TypeScriptParserDebugger, TypeScriptParserFunction, TypeScriptParserThis, TypeScriptParserWith, TypeScriptParserDefault, TypeScriptParserIf, TypeScriptParserThrow, TypeScriptParserDelete, TypeScriptParserIn, TypeScriptParserTry, TypeScriptParserAs, TypeScriptParserFrom, TypeScriptParserReadOnly, TypeScriptParserAsync, TypeScriptParserClass, TypeScriptParserEnum, TypeScriptParserExtends, TypeScriptParserSuper, TypeScriptParserConst, TypeScriptParserExport, TypeScriptParserImport, TypeScriptParserAwait, TypeScriptParserImplements, TypeScriptParserLet, TypeScriptParserPrivate, TypeScriptParserPublic, TypeScriptParserInterface, TypeScriptParserPackage, TypeScriptParserProtected, TypeScriptParserStatic, TypeScriptParserYield:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1699)
			p.Keyword()
		}

	case TypeScriptParserNullLiteral:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1700)
			p.Match(TypeScriptParserNullLiteral)
		}

	case TypeScriptParserBooleanLiteral:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1701)
			p.Match(TypeScriptParserBooleanLiteral)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IKeywordContext is an interface to support dynamic dispatch.
type IKeywordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKeywordContext differentiates from other interfaces.
	IsKeywordContext()
}

type KeywordContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKeywordContext() *KeywordContext {
	var p = new(KeywordContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_keyword
	return p
}

func (*KeywordContext) IsKeywordContext() {}

func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordContext {
	var p = new(KeywordContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_keyword

	return p
}

func (s *KeywordContext) GetParser() antlr.Parser { return s.parser }

func (s *KeywordContext) Break() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserBreak, 0)
}

func (s *KeywordContext) Do() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDo, 0)
}

func (s *KeywordContext) Instanceof() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserInstanceof, 0)
}

func (s *KeywordContext) Typeof() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserTypeof, 0)
}

func (s *KeywordContext) Case() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCase, 0)
}

func (s *KeywordContext) Else() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserElse, 0)
}

func (s *KeywordContext) New() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserNew, 0)
}

func (s *KeywordContext) Var() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserVar, 0)
}

func (s *KeywordContext) Catch() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserCatch, 0)
}

func (s *KeywordContext) Finally() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserFinally, 0)
}

func (s *KeywordContext) Return() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserReturn, 0)
}

func (s *KeywordContext) Void() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserVoid, 0)
}

func (s *KeywordContext) Continue() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserContinue, 0)
}

func (s *KeywordContext) For() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserFor, 0)
}

func (s *KeywordContext) Switch() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSwitch, 0)
}

func (s *KeywordContext) While() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserWhile, 0)
}

func (s *KeywordContext) Debugger() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDebugger, 0)
}

func (s *KeywordContext) Function() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserFunction, 0)
}

func (s *KeywordContext) This() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserThis, 0)
}

func (s *KeywordContext) With() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserWith, 0)
}

func (s *KeywordContext) Default() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDefault, 0)
}

func (s *KeywordContext) If() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIf, 0)
}

func (s *KeywordContext) Throw() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserThrow, 0)
}

func (s *KeywordContext) Delete() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserDelete, 0)
}

func (s *KeywordContext) In() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIn, 0)
}

func (s *KeywordContext) Try() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserTry, 0)
}

func (s *KeywordContext) ReadOnly() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserReadOnly, 0)
}

func (s *KeywordContext) Async() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAsync, 0)
}

func (s *KeywordContext) From() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserFrom, 0)
}

func (s *KeywordContext) Class() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserClass, 0)
}

func (s *KeywordContext) Enum() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserEnum, 0)
}

func (s *KeywordContext) Extends() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserExtends, 0)
}

func (s *KeywordContext) Super() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSuper, 0)
}

func (s *KeywordContext) Const() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserConst, 0)
}

func (s *KeywordContext) Export() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserExport, 0)
}

func (s *KeywordContext) Import() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserImport, 0)
}

func (s *KeywordContext) Implements() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserImplements, 0)
}

func (s *KeywordContext) Let() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserLet, 0)
}

func (s *KeywordContext) Private() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserPrivate, 0)
}

func (s *KeywordContext) Public() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserPublic, 0)
}

func (s *KeywordContext) Interface() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserInterface, 0)
}

func (s *KeywordContext) Package() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserPackage, 0)
}

func (s *KeywordContext) Protected() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserProtected, 0)
}

func (s *KeywordContext) Static() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserStatic, 0)
}

func (s *KeywordContext) Yield() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserYield, 0)
}

func (s *KeywordContext) Await() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAwait, 0)
}

func (s *KeywordContext) As() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserAs, 0)
}

func (s *KeywordContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KeywordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterKeyword(s)
	}
}

func (s *KeywordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitKeyword(s)
	}
}

func (p *TypeScriptParser) Keyword() (localctx IKeywordContext) {
	localctx = NewKeywordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 272, TypeScriptParserRULE_keyword)
	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(1704)
		_la = p.GetTokenStream().LA(1)

		if !((((_la-68)&-(0x1f+1)) == 0 && ((1<<uint((_la-68)))&((1<<(TypeScriptParserBreak-68))|(1<<(TypeScriptParserDo-68))|(1<<(TypeScriptParserInstanceof-68))|(1<<(TypeScriptParserTypeof-68))|(1<<(TypeScriptParserCase-68))|(1<<(TypeScriptParserElse-68))|(1<<(TypeScriptParserNew-68))|(1<<(TypeScriptParserVar-68))|(1<<(TypeScriptParserCatch-68))|(1<<(TypeScriptParserFinally-68))|(1<<(TypeScriptParserReturn-68))|(1<<(TypeScriptParserVoid-68))|(1<<(TypeScriptParserContinue-68))|(1<<(TypeScriptParserFor-68))|(1<<(TypeScriptParserSwitch-68))|(1<<(TypeScriptParserWhile-68))|(1<<(TypeScriptParserDebugger-68))|(1<<(TypeScriptParserFunction-68))|(1<<(TypeScriptParserThis-68))|(1<<(TypeScriptParserWith-68))|(1<<(TypeScriptParserDefault-68))|(1<<(TypeScriptParserIf-68))|(1<<(TypeScriptParserThrow-68))|(1<<(TypeScriptParserDelete-68))|(1<<(TypeScriptParserIn-68))|(1<<(TypeScriptParserTry-68))|(1<<(TypeScriptParserAs-68))|(1<<(TypeScriptParserFrom-68))|(1<<(TypeScriptParserReadOnly-68))|(1<<(TypeScriptParserAsync-68))|(1<<(TypeScriptParserClass-68))|(1<<(TypeScriptParserEnum-68)))) != 0) || (((_la-100)&-(0x1f+1)) == 0 && ((1<<uint((_la-100)))&((1<<(TypeScriptParserExtends-100))|(1<<(TypeScriptParserSuper-100))|(1<<(TypeScriptParserConst-100))|(1<<(TypeScriptParserExport-100))|(1<<(TypeScriptParserImport-100))|(1<<(TypeScriptParserAwait-100))|(1<<(TypeScriptParserImplements-100))|(1<<(TypeScriptParserLet-100))|(1<<(TypeScriptParserPrivate-100))|(1<<(TypeScriptParserPublic-100))|(1<<(TypeScriptParserInterface-100))|(1<<(TypeScriptParserPackage-100))|(1<<(TypeScriptParserProtected-100))|(1<<(TypeScriptParserStatic-100))|(1<<(TypeScriptParserYield-100)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IGetterContext is an interface to support dynamic dispatch.
type IGetterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsGetterContext differentiates from other interfaces.
	IsGetterContext()
}

type GetterContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyGetterContext() *GetterContext {
	var p = new(GetterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_getter
	return p
}

func (*GetterContext) IsGetterContext() {}

func NewGetterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GetterContext {
	var p = new(GetterContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_getter

	return p
}

func (s *GetterContext) GetParser() antlr.Parser { return s.parser }

func (s *GetterContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *GetterContext) PropertyName() IPropertyNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertyNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPropertyNameContext)
}

func (s *GetterContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *GetterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *GetterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterGetter(s)
	}
}

func (s *GetterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitGetter(s)
	}
}

func (p *TypeScriptParser) Getter() (localctx IGetterContext) {
	localctx = NewGetterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 274, TypeScriptParserRULE_getter)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1706)
		p.Match(TypeScriptParserIdentifier)
	}
	p.SetState(1707)

	if !(p.p("get")) {
		panic(antlr.NewFailedPredicateException(p, "p.p(\"get\")", ""))
	}
	{
		p.SetState(1708)
		p.PropertyName()
	}

	return localctx
}

// ISetterContext is an interface to support dynamic dispatch.
type ISetterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSetterContext differentiates from other interfaces.
	IsSetterContext()
}

type SetterContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySetterContext() *SetterContext {
	var p = new(SetterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_setter
	return p
}

func (*SetterContext) IsSetterContext() {}

func NewSetterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetterContext {
	var p = new(SetterContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_setter

	return p
}

func (s *SetterContext) GetParser() antlr.Parser { return s.parser }

func (s *SetterContext) Identifier() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserIdentifier, 0)
}

func (s *SetterContext) PropertyName() IPropertyNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPropertyNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPropertyNameContext)
}

func (s *SetterContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SetterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SetterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterSetter(s)
	}
}

func (s *SetterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitSetter(s)
	}
}

func (p *TypeScriptParser) Setter() (localctx ISetterContext) {
	localctx = NewSetterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 276, TypeScriptParserRULE_setter)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1710)
		p.Match(TypeScriptParserIdentifier)
	}
	p.SetState(1711)

	if !(p.p("set")) {
		panic(antlr.NewFailedPredicateException(p, "p.p(\"set\")", ""))
	}
	{
		p.SetState(1712)
		p.PropertyName()
	}

	return localctx
}

// IEosContext is an interface to support dynamic dispatch.
type IEosContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEosContext differentiates from other interfaces.
	IsEosContext()
}

type EosContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEosContext() *EosContext {
	var p = new(EosContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = TypeScriptParserRULE_eos
	return p
}

func (*EosContext) IsEosContext() {}

func NewEosContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EosContext {
	var p = new(EosContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = TypeScriptParserRULE_eos

	return p
}

func (s *EosContext) GetParser() antlr.Parser { return s.parser }

func (s *EosContext) SemiColon() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserSemiColon, 0)
}

func (s *EosContext) EOF() antlr.TerminalNode {
	return s.GetToken(TypeScriptParserEOF, 0)
}

func (s *EosContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EosContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EosContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.EnterEos(s)
	}
}

func (s *EosContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(TypeScriptParserListener); ok {
		listenerT.ExitEos(s)
	}
}

func (p *TypeScriptParser) Eos() (localctx IEosContext) {
	localctx = NewEosContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 278, TypeScriptParserRULE_eos)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1718)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 217, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1714)
			p.Match(TypeScriptParserSemiColon)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1715)
			p.Match(TypeScriptParserEOF)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		p.SetState(1716)

		if !(p.lineTerminatorAhead()) {
			panic(antlr.NewFailedPredicateException(p, "p.lineTerminatorAhead()", ""))
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		p.SetState(1717)

		if !(p.closeBrace()) {
			panic(antlr.NewFailedPredicateException(p, "p.closeBrace()", ""))
		}

	}

	return localctx
}

func (p *TypeScriptParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
	switch ruleIndex {
	case 10:
		var t *UnionOrIntersectionOrPrimaryTypeContext = nil
		if localctx != nil {
			t = localctx.(*UnionOrIntersectionOrPrimaryTypeContext)
		}
		return p.UnionOrIntersectionOrPrimaryType_Sempred(t, predIndex)

	case 11:
		var t *PrimaryTypeContext = nil
		if localctx != nil {
			t = localctx.(*PrimaryTypeContext)
		}
		return p.PrimaryType_Sempred(t, predIndex)

	case 21:
		var t *ArrayTypeContext = nil
		if localctx != nil {
			t = localctx.(*ArrayTypeContext)
		}
		return p.ArrayType_Sempred(t, predIndex)

	case 57:
		var t *DecoratorMemberExpressionContext = nil
		if localctx != nil {
			t = localctx.(*DecoratorMemberExpressionContext)
		}
		return p.DecoratorMemberExpression_Sempred(t, predIndex)

	case 73:
		var t *ExpressionStatementContext = nil
		if localctx != nil {
			t = localctx.(*ExpressionStatementContext)
		}
		return p.ExpressionStatement_Sempred(t, predIndex)

	case 75:
		var t *IterationStatementContext = nil
		if localctx != nil {
			t = localctx.(*IterationStatementContext)
		}
		return p.IterationStatement_Sempred(t, predIndex)

	case 77:
		var t *ContinueStatementContext = nil
		if localctx != nil {
			t = localctx.(*ContinueStatementContext)
		}
		return p.ContinueStatement_Sempred(t, predIndex)

	case 78:
		var t *BreakStatementContext = nil
		if localctx != nil {
			t = localctx.(*BreakStatementContext)
		}
		return p.BreakStatement_Sempred(t, predIndex)

	case 79:
		var t *ReturnStatementContext = nil
		if localctx != nil {
			t = localctx.(*ReturnStatementContext)
		}
		return p.ReturnStatement_Sempred(t, predIndex)

	case 80:
		var t *YieldStatementContext = nil
		if localctx != nil {
			t = localctx.(*YieldStatementContext)
		}
		return p.YieldStatement_Sempred(t, predIndex)

	case 88:
		var t *ThrowStatementContext = nil
		if localctx != nil {
			t = localctx.(*ThrowStatementContext)
		}
		return p.ThrowStatement_Sempred(t, predIndex)

	case 127:
		var t *SingleExpressionContext = nil
		if localctx != nil {
			t = localctx.(*SingleExpressionContext)
		}
		return p.SingleExpression_Sempred(t, predIndex)

	case 137:
		var t *GetterContext = nil
		if localctx != nil {
			t = localctx.(*GetterContext)
		}
		return p.Getter_Sempred(t, predIndex)

	case 138:
		var t *SetterContext = nil
		if localctx != nil {
			t = localctx.(*SetterContext)
		}
		return p.Setter_Sempred(t, predIndex)

	case 139:
		var t *EosContext = nil
		if localctx != nil {
			t = localctx.(*EosContext)
		}
		return p.Eos_Sempred(t, predIndex)

	default:
		panic("No predicate with index: " + fmt.Sprint(ruleIndex))
	}
}

func (p *TypeScriptParser) UnionOrIntersectionOrPrimaryType_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 0:
		return p.Precpred(p.GetParserRuleContext(), 3)

	case 1:
		return p.Precpred(p.GetParserRuleContext(), 2)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *TypeScriptParser) PrimaryType_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 2:
		return p.Precpred(p.GetParserRuleContext(), 5)

	case 3:
		return p.notLineTerminator()

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *TypeScriptParser) ArrayType_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 4:
		return p.notLineTerminator()

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *TypeScriptParser) DecoratorMemberExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 5:
		return p.Precpred(p.GetParserRuleContext(), 2)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *TypeScriptParser) ExpressionStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 6:
		return p.notOpenBraceAndNotFunction()

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *TypeScriptParser) IterationStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 7:
		return p.p("of")

	case 8:
		return p.p("of")

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *TypeScriptParser) ContinueStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 9:
		return p.notLineTerminator()

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *TypeScriptParser) BreakStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 10:
		return p.notLineTerminator()

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *TypeScriptParser) ReturnStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 11:
		return p.notLineTerminator()

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *TypeScriptParser) YieldStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 12:
		return p.notLineTerminator()

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *TypeScriptParser) ThrowStatement_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 13:
		return p.notLineTerminator()

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *TypeScriptParser) SingleExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 14:
		return p.Precpred(p.GetParserRuleContext(), 30)

	case 15:
		return p.Precpred(p.GetParserRuleContext(), 29)

	case 16:
		return p.Precpred(p.GetParserRuleContext(), 28)

	case 17:
		return p.Precpred(p.GetParserRuleContext(), 27)

	case 18:
		return p.Precpred(p.GetParserRuleContext(), 26)

	case 19:
		return p.Precpred(p.GetParserRuleContext(), 25)

	case 20:
		return p.Precpred(p.GetParserRuleContext(), 24)

	case 21:
		return p.Precpred(p.GetParserRuleContext(), 23)

	case 22:
		return p.Precpred(p.GetParserRuleContext(), 22)

	case 23:
		return p.Precpred(p.GetParserRuleContext(), 21)

	case 24:
		return p.Precpred(p.GetParserRuleContext(), 20)

	case 25:
		return p.Precpred(p.GetParserRuleContext(), 19)

	case 26:
		return p.Precpred(p.GetParserRuleContext(), 18)

	case 27:
		return p.Precpred(p.GetParserRuleContext(), 17)

	case 28:
		return p.Precpred(p.GetParserRuleContext(), 16)

	case 29:
		return p.Precpred(p.GetParserRuleContext(), 15)

	case 30:
		return p.Precpred(p.GetParserRuleContext(), 14)

	case 31:
		return p.Precpred(p.GetParserRuleContext(), 46)

	case 32:
		return p.Precpred(p.GetParserRuleContext(), 45)

	case 33:
		return p.Precpred(p.GetParserRuleContext(), 44)

	case 34:
		return p.Precpred(p.GetParserRuleContext(), 42)

	case 35:
		return p.notLineTerminator()

	case 36:
		return p.Precpred(p.GetParserRuleContext(), 41)

	case 37:
		return p.notLineTerminator()

	case 38:
		return p.Precpred(p.GetParserRuleContext(), 13)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *TypeScriptParser) Getter_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 39:
		return p.p("get")

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *TypeScriptParser) Setter_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 40:
		return p.p("set")

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *TypeScriptParser) Eos_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 41:
		return p.lineTerminatorAhead()

	case 42:
		return p.closeBrace()

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}
