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

package alef // alef
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, 101, 1023,
	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, 3, 2, 5, 2, 126, 10, 2, 3, 3, 6, 3, 129,
	10, 3, 13, 3, 14, 3, 130, 3, 4, 3, 4, 5, 4, 135, 10, 4, 3, 4, 3, 4, 3,
	4, 3, 4, 3, 4, 3, 4, 5, 4, 143, 10, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3,
	4, 3, 4, 5, 4, 152, 10, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 5,
	4, 161, 10, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3,
	4, 5, 4, 173, 10, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 5, 4, 180, 10, 4, 3,
	5, 3, 5, 5, 5, 184, 10, 5, 3, 5, 3, 5, 3, 6, 3, 6, 3, 6, 3, 6, 5, 6, 192,
	10, 6, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 203,
	10, 7, 3, 8, 3, 8, 5, 8, 207, 10, 8, 3, 8, 3, 8, 3, 8, 3, 8, 5, 8, 213,
	10, 8, 3, 8, 3, 8, 5, 8, 217, 10, 8, 3, 8, 3, 8, 3, 8, 3, 8, 5, 8, 223,
	10, 8, 3, 8, 3, 8, 5, 8, 227, 10, 8, 3, 8, 5, 8, 230, 10, 8, 3, 8, 3, 8,
	3, 8, 3, 8, 5, 8, 236, 10, 8, 3, 8, 3, 8, 5, 8, 240, 10, 8, 3, 8, 3, 8,
	3, 8, 3, 8, 5, 8, 246, 10, 8, 3, 9, 3, 9, 5, 9, 250, 10, 9, 3, 10, 3, 10,
	3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 261, 10, 11, 3,
	12, 3, 12, 5, 12, 265, 10, 12, 3, 12, 3, 12, 3, 12, 7, 12, 270, 10, 12,
	12, 12, 14, 12, 273, 11, 12, 3, 13, 3, 13, 3, 13, 5, 13, 278, 10, 13, 3,
	14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 7, 15, 287, 10, 15, 12, 15,
	14, 15, 290, 11, 15, 3, 16, 3, 16, 3, 16, 7, 16, 295, 10, 16, 12, 16, 14,
	16, 298, 11, 16, 3, 17, 3, 17, 5, 17, 302, 10, 17, 3, 18, 3, 18, 3, 18,
	3, 19, 3, 19, 5, 19, 309, 10, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3,
	19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19,
	3, 19, 3, 19, 3, 19, 3, 19, 5, 19, 331, 10, 19, 3, 19, 3, 19, 3, 19, 7,
	19, 336, 10, 19, 12, 19, 14, 19, 339, 11, 19, 3, 20, 3, 20, 5, 20, 343,
	10, 20, 3, 20, 3, 20, 3, 20, 5, 20, 348, 10, 20, 3, 20, 3, 20, 3, 20, 3,
	20, 5, 20, 354, 10, 20, 3, 20, 3, 20, 3, 20, 5, 20, 359, 10, 20, 3, 20,
	3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 5, 20, 368, 10, 20, 3, 20, 3,
	20, 3, 20, 5, 20, 373, 10, 20, 3, 20, 3, 20, 5, 20, 377, 10, 20, 3, 21,
	3, 21, 5, 21, 381, 10, 21, 3, 21, 6, 21, 384, 10, 21, 13, 21, 14, 21, 385,
	3, 22, 6, 22, 389, 10, 22, 13, 22, 14, 22, 390, 3, 23, 7, 23, 394, 10,
	23, 12, 23, 14, 23, 397, 11, 23, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3,
	24, 3, 24, 3, 24, 5, 24, 407, 10, 24, 3, 25, 3, 25, 3, 25, 3, 25, 5, 25,
	413, 10, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 5, 25, 421, 10,
	25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 5, 25,
	432, 10, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3,
	25, 3, 25, 5, 25, 444, 10, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26,
	3, 26, 5, 26, 453, 10, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 5, 26, 460,
	10, 26, 3, 27, 6, 27, 463, 10, 27, 13, 27, 14, 27, 464, 3, 28, 3, 28, 5,
	28, 469, 10, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 5, 28, 476, 10, 28,
	3, 28, 3, 28, 5, 28, 480, 10, 28, 3, 29, 3, 29, 5, 29, 484, 10, 29, 3,
	29, 5, 29, 487, 10, 29, 3, 29, 3, 29, 3, 29, 3, 29, 5, 29, 493, 10, 29,
	3, 29, 5, 29, 496, 10, 29, 3, 29, 5, 29, 499, 10, 29, 3, 30, 6, 30, 502,
	10, 30, 13, 30, 14, 30, 503, 3, 31, 3, 31, 5, 31, 508, 10, 31, 3, 31, 3,
	31, 3, 31, 3, 31, 5, 31, 514, 10, 31, 3, 31, 5, 31, 517, 10, 31, 3, 32,
	6, 32, 520, 10, 32, 13, 32, 14, 32, 521, 3, 33, 3, 33, 3, 33, 3, 33, 5,
	33, 528, 10, 33, 3, 33, 3, 33, 3, 33, 5, 33, 533, 10, 33, 5, 33, 535, 10,
	33, 3, 34, 3, 34, 5, 34, 539, 10, 34, 3, 34, 3, 34, 3, 34, 3, 34, 5, 34,
	545, 10, 34, 3, 34, 5, 34, 548, 10, 34, 3, 35, 6, 35, 551, 10, 35, 13,
	35, 14, 35, 552, 3, 36, 3, 36, 3, 36, 3, 36, 5, 36, 559, 10, 36, 3, 36,
	3, 36, 3, 36, 5, 36, 564, 10, 36, 5, 36, 566, 10, 36, 3, 37, 3, 37, 3,
	37, 5, 37, 571, 10, 37, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 5, 39,
	579, 10, 39, 3, 40, 3, 40, 3, 40, 3, 41, 5, 41, 585, 10, 41, 3, 41, 3,
	41, 3, 41, 3, 41, 3, 41, 5, 41, 592, 10, 41, 3, 41, 3, 41, 3, 41, 3, 41,
	3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 5,
	41, 608, 10, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41,
	3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3,
	41, 3, 41, 5, 41, 630, 10, 41, 3, 41, 3, 41, 3, 41, 3, 41, 5, 41, 636,
	10, 41, 3, 41, 3, 41, 5, 41, 640, 10, 41, 3, 41, 3, 41, 5, 41, 644, 10,
	41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41,
	3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3,
	41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41,
	3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 5,
	41, 687, 10, 41, 3, 41, 3, 41, 3, 41, 5, 41, 692, 10, 41, 3, 41, 5, 41,
	695, 10, 41, 3, 42, 3, 42, 3, 43, 3, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3,
	44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44,
	3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3,
	44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44,
	3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3,
	44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44,
	3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3,
	44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44,
	3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3,
	44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44,
	3, 44, 7, 44, 801, 10, 44, 12, 44, 14, 44, 804, 11, 44, 3, 45, 3, 45, 3,
	45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 5, 45,
	818, 10, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3,
	46, 3, 46, 5, 46, 830, 10, 46, 3, 46, 3, 46, 3, 46, 3, 46, 5, 46, 836,
	10, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47,
	3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3,
	47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 863, 10, 47, 3, 48, 3, 48,
	3, 49, 3, 49, 3, 49, 7, 49, 870, 10, 49, 12, 49, 14, 49, 873, 11, 49, 3,
	50, 3, 50, 3, 50, 5, 50, 878, 10, 50, 3, 50, 5, 50, 881, 10, 50, 3, 51,
	3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3,
	51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51,
	3, 51, 3, 51, 3, 51, 3, 51, 5, 51, 909, 10, 51, 3, 51, 3, 51, 3, 51, 5,
	51, 914, 10, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51,
	3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 7,
	51, 934, 10, 51, 12, 51, 14, 51, 937, 11, 51, 3, 52, 3, 52, 5, 52, 941,
	10, 52, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 7, 54,
	951, 10, 54, 12, 54, 14, 54, 954, 11, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3,
	55, 5, 55, 961, 10, 55, 3, 56, 5, 56, 964, 10, 56, 3, 56, 3, 56, 5, 56,
	968, 10, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 5, 56, 976, 10,
	56, 3, 56, 3, 56, 3, 56, 3, 56, 5, 56, 982, 10, 56, 3, 57, 3, 57, 3, 57,
	3, 57, 3, 57, 5, 57, 989, 10, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3,
	58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58,
	3, 58, 3, 58, 5, 58, 1009, 10, 58, 5, 58, 1011, 10, 58, 3, 59, 3, 59, 3,
	59, 3, 59, 3, 60, 3, 60, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 2, 8, 22, 28,
	36, 86, 100, 106, 63, 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, 2, 3, 5, 2, 67,
	67, 73, 73, 96, 96, 2, 1178, 2, 125, 3, 2, 2, 2, 4, 128, 3, 2, 2, 2, 6,
	179, 3, 2, 2, 2, 8, 181, 3, 2, 2, 2, 10, 191, 3, 2, 2, 2, 12, 202, 3, 2,
	2, 2, 14, 245, 3, 2, 2, 2, 16, 249, 3, 2, 2, 2, 18, 251, 3, 2, 2, 2, 20,
	260, 3, 2, 2, 2, 22, 262, 3, 2, 2, 2, 24, 274, 3, 2, 2, 2, 26, 279, 3,
	2, 2, 2, 28, 281, 3, 2, 2, 2, 30, 291, 3, 2, 2, 2, 32, 299, 3, 2, 2, 2,
	34, 303, 3, 2, 2, 2, 36, 330, 3, 2, 2, 2, 38, 376, 3, 2, 2, 2, 40, 383,
	3, 2, 2, 2, 42, 388, 3, 2, 2, 2, 44, 395, 3, 2, 2, 2, 46, 406, 3, 2, 2,
	2, 48, 443, 3, 2, 2, 2, 50, 459, 3, 2, 2, 2, 52, 462, 3, 2, 2, 2, 54, 479,
	3, 2, 2, 2, 56, 498, 3, 2, 2, 2, 58, 501, 3, 2, 2, 2, 60, 516, 3, 2, 2,
	2, 62, 519, 3, 2, 2, 2, 64, 534, 3, 2, 2, 2, 66, 547, 3, 2, 2, 2, 68, 550,
	3, 2, 2, 2, 70, 565, 3, 2, 2, 2, 72, 570, 3, 2, 2, 2, 74, 572, 3, 2, 2,
	2, 76, 578, 3, 2, 2, 2, 78, 580, 3, 2, 2, 2, 80, 694, 3, 2, 2, 2, 82, 696,
	3, 2, 2, 2, 84, 698, 3, 2, 2, 2, 86, 700, 3, 2, 2, 2, 88, 817, 3, 2, 2,
	2, 90, 835, 3, 2, 2, 2, 92, 862, 3, 2, 2, 2, 94, 864, 3, 2, 2, 2, 96, 866,
	3, 2, 2, 2, 98, 880, 3, 2, 2, 2, 100, 908, 3, 2, 2, 2, 102, 940, 3, 2,
	2, 2, 104, 942, 3, 2, 2, 2, 106, 944, 3, 2, 2, 2, 108, 960, 3, 2, 2, 2,
	110, 981, 3, 2, 2, 2, 112, 988, 3, 2, 2, 2, 114, 1010, 3, 2, 2, 2, 116,
	1012, 3, 2, 2, 2, 118, 1016, 3, 2, 2, 2, 120, 1018, 3, 2, 2, 2, 122, 1020,
	3, 2, 2, 2, 124, 126, 5, 4, 3, 2, 125, 124, 3, 2, 2, 2, 125, 126, 3, 2,
	2, 2, 126, 3, 3, 2, 2, 2, 127, 129, 5, 6, 4, 2, 128, 127, 3, 2, 2, 2, 129,
	130, 3, 2, 2, 2, 130, 128, 3, 2, 2, 2, 130, 131, 3, 2, 2, 2, 131, 5, 3,
	2, 2, 2, 132, 134, 5, 110, 56, 2, 133, 135, 5, 30, 16, 2, 134, 133, 3,
	2, 2, 2, 134, 135, 3, 2, 2, 2, 135, 136, 3, 2, 2, 2, 136, 137, 7, 3, 2,
	2, 137, 180, 3, 2, 2, 2, 138, 139, 5, 110, 56, 2, 139, 140, 5, 38, 20,
	2, 140, 142, 7, 4, 2, 2, 141, 143, 5, 44, 23, 2, 142, 141, 3, 2, 2, 2,
	142, 143, 3, 2, 2, 2, 143, 144, 3, 2, 2, 2, 144, 145, 7, 5, 2, 2, 145,
	146, 5, 56, 29, 2, 146, 180, 3, 2, 2, 2, 147, 148, 5, 110, 56, 2, 148,
	149, 5, 12, 7, 2, 149, 151, 7, 4, 2, 2, 150, 152, 5, 44, 23, 2, 151, 150,
	3, 2, 2, 2, 151, 152, 3, 2, 2, 2, 152, 153, 3, 2, 2, 2, 153, 154, 7, 5,
	2, 2, 154, 155, 5, 56, 29, 2, 155, 180, 3, 2, 2, 2, 156, 157, 5, 110, 56,
	2, 157, 158, 5, 38, 20, 2, 158, 160, 7, 4, 2, 2, 159, 161, 5, 44, 23, 2,
	160, 159, 3, 2, 2, 2, 160, 161, 3, 2, 2, 2, 161, 162, 3, 2, 2, 2, 162,
	163, 7, 5, 2, 2, 163, 164, 7, 3, 2, 2, 164, 180, 3, 2, 2, 2, 165, 166,
	5, 14, 8, 2, 166, 167, 7, 3, 2, 2, 167, 180, 3, 2, 2, 2, 168, 169, 7, 86,
	2, 2, 169, 170, 5, 10, 6, 2, 170, 172, 5, 38, 20, 2, 171, 173, 5, 8, 5,
	2, 172, 171, 3, 2, 2, 2, 172, 173, 3, 2, 2, 2, 173, 174, 3, 2, 2, 2, 174,
	175, 7, 3, 2, 2, 175, 180, 3, 2, 2, 2, 176, 177, 7, 86, 2, 2, 177, 178,
	7, 97, 2, 2, 178, 180, 7, 3, 2, 2, 179, 132, 3, 2, 2, 2, 179, 138, 3, 2,
	2, 2, 179, 147, 3, 2, 2, 2, 179, 156, 3, 2, 2, 2, 179, 165, 3, 2, 2, 2,
	179, 168, 3, 2, 2, 2, 179, 176, 3, 2, 2, 2, 180, 7, 3, 2, 2, 2, 181, 183,
	7, 4, 2, 2, 182, 184, 5, 44, 23, 2, 183, 182, 3, 2, 2, 2, 183, 184, 3,
	2, 2, 2, 184, 185, 3, 2, 2, 2, 185, 186, 7, 5, 2, 2, 186, 9, 3, 2, 2, 2,
	187, 192, 5, 110, 56, 2, 188, 192, 7, 53, 2, 2, 189, 192, 7, 52, 2, 2,
	190, 192, 7, 91, 2, 2, 191, 187, 3, 2, 2, 2, 191, 188, 3, 2, 2, 2, 191,
	189, 3, 2, 2, 2, 191, 190, 3, 2, 2, 2, 192, 11, 3, 2, 2, 2, 193, 194, 5,
	120, 61, 2, 194, 195, 7, 6, 2, 2, 195, 196, 5, 26, 14, 2, 196, 203, 3,
	2, 2, 2, 197, 198, 5, 42, 22, 2, 198, 199, 5, 120, 61, 2, 199, 200, 7,
	6, 2, 2, 200, 201, 5, 26, 14, 2, 201, 203, 3, 2, 2, 2, 202, 193, 3, 2,
	2, 2, 202, 197, 3, 2, 2, 2, 203, 13, 3, 2, 2, 2, 204, 206, 7, 53, 2, 2,
	205, 207, 5, 16, 9, 2, 206, 205, 3, 2, 2, 2, 206, 207, 3, 2, 2, 2, 207,
	208, 3, 2, 2, 2, 208, 209, 7, 7, 2, 2, 209, 210, 5, 28, 15, 2, 210, 212,
	7, 8, 2, 2, 211, 213, 5, 16, 9, 2, 212, 211, 3, 2, 2, 2, 212, 213, 3, 2,
	2, 2, 213, 246, 3, 2, 2, 2, 214, 216, 7, 91, 2, 2, 215, 217, 5, 16, 9,
	2, 216, 215, 3, 2, 2, 2, 216, 217, 3, 2, 2, 2, 217, 218, 3, 2, 2, 2, 218,
	219, 7, 7, 2, 2, 219, 220, 5, 28, 15, 2, 220, 222, 7, 8, 2, 2, 221, 223,
	5, 16, 9, 2, 222, 221, 3, 2, 2, 2, 222, 223, 3, 2, 2, 2, 223, 246, 3, 2,
	2, 2, 224, 226, 7, 52, 2, 2, 225, 227, 5, 16, 9, 2, 226, 225, 3, 2, 2,
	2, 226, 227, 3, 2, 2, 2, 227, 229, 3, 2, 2, 2, 228, 230, 5, 18, 10, 2,
	229, 228, 3, 2, 2, 2, 229, 230, 3, 2, 2, 2, 230, 231, 3, 2, 2, 2, 231,
	232, 7, 7, 2, 2, 232, 233, 5, 28, 15, 2, 233, 235, 7, 8, 2, 2, 234, 236,
	5, 16, 9, 2, 235, 234, 3, 2, 2, 2, 235, 236, 3, 2, 2, 2, 236, 246, 3, 2,
	2, 2, 237, 239, 7, 66, 2, 2, 238, 240, 5, 16, 9, 2, 239, 238, 3, 2, 2,
	2, 239, 240, 3, 2, 2, 2, 240, 241, 3, 2, 2, 2, 241, 242, 7, 7, 2, 2, 242,
	243, 5, 22, 12, 2, 243, 244, 7, 8, 2, 2, 244, 246, 3, 2, 2, 2, 245, 204,
	3, 2, 2, 2, 245, 214, 3, 2, 2, 2, 245, 224, 3, 2, 2, 2, 245, 237, 3, 2,
	2, 2, 246, 15, 3, 2, 2, 2, 247, 250, 5, 26, 14, 2, 248, 250, 5, 120, 61,
	2, 249, 247, 3, 2, 2, 2, 249, 248, 3, 2, 2, 2, 250, 17, 3, 2, 2, 2, 251,
	252, 7, 9, 2, 2, 252, 253, 5, 20, 11, 2, 253, 254, 7, 10, 2, 2, 254, 19,
	3, 2, 2, 2, 255, 261, 5, 26, 14, 2, 256, 257, 5, 26, 14, 2, 257, 258, 7,
	11, 2, 2, 258, 259, 5, 20, 11, 2, 259, 261, 3, 2, 2, 2, 260, 255, 3, 2,
	2, 2, 260, 256, 3, 2, 2, 2, 261, 21, 3, 2, 2, 2, 262, 264, 8, 12, 1, 2,
	263, 265, 5, 24, 13, 2, 264, 263, 3, 2, 2, 2, 264, 265, 3, 2, 2, 2, 265,
	271, 3, 2, 2, 2, 266, 267, 12, 3, 2, 2, 267, 268, 7, 11, 2, 2, 268, 270,
	5, 22, 12, 4, 269, 266, 3, 2, 2, 2, 270, 273, 3, 2, 2, 2, 271, 269, 3,
	2, 2, 2, 271, 272, 3, 2, 2, 2, 272, 23, 3, 2, 2, 2, 273, 271, 3, 2, 2,
	2, 274, 277, 5, 26, 14, 2, 275, 276, 7, 12, 2, 2, 276, 278, 5, 86, 44,
	2, 277, 275, 3, 2, 2, 2, 277, 278, 3, 2, 2, 2, 278, 25, 3, 2, 2, 2, 279,
	280, 7, 97, 2, 2, 280, 27, 3, 2, 2, 2, 281, 282, 8, 15, 1, 2, 282, 283,
	5, 6, 4, 2, 283, 288, 3, 2, 2, 2, 284, 285, 12, 3, 2, 2, 285, 287, 5, 6,
	4, 2, 286, 284, 3, 2, 2, 2, 287, 290, 3, 2, 2, 2, 288, 286, 3, 2, 2, 2,
	288, 289, 3, 2, 2, 2, 289, 29, 3, 2, 2, 2, 290, 288, 3, 2, 2, 2, 291, 296,
	5, 32, 17, 2, 292, 293, 7, 11, 2, 2, 293, 295, 5, 32, 17, 2, 294, 292,
	3, 2, 2, 2, 295, 298, 3, 2, 2, 2, 296, 294, 3, 2, 2, 2, 296, 297, 3, 2,
	2, 2, 297, 31, 3, 2, 2, 2, 298, 296, 3, 2, 2, 2, 299, 301, 5, 38, 20, 2,
	300, 302, 5, 34, 18, 2, 301, 300, 3, 2, 2, 2, 301, 302, 3, 2, 2, 2, 302,
	33, 3, 2, 2, 2, 303, 304, 7, 12, 2, 2, 304, 305, 5, 36, 19, 2, 305, 35,
	3, 2, 2, 2, 306, 308, 8, 19, 1, 2, 307, 309, 5, 84, 43, 2, 308, 307, 3,
	2, 2, 2, 308, 309, 3, 2, 2, 2, 309, 331, 3, 2, 2, 2, 310, 311, 7, 9, 2,
	2, 311, 312, 5, 86, 44, 2, 312, 313, 7, 10, 2, 2, 313, 314, 5, 86, 44,
	2, 314, 331, 3, 2, 2, 2, 315, 316, 7, 6, 2, 2, 316, 317, 5, 102, 52, 2,
	317, 318, 5, 86, 44, 2, 318, 331, 3, 2, 2, 2, 319, 320, 7, 7, 2, 2, 320,
	321, 5, 36, 19, 2, 321, 322, 7, 8, 2, 2, 322, 331, 3, 2, 2, 2, 323, 324,
	7, 9, 2, 2, 324, 325, 5, 86, 44, 2, 325, 326, 7, 10, 2, 2, 326, 327, 7,
	7, 2, 2, 327, 328, 5, 36, 19, 2, 328, 329, 7, 8, 2, 2, 329, 331, 3, 2,
	2, 2, 330, 306, 3, 2, 2, 2, 330, 310, 3, 2, 2, 2, 330, 315, 3, 2, 2, 2,
	330, 319, 3, 2, 2, 2, 330, 323, 3, 2, 2, 2, 331, 337, 3, 2, 2, 2, 332,
	333, 12, 3, 2, 2, 333, 334, 7, 11, 2, 2, 334, 336, 5, 36, 19, 4, 335, 332,
	3, 2, 2, 2, 336, 339, 3, 2, 2, 2, 337, 335, 3, 2, 2, 2, 337, 338, 3, 2,
	2, 2, 338, 37, 3, 2, 2, 2, 339, 337, 3, 2, 2, 2, 340, 342, 7, 97, 2, 2,
	341, 343, 5, 40, 21, 2, 342, 341, 3, 2, 2, 2, 342, 343, 3, 2, 2, 2, 343,
	377, 3, 2, 2, 2, 344, 345, 5, 42, 22, 2, 345, 347, 7, 97, 2, 2, 346, 348,
	5, 40, 21, 2, 347, 346, 3, 2, 2, 2, 347, 348, 3, 2, 2, 2, 348, 377, 3,
	2, 2, 2, 349, 350, 7, 4, 2, 2, 350, 351, 5, 42, 22, 2, 351, 353, 7, 97,
	2, 2, 352, 354, 5, 40, 21, 2, 353, 352, 3, 2, 2, 2, 353, 354, 3, 2, 2,
	2, 354, 355, 3, 2, 2, 2, 355, 356, 7, 5, 2, 2, 356, 358, 7, 4, 2, 2, 357,
	359, 5, 44, 23, 2, 358, 357, 3, 2, 2, 2, 358, 359, 3, 2, 2, 2, 359, 360,
	3, 2, 2, 2, 360, 361, 7, 5, 2, 2, 361, 377, 3, 2, 2, 2, 362, 363, 5, 42,
	22, 2, 363, 364, 7, 4, 2, 2, 364, 365, 5, 42, 22, 2, 365, 367, 7, 97, 2,
	2, 366, 368, 5, 40, 21, 2, 367, 366, 3, 2, 2, 2, 367, 368, 3, 2, 2, 2,
	368, 369, 3, 2, 2, 2, 369, 370, 7, 5, 2, 2, 370, 372, 7, 4, 2, 2, 371,
	373, 5, 44, 23, 2, 372, 371, 3, 2, 2, 2, 372, 373, 3, 2, 2, 2, 373, 374,
	3, 2, 2, 2, 374, 375, 7, 5, 2, 2, 375, 377, 3, 2, 2, 2, 376, 340, 3, 2,
	2, 2, 376, 344, 3, 2, 2, 2, 376, 349, 3, 2, 2, 2, 376, 362, 3, 2, 2, 2,
	377, 39, 3, 2, 2, 2, 378, 380, 7, 9, 2, 2, 379, 381, 5, 84, 43, 2, 380,
	379, 3, 2, 2, 2, 380, 381, 3, 2, 2, 2, 381, 382, 3, 2, 2, 2, 382, 384,
	7, 10, 2, 2, 383, 378, 3, 2, 2, 2, 384, 385, 3, 2, 2, 2, 385, 383, 3, 2,
	2, 2, 385, 386, 3, 2, 2, 2, 386, 41, 3, 2, 2, 2, 387, 389, 7, 13, 2, 2,
	388, 387, 3, 2, 2, 2, 389, 390, 3, 2, 2, 2, 390, 388, 3, 2, 2, 2, 390,
	391, 3, 2, 2, 2, 391, 43, 3, 2, 2, 2, 392, 394, 5, 46, 24, 2, 393, 392,
	3, 2, 2, 2, 394, 397, 3, 2, 2, 2, 395, 393, 3, 2, 2, 2, 395, 396, 3, 2,
	2, 2, 396, 398, 3, 2, 2, 2, 397, 395, 3, 2, 2, 2, 398, 399, 7, 11, 2, 2,
	399, 400, 5, 48, 25, 2, 400, 45, 3, 2, 2, 2, 401, 407, 5, 48, 25, 2, 402,
	403, 7, 13, 2, 2, 403, 407, 5, 114, 58, 2, 404, 405, 7, 6, 2, 2, 405, 407,
	5, 114, 58, 2, 406, 401, 3, 2, 2, 2, 406, 402, 3, 2, 2, 2, 406, 404, 3,
	2, 2, 2, 407, 47, 3, 2, 2, 2, 408, 444, 5, 114, 58, 2, 409, 410, 5, 114,
	58, 2, 410, 412, 5, 42, 22, 2, 411, 413, 5, 40, 21, 2, 412, 411, 3, 2,
	2, 2, 412, 413, 3, 2, 2, 2, 413, 444, 3, 2, 2, 2, 414, 415, 5, 114, 58,
	2, 415, 416, 7, 4, 2, 2, 416, 417, 5, 42, 22, 2, 417, 418, 7, 5, 2, 2,
	418, 420, 7, 4, 2, 2, 419, 421, 5, 44, 23, 2, 420, 419, 3, 2, 2, 2, 420,
	421, 3, 2, 2, 2, 421, 422, 3, 2, 2, 2, 422, 423, 7, 5, 2, 2, 423, 444,
	3, 2, 2, 2, 424, 425, 5, 114, 58, 2, 425, 426, 5, 42, 22, 2, 426, 427,
	7, 4, 2, 2, 427, 428, 5, 42, 22, 2, 428, 429, 7, 5, 2, 2, 429, 431, 7,
	4, 2, 2, 430, 432, 5, 44, 23, 2, 431, 430, 3, 2, 2, 2, 431, 432, 3, 2,
	2, 2, 432, 433, 3, 2, 2, 2, 433, 434, 7, 5, 2, 2, 434, 444, 3, 2, 2, 2,
	435, 436, 7, 85, 2, 2, 436, 444, 5, 50, 26, 2, 437, 438, 5, 114, 58, 2,
	438, 439, 5, 38, 20, 2, 439, 444, 3, 2, 2, 2, 440, 441, 7, 6, 2, 2, 441,
	442, 7, 6, 2, 2, 442, 444, 7, 6, 2, 2, 443, 408, 3, 2, 2, 2, 443, 409,
	3, 2, 2, 2, 443, 414, 3, 2, 2, 2, 443, 424, 3, 2, 2, 2, 443, 435, 3, 2,
	2, 2, 443, 437, 3, 2, 2, 2, 443, 440, 3, 2, 2, 2, 444, 49, 3, 2, 2, 2,
	445, 460, 5, 110, 56, 2, 446, 447, 5, 110, 56, 2, 447, 448, 7, 4, 2, 2,
	448, 449, 5, 42, 22, 2, 449, 450, 7, 5, 2, 2, 450, 452, 7, 4, 2, 2, 451,
	453, 5, 44, 23, 2, 452, 451, 3, 2, 2, 2, 452, 453, 3, 2, 2, 2, 453, 454,
	3, 2, 2, 2, 454, 455, 7, 5, 2, 2, 455, 460, 3, 2, 2, 2, 456, 457, 5, 110,
	56, 2, 457, 458, 5, 38, 20, 2, 458, 460, 3, 2, 2, 2, 459, 445, 3, 2, 2,
	2, 459, 446, 3, 2, 2, 2, 459, 456, 3, 2, 2, 2, 460, 51, 3, 2, 2, 2, 461,
	463, 5, 54, 28, 2, 462, 461, 3, 2, 2, 2, 463, 464, 3, 2, 2, 2, 464, 462,
	3, 2, 2, 2, 464, 465, 3, 2, 2, 2, 465, 53, 3, 2, 2, 2, 466, 468, 5, 114,
	58, 2, 467, 469, 5, 30, 16, 2, 468, 467, 3, 2, 2, 2, 468, 469, 3, 2, 2,
	2, 469, 470, 3, 2, 2, 2, 470, 471, 7, 3, 2, 2, 471, 480, 3, 2, 2, 2, 472,
	473, 7, 85, 2, 2, 473, 475, 5, 110, 56, 2, 474, 476, 5, 30, 16, 2, 475,
	474, 3, 2, 2, 2, 475, 476, 3, 2, 2, 2, 476, 477, 3, 2, 2, 2, 477, 478,
	7, 3, 2, 2, 478, 480, 3, 2, 2, 2, 479, 466, 3, 2, 2, 2, 479, 472, 3, 2,
	2, 2, 480, 55, 3, 2, 2, 2, 481, 483, 7, 7, 2, 2, 482, 484, 5, 52, 27, 2,
	483, 482, 3, 2, 2, 2, 483, 484, 3, 2, 2, 2, 484, 486, 3, 2, 2, 2, 485,
	487, 5, 58, 30, 2, 486, 485, 3, 2, 2, 2, 486, 487, 3, 2, 2, 2, 487, 488,
	3, 2, 2, 2, 488, 499, 7, 8, 2, 2, 489, 490, 7, 14, 2, 2, 490, 492, 7, 7,
	2, 2, 491, 493, 5, 52, 27, 2, 492, 491, 3, 2, 2, 2, 492, 493, 3, 2, 2,
	2, 493, 495, 3, 2, 2, 2, 494, 496, 5, 58, 30, 2, 495, 494, 3, 2, 2, 2,
	495, 496, 3, 2, 2, 2, 496, 497, 3, 2, 2, 2, 497, 499, 7, 8, 2, 2, 498,
	481, 3, 2, 2, 2, 498, 489, 3, 2, 2, 2, 499, 57, 3, 2, 2, 2, 500, 502, 5,
	76, 39, 2, 501, 500, 3, 2, 2, 2, 502, 503, 3, 2, 2, 2, 503, 501, 3, 2,
	2, 2, 503, 504, 3, 2, 2, 2, 504, 59, 3, 2, 2, 2, 505, 507, 7, 7, 2, 2,
	506, 508, 5, 62, 32, 2, 507, 506, 3, 2, 2, 2, 507, 508, 3, 2, 2, 2, 508,
	509, 3, 2, 2, 2, 509, 517, 7, 8, 2, 2, 510, 511, 7, 14, 2, 2, 511, 513,
	7, 7, 2, 2, 512, 514, 5, 68, 35, 2, 513, 512, 3, 2, 2, 2, 513, 514, 3,
	2, 2, 2, 514, 515, 3, 2, 2, 2, 515, 517, 7, 8, 2, 2, 516, 505, 3, 2, 2,
	2, 516, 510, 3, 2, 2, 2, 517, 61, 3, 2, 2, 2, 518, 520, 5, 64, 33, 2, 519,
	518, 3, 2, 2, 2, 520, 521, 3, 2, 2, 2, 521, 519, 3, 2, 2, 2, 521, 522,
	3, 2, 2, 2, 522, 63, 3, 2, 2, 2, 523, 524, 7, 59, 2, 2, 524, 525, 5, 90,
	46, 2, 525, 527, 7, 15, 2, 2, 526, 528, 5, 58, 30, 2, 527, 526, 3, 2, 2,
	2, 527, 528, 3, 2, 2, 2, 528, 535, 3, 2, 2, 2, 529, 530, 7, 63, 2, 2, 530,
	532, 7, 15, 2, 2, 531, 533, 5, 58, 30, 2, 532, 531, 3, 2, 2, 2, 532, 533,
	3, 2, 2, 2, 533, 535, 3, 2, 2, 2, 534, 523, 3, 2, 2, 2, 534, 529, 3, 2,
	2, 2, 535, 65, 3, 2, 2, 2, 536, 538, 7, 7, 2, 2, 537, 539, 5, 68, 35, 2,
	538, 537, 3, 2, 2, 2, 538, 539, 3, 2, 2, 2, 539, 540, 3, 2, 2, 2, 540,
	548, 7, 8, 2, 2, 541, 542, 7, 14, 2, 2, 542, 544, 7, 7, 2, 2, 543, 545,
	5, 68, 35, 2, 544, 543, 3, 2, 2, 2, 544, 545, 3, 2, 2, 2, 545, 546, 3,
	2, 2, 2, 546, 548, 7, 8, 2, 2, 547, 536, 3, 2, 2, 2, 547, 541, 3, 2, 2,
	2, 548, 67, 3, 2, 2, 2, 549, 551, 5, 70, 36, 2, 550, 549, 3, 2, 2, 2, 551,
	552, 3, 2, 2, 2, 552, 550, 3, 2, 2, 2, 552, 553, 3, 2, 2, 2, 553, 69, 3,
	2, 2, 2, 554, 555, 7, 59, 2, 2, 555, 556, 5, 86, 44, 2, 556, 558, 7, 15,
	2, 2, 557, 559, 5, 58, 30, 2, 558, 557, 3, 2, 2, 2, 558, 559, 3, 2, 2,
	2, 559, 566, 3, 2, 2, 2, 560, 561, 7, 63, 2, 2, 561, 563, 7, 15, 2, 2,
	562, 564, 5, 58, 30, 2, 563, 562, 3, 2, 2, 2, 563, 564, 3, 2, 2, 2, 564,
	566, 3, 2, 2, 2, 565, 554, 3, 2, 2, 2, 565, 560, 3, 2, 2, 2, 566, 71, 3,
	2, 2, 2, 567, 571, 5, 76, 39, 2, 568, 569, 7, 97, 2, 2, 569, 571, 5, 56,
	29, 2, 570, 567, 3, 2, 2, 2, 570, 568, 3, 2, 2, 2, 571, 73, 3, 2, 2, 2,
	572, 573, 7, 97, 2, 2, 573, 75, 3, 2, 2, 2, 574, 579, 5, 80, 41, 2, 575,
	576, 7, 97, 2, 2, 576, 577, 7, 15, 2, 2, 577, 579, 5, 76, 39, 2, 578, 574,
	3, 2, 2, 2, 578, 575, 3, 2, 2, 2, 579, 77, 3, 2, 2, 2, 580, 581, 7, 11,
	2, 2, 581, 582, 7, 98, 2, 2, 582, 79, 3, 2, 2, 2, 583, 585, 5, 84, 43,
	2, 584, 583, 3, 2, 2, 2, 584, 585, 3, 2, 2, 2, 585, 586, 3, 2, 2, 2, 586,
	695, 7, 3, 2, 2, 587, 695, 5, 56, 29, 2, 588, 589, 7, 61, 2, 2, 589, 591,
	5, 86, 44, 2, 590, 592, 5, 78, 40, 2, 591, 590, 3, 2, 2, 2, 591, 592, 3,
	2, 2, 2, 592, 593, 3, 2, 2, 2, 593, 594, 7, 3, 2, 2, 594, 695, 3, 2, 2,
	2, 595, 596, 7, 54, 2, 2, 596, 597, 5, 106, 54, 2, 597, 598, 7, 3, 2, 2,
	598, 695, 3, 2, 2, 2, 599, 600, 7, 90, 2, 2, 600, 601, 5, 106, 54, 2, 601,
	602, 7, 3, 2, 2, 602, 695, 3, 2, 2, 2, 603, 604, 7, 79, 2, 2, 604, 695,
	5, 72, 37, 2, 605, 607, 7, 78, 2, 2, 606, 608, 5, 74, 38, 2, 607, 606,
	3, 2, 2, 2, 607, 608, 3, 2, 2, 2, 608, 609, 3, 2, 2, 2, 609, 695, 7, 3,
	2, 2, 610, 611, 7, 70, 2, 2, 611, 612, 7, 97, 2, 2, 612, 695, 7, 3, 2,
	2, 613, 614, 7, 77, 2, 2, 614, 615, 5, 106, 54, 2, 615, 616, 7, 3, 2, 2,
	616, 695, 3, 2, 2, 2, 617, 618, 7, 84, 2, 2, 618, 619, 5, 106, 54, 2, 619,
	620, 7, 3, 2, 2, 620, 695, 3, 2, 2, 2, 621, 622, 7, 56, 2, 2, 622, 623,
	5, 86, 44, 2, 623, 624, 7, 3, 2, 2, 624, 695, 3, 2, 2, 2, 625, 626, 7,
	55, 2, 2, 626, 695, 5, 66, 34, 2, 627, 629, 7, 80, 2, 2, 628, 630, 5, 84,
	43, 2, 629, 628, 3, 2, 2, 2, 629, 630, 3, 2, 2, 2, 630, 631, 3, 2, 2, 2,
	631, 695, 7, 3, 2, 2, 632, 633, 7, 69, 2, 2, 633, 635, 7, 4, 2, 2, 634,
	636, 5, 84, 43, 2, 635, 634, 3, 2, 2, 2, 635, 636, 3, 2, 2, 2, 636, 637,
	3, 2, 2, 2, 637, 639, 7, 3, 2, 2, 638, 640, 5, 84, 43, 2, 639, 638, 3,
	2, 2, 2, 639, 640, 3, 2, 2, 2, 640, 641, 3, 2, 2, 2, 641, 643, 7, 3, 2,
	2, 642, 644, 5, 84, 43, 2, 643, 642, 3, 2, 2, 2, 643, 644, 3, 2, 2, 2,
	644, 645, 3, 2, 2, 2, 645, 646, 7, 5, 2, 2, 646, 695, 5, 76, 39, 2, 647,
	648, 7, 94, 2, 2, 648, 649, 7, 4, 2, 2, 649, 650, 5, 86, 44, 2, 650, 651,
	7, 5, 2, 2, 651, 652, 5, 76, 39, 2, 652, 695, 3, 2, 2, 2, 653, 654, 7,
	64, 2, 2, 654, 655, 5, 76, 39, 2, 655, 656, 7, 94, 2, 2, 656, 657, 7, 4,
	2, 2, 657, 658, 5, 86, 44, 2, 658, 659, 7, 5, 2, 2, 659, 695, 3, 2, 2,
	2, 660, 661, 7, 71, 2, 2, 661, 662, 7, 4, 2, 2, 662, 663, 5, 86, 44, 2,
	663, 664, 7, 5, 2, 2, 664, 665, 5, 76, 39, 2, 665, 695, 3, 2, 2, 2, 666,
	667, 7, 71, 2, 2, 667, 668, 7, 4, 2, 2, 668, 669, 5, 86, 44, 2, 669, 670,
	7, 5, 2, 2, 670, 671, 5, 76, 39, 2, 671, 672, 7, 65, 2, 2, 672, 673, 5,
	76, 39, 2, 673, 695, 3, 2, 2, 2, 674, 675, 7, 76, 2, 2, 675, 695, 5, 56,
	29, 2, 676, 677, 7, 83, 2, 2, 677, 678, 5, 86, 44, 2, 678, 679, 5, 66,
	34, 2, 679, 695, 3, 2, 2, 2, 680, 681, 7, 87, 2, 2, 681, 682, 5, 86, 44,
	2, 682, 683, 5, 60, 31, 2, 683, 695, 3, 2, 2, 2, 684, 686, 7, 62, 2, 2,
	685, 687, 5, 82, 42, 2, 686, 685, 3, 2, 2, 2, 686, 687, 3, 2, 2, 2, 687,
	688, 3, 2, 2, 2, 688, 695, 7, 3, 2, 2, 689, 691, 7, 57, 2, 2, 690, 692,
	5, 82, 42, 2, 691, 690, 3, 2, 2, 2, 691, 692, 3, 2, 2, 2, 692, 693, 3,
	2, 2, 2, 693, 695, 7, 3, 2, 2, 694, 584, 3, 2, 2, 2, 694, 587, 3, 2, 2,
	2, 694, 588, 3, 2, 2, 2, 694, 595, 3, 2, 2, 2, 694, 599, 3, 2, 2, 2, 694,
	603, 3, 2, 2, 2, 694, 605, 3, 2, 2, 2, 694, 610, 3, 2, 2, 2, 694, 613,
	3, 2, 2, 2, 694, 617, 3, 2, 2, 2, 694, 621, 3, 2, 2, 2, 694, 625, 3, 2,
	2, 2, 694, 627, 3, 2, 2, 2, 694, 632, 3, 2, 2, 2, 694, 647, 3, 2, 2, 2,
	694, 653, 3, 2, 2, 2, 694, 660, 3, 2, 2, 2, 694, 666, 3, 2, 2, 2, 694,
	674, 3, 2, 2, 2, 694, 676, 3, 2, 2, 2, 694, 680, 3, 2, 2, 2, 694, 684,
	3, 2, 2, 2, 694, 689, 3, 2, 2, 2, 695, 81, 3, 2, 2, 2, 696, 697, 7, 99,
	2, 2, 697, 83, 3, 2, 2, 2, 698, 699, 5, 86, 44, 2, 699, 85, 3, 2, 2, 2,
	700, 701, 8, 44, 1, 2, 701, 702, 5, 88, 45, 2, 702, 802, 3, 2, 2, 2, 703,
	704, 12, 34, 2, 2, 704, 705, 7, 13, 2, 2, 705, 801, 5, 86, 44, 35, 706,
	707, 12, 33, 2, 2, 707, 708, 7, 16, 2, 2, 708, 801, 5, 86, 44, 34, 709,
	710, 12, 32, 2, 2, 710, 711, 7, 17, 2, 2, 711, 801, 5, 86, 44, 33, 712,
	713, 12, 31, 2, 2, 713, 714, 7, 18, 2, 2, 714, 801, 5, 86, 44, 32, 715,
	716, 12, 30, 2, 2, 716, 717, 7, 19, 2, 2, 717, 801, 5, 86, 44, 31, 718,
	719, 12, 29, 2, 2, 719, 720, 7, 20, 2, 2, 720, 801, 5, 86, 44, 30, 721,
	722, 12, 28, 2, 2, 722, 723, 7, 21, 2, 2, 723, 801, 5, 86, 44, 29, 724,
	725, 12, 27, 2, 2, 725, 726, 7, 22, 2, 2, 726, 801, 5, 86, 44, 28, 727,
	728, 12, 26, 2, 2, 728, 729, 7, 23, 2, 2, 729, 801, 5, 86, 44, 27, 730,
	731, 12, 25, 2, 2, 731, 732, 7, 24, 2, 2, 732, 801, 5, 86, 44, 26, 733,
	734, 12, 24, 2, 2, 734, 735, 7, 25, 2, 2, 735, 801, 5, 86, 44, 25, 736,
	737, 12, 23, 2, 2, 737, 738, 7, 26, 2, 2, 738, 801, 5, 86, 44, 24, 739,
	740, 12, 22, 2, 2, 740, 741, 7, 27, 2, 2, 741, 801, 5, 86, 44, 23, 742,
	743, 12, 21, 2, 2, 743, 744, 7, 28, 2, 2, 744, 801, 5, 86, 44, 22, 745,
	746, 12, 20, 2, 2, 746, 747, 7, 29, 2, 2, 747, 801, 5, 86, 44, 21, 748,
	749, 12, 19, 2, 2, 749, 750, 7, 30, 2, 2, 750, 801, 5, 86, 44, 20, 751,
	752, 12, 18, 2, 2, 752, 753, 7, 31, 2, 2, 753, 801, 5, 86, 44, 19, 754,
	755, 12, 17, 2, 2, 755, 756, 7, 32, 2, 2, 756, 801, 5, 86, 44, 18, 757,
	758, 12, 16, 2, 2, 758, 759, 7, 12, 2, 2, 759, 801, 5, 86, 44, 17, 760,
	761, 12, 15, 2, 2, 761, 762, 7, 33, 2, 2, 762, 801, 5, 86, 44, 16, 763,
	764, 12, 14, 2, 2, 764, 765, 7, 34, 2, 2, 765, 766, 7, 12, 2, 2, 766, 801,
	5, 86, 44, 15, 767, 768, 12, 13, 2, 2, 768, 769, 7, 35, 2, 2, 769, 801,
	5, 86, 44, 14, 770, 771, 12, 12, 2, 2, 771, 772, 7, 36, 2, 2, 772, 801,
	5, 86, 44, 13, 773, 774, 12, 11, 2, 2, 774, 775, 7, 37, 2, 2, 775, 801,
	5, 86, 44, 12, 776, 777, 12, 10, 2, 2, 777, 778, 7, 38, 2, 2, 778, 801,
	5, 86, 44, 11, 779, 780, 12, 9, 2, 2, 780, 781, 7, 39, 2, 2, 781, 801,
	5, 86, 44, 10, 782, 783, 12, 8, 2, 2, 783, 784, 7, 40, 2, 2, 784, 801,
	5, 86, 44, 9, 785, 786, 12, 7, 2, 2, 786, 787, 7, 41, 2, 2, 787, 801, 5,
	86, 44, 8, 788, 789, 12, 6, 2, 2, 789, 790, 7, 42, 2, 2, 790, 801, 5, 86,
	44, 7, 791, 792, 12, 5, 2, 2, 792, 793, 7, 43, 2, 2, 793, 801, 5, 86, 44,
	6, 794, 795, 12, 4, 2, 2, 795, 796, 7, 44, 2, 2, 796, 801, 5, 86, 44, 5,
	797, 798, 12, 3, 2, 2, 798, 799, 7, 45, 2, 2, 799, 801, 5, 86, 44, 4, 800,
	703, 3, 2, 2, 2, 800, 706, 3, 2, 2, 2, 800, 709, 3, 2, 2, 2, 800, 712,
	3, 2, 2, 2, 800, 715, 3, 2, 2, 2, 800, 718, 3, 2, 2, 2, 800, 721, 3, 2,
	2, 2, 800, 724, 3, 2, 2, 2, 800, 727, 3, 2, 2, 2, 800, 730, 3, 2, 2, 2,
	800, 733, 3, 2, 2, 2, 800, 736, 3, 2, 2, 2, 800, 739, 3, 2, 2, 2, 800,
	742, 3, 2, 2, 2, 800, 745, 3, 2, 2, 2, 800, 748, 3, 2, 2, 2, 800, 751,
	3, 2, 2, 2, 800, 754, 3, 2, 2, 2, 800, 757, 3, 2, 2, 2, 800, 760, 3, 2,
	2, 2, 800, 763, 3, 2, 2, 2, 800, 767, 3, 2, 2, 2, 800, 770, 3, 2, 2, 2,
	800, 773, 3, 2, 2, 2, 800, 776, 3, 2, 2, 2, 800, 779, 3, 2, 2, 2, 800,
	782, 3, 2, 2, 2, 800, 785, 3, 2, 2, 2, 800, 788, 3, 2, 2, 2, 800, 791,
	3, 2, 2, 2, 800, 794, 3, 2, 2, 2, 800, 797, 3, 2, 2, 2, 801, 804, 3, 2,
	2, 2, 802, 800, 3, 2, 2, 2, 802, 803, 3, 2, 2, 2, 803, 87, 3, 2, 2, 2,
	804, 802, 3, 2, 2, 2, 805, 818, 5, 92, 47, 2, 806, 807, 7, 4, 2, 2, 807,
	808, 5, 90, 46, 2, 808, 809, 7, 5, 2, 2, 809, 810, 5, 88, 45, 2, 810, 818,
	3, 2, 2, 2, 811, 812, 7, 4, 2, 2, 812, 813, 7, 54, 2, 2, 813, 814, 5, 90,
	46, 2, 814, 815, 7, 5, 2, 2, 815, 816, 5, 88, 45, 2, 816, 818, 3, 2, 2,
	2, 817, 805, 3, 2, 2, 2, 817, 806, 3, 2, 2, 2, 817, 811, 3, 2, 2, 2, 818,
	89, 3, 2, 2, 2, 819, 836, 5, 114, 58, 2, 820, 821, 5, 114, 58, 2, 821,
	822, 5, 42, 22, 2, 822, 836, 3, 2, 2, 2, 823, 824, 5, 114, 58, 2, 824,
	825, 7, 4, 2, 2, 825, 826, 5, 42, 22, 2, 826, 827, 7, 5, 2, 2, 827, 829,
	7, 4, 2, 2, 828, 830, 5, 44, 23, 2, 829, 828, 3, 2, 2, 2, 829, 830, 3,
	2, 2, 2, 830, 831, 3, 2, 2, 2, 831, 832, 7, 5, 2, 2, 832, 836, 3, 2, 2,
	2, 833, 834, 7, 85, 2, 2, 834, 836, 5, 110, 56, 2, 835, 819, 3, 2, 2, 2,
	835, 820, 3, 2, 2, 2, 835, 823, 3, 2, 2, 2, 835, 833, 3, 2, 2, 2, 836,
	91, 3, 2, 2, 2, 837, 863, 5, 100, 51, 2, 838, 839, 7, 13, 2, 2, 839, 863,
	5, 88, 45, 2, 840, 841, 7, 28, 2, 2, 841, 863, 5, 88, 45, 2, 842, 843,
	7, 18, 2, 2, 843, 863, 5, 88, 45, 2, 844, 845, 7, 19, 2, 2, 845, 863, 5,
	88, 45, 2, 846, 847, 7, 46, 2, 2, 847, 863, 5, 88, 45, 2, 848, 849, 7,
	95, 2, 2, 849, 863, 5, 88, 45, 2, 850, 851, 7, 47, 2, 2, 851, 863, 5, 88,
	45, 2, 852, 853, 7, 14, 2, 2, 853, 863, 5, 88, 45, 2, 854, 855, 7, 48,
	2, 2, 855, 863, 5, 88, 45, 2, 856, 857, 7, 82, 2, 2, 857, 863, 5, 92, 47,
	2, 858, 859, 7, 34, 2, 2, 859, 863, 5, 88, 45, 2, 860, 861, 7, 49, 2, 2,
	861, 863, 5, 88, 45, 2, 862, 837, 3, 2, 2, 2, 862, 838, 3, 2, 2, 2, 862,
	840, 3, 2, 2, 2, 862, 842, 3, 2, 2, 2, 862, 844, 3, 2, 2, 2, 862, 846,
	3, 2, 2, 2, 862, 848, 3, 2, 2, 2, 862, 850, 3, 2, 2, 2, 862, 852, 3, 2,
	2, 2, 862, 854, 3, 2, 2, 2, 862, 856, 3, 2, 2, 2, 862, 858, 3, 2, 2, 2,
	862, 860, 3, 2, 2, 2, 863, 93, 3, 2, 2, 2, 864, 865, 5, 96, 49, 2, 865,
	95, 3, 2, 2, 2, 866, 871, 5, 98, 50, 2, 867, 868, 7, 11, 2, 2, 868, 870,
	5, 98, 50, 2, 869, 867, 3, 2, 2, 2, 870, 873, 3, 2, 2, 2, 871, 869, 3,
	2, 2, 2, 871, 872, 3, 2, 2, 2, 872, 97, 3, 2, 2, 2, 873, 871, 3, 2, 2,
	2, 874, 881, 5, 86, 44, 2, 875, 877, 7, 7, 2, 2, 876, 878, 5, 94, 48, 2,
	877, 876, 3, 2, 2, 2, 877, 878, 3, 2, 2, 2, 878, 879, 3, 2, 2, 2, 879,
	881, 7, 8, 2, 2, 880, 874, 3, 2, 2, 2, 880, 875, 3, 2, 2, 2, 881, 99, 3,
	2, 2, 2, 882, 883, 8, 51, 1, 2, 883, 884, 7, 4, 2, 2, 884, 885, 5, 96,
	49, 2, 885, 886, 7, 5, 2, 2, 886, 909, 3, 2, 2, 2, 887, 888, 7, 82, 2,
	2, 888, 889, 7, 4, 2, 2, 889, 890, 5, 90, 46, 2, 890, 891, 7, 5, 2, 2,
	891, 909, 3, 2, 2, 2, 892, 893, 7, 6, 2, 2, 893, 894, 5, 120, 61, 2, 894,
	895, 7, 6, 2, 2, 895, 896, 5, 102, 52, 2, 896, 909, 3, 2, 2, 2, 897, 909,
	5, 26, 14, 2, 898, 899, 7, 6, 2, 2, 899, 900, 7, 6, 2, 2, 900, 909, 7,
	6, 2, 2, 901, 909, 7, 100, 2, 2, 902, 909, 7, 75, 2, 2, 903, 909, 7, 99,
	2, 2, 904, 909, 5, 122, 62, 2, 905, 909, 7, 98, 2, 2, 906, 907, 7, 51,
	2, 2, 907, 909, 7, 98, 2, 2, 908, 882, 3, 2, 2, 2, 908, 887, 3, 2, 2, 2,
	908, 892, 3, 2, 2, 2, 908, 897, 3, 2, 2, 2, 908, 898, 3, 2, 2, 2, 908,
	901, 3, 2, 2, 2, 908, 902, 3, 2, 2, 2, 908, 903, 3, 2, 2, 2, 908, 904,
	3, 2, 2, 2, 908, 905, 3, 2, 2, 2, 908, 906, 3, 2, 2, 2, 909, 935, 3, 2,
	2, 2, 910, 911, 12, 18, 2, 2, 911, 913, 7, 4, 2, 2, 912, 914, 5, 104, 53,
	2, 913, 912, 3, 2, 2, 2, 913, 914, 3, 2, 2, 2, 914, 915, 3, 2, 2, 2, 915,
	934, 7, 5, 2, 2, 916, 917, 12, 17, 2, 2, 917, 918, 7, 9, 2, 2, 918, 919,
	5, 86, 44, 2, 919, 920, 7, 10, 2, 2, 920, 934, 3, 2, 2, 2, 921, 922, 12,
	16, 2, 2, 922, 923, 7, 6, 2, 2, 923, 934, 5, 102, 52, 2, 924, 925, 12,
	14, 2, 2, 925, 926, 7, 50, 2, 2, 926, 934, 5, 102, 52, 2, 927, 928, 12,
	13, 2, 2, 928, 934, 7, 46, 2, 2, 929, 930, 12, 12, 2, 2, 930, 934, 7, 47,
	2, 2, 931, 932, 12, 11, 2, 2, 932, 934, 7, 49, 2, 2, 933, 910, 3, 2, 2,
	2, 933, 916, 3, 2, 2, 2, 933, 921, 3, 2, 2, 2, 933, 924, 3, 2, 2, 2, 933,
	927, 3, 2, 2, 2, 933, 929, 3, 2, 2, 2, 933, 931, 3, 2, 2, 2, 934, 937,
	3, 2, 2, 2, 935, 933, 3, 2, 2, 2, 935, 936, 3, 2, 2, 2, 936, 101, 3, 2,
	2, 2, 937, 935, 3, 2, 2, 2, 938, 941, 7, 97, 2, 2, 939, 941, 5, 120, 61,
	2, 940, 938, 3, 2, 2, 2, 940, 939, 3, 2, 2, 2, 941, 103, 3, 2, 2, 2, 942,
	943, 5, 106, 54, 2, 943, 105, 3, 2, 2, 2, 944, 945, 8, 54, 1, 2, 945, 946,
	5, 86, 44, 2, 946, 952, 3, 2, 2, 2, 947, 948, 12, 3, 2, 2, 948, 949, 7,
	11, 2, 2, 949, 951, 5, 86, 44, 2, 950, 947, 3, 2, 2, 2, 951, 954, 3, 2,
	2, 2, 952, 950, 3, 2, 2, 2, 952, 953, 3, 2, 2, 2, 953, 107, 3, 2, 2, 2,
	954, 952, 3, 2, 2, 2, 955, 961, 5, 90, 46, 2, 956, 957, 5, 90, 46, 2, 957,
	958, 7, 11, 2, 2, 958, 959, 5, 108, 55, 2, 959, 961, 3, 2, 2, 2, 960, 955,
	3, 2, 2, 2, 960, 956, 3, 2, 2, 2, 961, 109, 3, 2, 2, 2, 962, 964, 5, 118,
	60, 2, 963, 962, 3, 2, 2, 2, 963, 964, 3, 2, 2, 2, 964, 965, 3, 2, 2, 2,
	965, 982, 5, 114, 58, 2, 966, 968, 5, 118, 60, 2, 967, 966, 3, 2, 2, 2,
	967, 968, 3, 2, 2, 2, 968, 969, 3, 2, 2, 2, 969, 970, 7, 85, 2, 2, 970,
	971, 7, 4, 2, 2, 971, 972, 5, 108, 55, 2, 972, 973, 7, 5, 2, 2, 973, 982,
	3, 2, 2, 2, 974, 976, 5, 118, 60, 2, 975, 974, 3, 2, 2, 2, 975, 976, 3,
	2, 2, 2, 976, 977, 3, 2, 2, 2, 977, 978, 7, 4, 2, 2, 978, 979, 5, 108,
	55, 2, 979, 980, 7, 5, 2, 2, 980, 982, 3, 2, 2, 2, 981, 963, 3, 2, 2, 2,
	981, 967, 3, 2, 2, 2, 981, 975, 3, 2, 2, 2, 982, 111, 3, 2, 2, 2, 983,
	989, 5, 90, 46, 2, 984, 985, 5, 90, 46, 2, 985, 986, 7, 11, 2, 2, 986,
	987, 5, 112, 57, 2, 987, 989, 3, 2, 2, 2, 988, 983, 3, 2, 2, 2, 988, 984,
	3, 2, 2, 2, 989, 113, 3, 2, 2, 2, 990, 1011, 7, 72, 2, 2, 991, 1011, 7,
	88, 2, 2, 992, 1011, 7, 81, 2, 2, 993, 1011, 7, 92, 2, 2, 994, 1011, 7,
	58, 2, 2, 995, 1011, 7, 68, 2, 2, 996, 1011, 7, 93, 2, 2, 997, 1011, 5,
	120, 61, 2, 998, 999, 5, 120, 61, 2, 999, 1000, 7, 9, 2, 2, 1000, 1001,
	5, 112, 57, 2, 1001, 1002, 7, 10, 2, 2, 1002, 1011, 3, 2, 2, 2, 1003, 1004,
	7, 60, 2, 2, 1004, 1005, 7, 4, 2, 2, 1005, 1006, 5, 112, 57, 2, 1006, 1008,
	7, 5, 2, 2, 1007, 1009, 5, 116, 59, 2, 1008, 1007, 3, 2, 2, 2, 1008, 1009,
	3, 2, 2, 2, 1009, 1011, 3, 2, 2, 2, 1010, 990, 3, 2, 2, 2, 1010, 991, 3,
	2, 2, 2, 1010, 992, 3, 2, 2, 2, 1010, 993, 3, 2, 2, 2, 1010, 994, 3, 2,
	2, 2, 1010, 995, 3, 2, 2, 2, 1010, 996, 3, 2, 2, 2, 1010, 997, 3, 2, 2,
	2, 1010, 998, 3, 2, 2, 2, 1010, 1003, 3, 2, 2, 2, 1011, 115, 3, 2, 2, 2,
	1012, 1013, 7, 9, 2, 2, 1013, 1014, 5, 86, 44, 2, 1014, 1015, 7, 10, 2,
	2, 1015, 117, 3, 2, 2, 2, 1016, 1017, 9, 2, 2, 2, 1017, 119, 3, 2, 2, 2,
	1018, 1019, 7, 97, 2, 2, 1019, 121, 3, 2, 2, 2, 1020, 1021, 7, 97, 2, 2,
	1021, 123, 3, 2, 2, 2, 110, 125, 130, 134, 142, 151, 160, 172, 179, 183,
	191, 202, 206, 212, 216, 222, 226, 229, 235, 239, 245, 249, 260, 264, 271,
	277, 288, 296, 301, 308, 330, 337, 342, 347, 353, 358, 367, 372, 376, 380,
	385, 390, 395, 406, 412, 420, 431, 443, 452, 459, 464, 468, 475, 479, 483,
	486, 492, 495, 498, 503, 507, 513, 516, 521, 527, 532, 534, 538, 544, 547,
	552, 558, 563, 565, 570, 578, 584, 591, 607, 629, 635, 639, 643, 686, 691,
	694, 800, 802, 817, 829, 835, 862, 871, 877, 880, 908, 913, 933, 935, 940,
	952, 960, 963, 967, 975, 981, 988, 1008, 1010,
}
var literalNames = []string{
	"", "';'", "'('", "')'", "'.'", "'{'", "'}'", "'['", "']'", "','", "'='",
	"'*'", "'!'", "':'", "'/'", "'%'", "'+'", "'-'", "'>>'", "'<<'", "'<'",
	"'>'", "'<='", "'>='", "'=='", "'!='", "'&'", "'^'", "'|'", "'&&'", "'||'",
	"':='", "'<-'", "'+='", "'-='", "'*='", "'/='", "'%='", "'>>='", "'<<='",
	"'&='", "'|='", "'^='", "'::'", "'--'", "'++'", "'~'", "'?'", "'->'", "'$'",
	"'adt'", "'aggr'", "'alloc'", "'alt'", "'become'", "'break'", "'byte'",
	"'case'", "'chan'", "'check'", "'continue'", "'default'", "'do'", "'else'",
	"'enum'", "'extern'", "'float'", "'for'", "'goto'", "'if'", "'int'", "'intern'",
	"'lint'", "'nil'", "'par'", "'proc'", "'raise'", "'rescue'", "'return'",
	"'sint'", "'sizeof'", "'switch'", "'task'", "'tuple'", "'typedef'", "'typeof'",
	"'uint'", "'ulint'", "'unalloc'", "'union'", "'usint'", "'void'", "'while'",
	"'zerox'", "'private'",
}
var symbolicNames = []string{
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "ADT", "AGGR",
	"ALLOC", "ALT", "BECOME", "BREAK", "BYTE", "CASE", "CHAN", "CHECK", "CONTINUE",
	"DEFAULT", "DO", "ELSE", "ENUM", "EXTERN", "FLOAT", "FOR", "GOTO", "IF",
	"INT", "INTERN", "LINT", "NIL", "PAR", "PROC", "RAISE", "RESCUE", "RETURN",
	"SINT", "SIZEOF", "SWITCH", "TASK", "TUPLE", "TYPEDEF", "TYPEOF", "UINT",
	"ULINT", "UNALLOC", "UNION", "USINT", "VOID", "WHILE", "ZEROX", "PRIVATE",
	"IDENTIFIER", "STRING_CONST", "CONSTANT", "ARITHMETIC_CONST", "WS",
}

var ruleNames = []string{
	"program", "decllist", "decl", "zargs", "ztname", "adtfunc", "typespec",
	"ztag", "zpolytype", "polytype", "setlist", "sname", "name", "memberlist",
	"vardecllist", "ivardecl", "zinit", "zelist", "vardecl", "arrayspec", "indsp",
	"arglist", "arglistp", "arg", "tuplearg", "autolist", "autodecl", "block",
	"slist", "tbody", "ctlist", "tcase", "cbody", "clist", "case_", "rbody",
	"zlab", "stmnt", "info", "nlstmnt", "zconst", "zexpr", "expr_", "castexpr",
	"typecast", "monexpr", "ztelist", "telist", "tcomp", "term_", "stag", "zarlist",
	"elist", "tlist", "tname", "variant", "xtname", "bufdim", "sclass", "typename",
	"enum_member",
}

type alefParser struct {
	*antlr.BaseParser
}

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

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

	return this
}

// alefParser tokens.
const (
	alefParserEOF              = antlr.TokenEOF
	alefParserT__0             = 1
	alefParserT__1             = 2
	alefParserT__2             = 3
	alefParserT__3             = 4
	alefParserT__4             = 5
	alefParserT__5             = 6
	alefParserT__6             = 7
	alefParserT__7             = 8
	alefParserT__8             = 9
	alefParserT__9             = 10
	alefParserT__10            = 11
	alefParserT__11            = 12
	alefParserT__12            = 13
	alefParserT__13            = 14
	alefParserT__14            = 15
	alefParserT__15            = 16
	alefParserT__16            = 17
	alefParserT__17            = 18
	alefParserT__18            = 19
	alefParserT__19            = 20
	alefParserT__20            = 21
	alefParserT__21            = 22
	alefParserT__22            = 23
	alefParserT__23            = 24
	alefParserT__24            = 25
	alefParserT__25            = 26
	alefParserT__26            = 27
	alefParserT__27            = 28
	alefParserT__28            = 29
	alefParserT__29            = 30
	alefParserT__30            = 31
	alefParserT__31            = 32
	alefParserT__32            = 33
	alefParserT__33            = 34
	alefParserT__34            = 35
	alefParserT__35            = 36
	alefParserT__36            = 37
	alefParserT__37            = 38
	alefParserT__38            = 39
	alefParserT__39            = 40
	alefParserT__40            = 41
	alefParserT__41            = 42
	alefParserT__42            = 43
	alefParserT__43            = 44
	alefParserT__44            = 45
	alefParserT__45            = 46
	alefParserT__46            = 47
	alefParserT__47            = 48
	alefParserT__48            = 49
	alefParserADT              = 50
	alefParserAGGR             = 51
	alefParserALLOC            = 52
	alefParserALT              = 53
	alefParserBECOME           = 54
	alefParserBREAK            = 55
	alefParserBYTE             = 56
	alefParserCASE             = 57
	alefParserCHAN             = 58
	alefParserCHECK            = 59
	alefParserCONTINUE         = 60
	alefParserDEFAULT          = 61
	alefParserDO               = 62
	alefParserELSE             = 63
	alefParserENUM             = 64
	alefParserEXTERN           = 65
	alefParserFLOAT            = 66
	alefParserFOR              = 67
	alefParserGOTO             = 68
	alefParserIF               = 69
	alefParserINT              = 70
	alefParserINTERN           = 71
	alefParserLINT             = 72
	alefParserNIL              = 73
	alefParserPAR              = 74
	alefParserPROC             = 75
	alefParserRAISE            = 76
	alefParserRESCUE           = 77
	alefParserRETURN           = 78
	alefParserSINT             = 79
	alefParserSIZEOF           = 80
	alefParserSWITCH           = 81
	alefParserTASK             = 82
	alefParserTUPLE            = 83
	alefParserTYPEDEF          = 84
	alefParserTYPEOF           = 85
	alefParserUINT             = 86
	alefParserULINT            = 87
	alefParserUNALLOC          = 88
	alefParserUNION            = 89
	alefParserUSINT            = 90
	alefParserVOID             = 91
	alefParserWHILE            = 92
	alefParserZEROX            = 93
	alefParserPRIVATE          = 94
	alefParserIDENTIFIER       = 95
	alefParserSTRING_CONST     = 96
	alefParserCONSTANT         = 97
	alefParserARITHMETIC_CONST = 98
	alefParserWS               = 99
)

// alefParser rules.
const (
	alefParserRULE_program     = 0
	alefParserRULE_decllist    = 1
	alefParserRULE_decl        = 2
	alefParserRULE_zargs       = 3
	alefParserRULE_ztname      = 4
	alefParserRULE_adtfunc     = 5
	alefParserRULE_typespec    = 6
	alefParserRULE_ztag        = 7
	alefParserRULE_zpolytype   = 8
	alefParserRULE_polytype    = 9
	alefParserRULE_setlist     = 10
	alefParserRULE_sname       = 11
	alefParserRULE_name        = 12
	alefParserRULE_memberlist  = 13
	alefParserRULE_vardecllist = 14
	alefParserRULE_ivardecl    = 15
	alefParserRULE_zinit       = 16
	alefParserRULE_zelist      = 17
	alefParserRULE_vardecl     = 18
	alefParserRULE_arrayspec   = 19
	alefParserRULE_indsp       = 20
	alefParserRULE_arglist     = 21
	alefParserRULE_arglistp    = 22
	alefParserRULE_arg         = 23
	alefParserRULE_tuplearg    = 24
	alefParserRULE_autolist    = 25
	alefParserRULE_autodecl    = 26
	alefParserRULE_block       = 27
	alefParserRULE_slist       = 28
	alefParserRULE_tbody       = 29
	alefParserRULE_ctlist      = 30
	alefParserRULE_tcase       = 31
	alefParserRULE_cbody       = 32
	alefParserRULE_clist       = 33
	alefParserRULE_case_       = 34
	alefParserRULE_rbody       = 35
	alefParserRULE_zlab        = 36
	alefParserRULE_stmnt       = 37
	alefParserRULE_info        = 38
	alefParserRULE_nlstmnt     = 39
	alefParserRULE_zconst      = 40
	alefParserRULE_zexpr       = 41
	alefParserRULE_expr_       = 42
	alefParserRULE_castexpr    = 43
	alefParserRULE_typecast    = 44
	alefParserRULE_monexpr     = 45
	alefParserRULE_ztelist     = 46
	alefParserRULE_telist      = 47
	alefParserRULE_tcomp       = 48
	alefParserRULE_term_       = 49
	alefParserRULE_stag        = 50
	alefParserRULE_zarlist     = 51
	alefParserRULE_elist       = 52
	alefParserRULE_tlist       = 53
	alefParserRULE_tname       = 54
	alefParserRULE_variant     = 55
	alefParserRULE_xtname      = 56
	alefParserRULE_bufdim      = 57
	alefParserRULE_sclass      = 58
	alefParserRULE_typename    = 59
	alefParserRULE_enum_member = 60
)

// 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 = alefParserRULE_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 = alefParserRULE_program

	return p
}

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

func (s *ProgramContext) Decllist() IDecllistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDecllistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDecllistContext)
}

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

func (s *ProgramContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitProgram(s)
	}
}

func (p *alefParser) Program() (localctx IProgramContext) {
	this := p
	_ = this

	localctx = NewProgramContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 0, alefParserRULE_program)
	var _la int

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

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

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

	if _la == alefParserT__1 || (((_la-50)&-(0x1f+1)) == 0 && ((1<<uint((_la-50)))&((1<<(alefParserADT-50))|(1<<(alefParserAGGR-50))|(1<<(alefParserBYTE-50))|(1<<(alefParserCHAN-50))|(1<<(alefParserENUM-50))|(1<<(alefParserEXTERN-50))|(1<<(alefParserFLOAT-50))|(1<<(alefParserINT-50))|(1<<(alefParserINTERN-50))|(1<<(alefParserSINT-50)))) != 0) || (((_la-83)&-(0x1f+1)) == 0 && ((1<<uint((_la-83)))&((1<<(alefParserTUPLE-83))|(1<<(alefParserTYPEDEF-83))|(1<<(alefParserUINT-83))|(1<<(alefParserUNION-83))|(1<<(alefParserUSINT-83))|(1<<(alefParserVOID-83))|(1<<(alefParserPRIVATE-83))|(1<<(alefParserIDENTIFIER-83)))) != 0) {
		{
			p.SetState(122)
			p.Decllist()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyDecllistContext() *DecllistContext {
	var p = new(DecllistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_decllist
	return p
}

func (*DecllistContext) IsDecllistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_decllist

	return p
}

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

func (s *DecllistContext) AllDecl() []IDeclContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDeclContext)(nil)).Elem())
	var tst = make([]IDeclContext, len(ts))

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

	return tst
}

func (s *DecllistContext) Decl(i int) IDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDeclContext)
}

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

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

func (s *DecllistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterDecllist(s)
	}
}

func (s *DecllistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitDecllist(s)
	}
}

func (p *alefParser) Decllist() (localctx IDecllistContext) {
	this := p
	_ = this

	localctx = NewDecllistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 2, alefParserRULE_decllist)
	var _la int

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

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

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

	for ok := true; ok; ok = _la == alefParserT__1 || (((_la-50)&-(0x1f+1)) == 0 && ((1<<uint((_la-50)))&((1<<(alefParserADT-50))|(1<<(alefParserAGGR-50))|(1<<(alefParserBYTE-50))|(1<<(alefParserCHAN-50))|(1<<(alefParserENUM-50))|(1<<(alefParserEXTERN-50))|(1<<(alefParserFLOAT-50))|(1<<(alefParserINT-50))|(1<<(alefParserINTERN-50))|(1<<(alefParserSINT-50)))) != 0) || (((_la-83)&-(0x1f+1)) == 0 && ((1<<uint((_la-83)))&((1<<(alefParserTUPLE-83))|(1<<(alefParserTYPEDEF-83))|(1<<(alefParserUINT-83))|(1<<(alefParserUNION-83))|(1<<(alefParserUSINT-83))|(1<<(alefParserVOID-83))|(1<<(alefParserPRIVATE-83))|(1<<(alefParserIDENTIFIER-83)))) != 0) {
		{
			p.SetState(125)
			p.Decl()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyDeclContext() *DeclContext {
	var p = new(DeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_decl
	return p
}

func (*DeclContext) IsDeclContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_decl

	return p
}

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

func (s *DeclContext) Tname() ITnameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITnameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITnameContext)
}

func (s *DeclContext) Vardecllist() IVardecllistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVardecllistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVardecllistContext)
}

func (s *DeclContext) Vardecl() IVardeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVardeclContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVardeclContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *DeclContext) Arglist() IArglistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArglistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArglistContext)
}

func (s *DeclContext) Adtfunc() IAdtfuncContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAdtfuncContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAdtfuncContext)
}

func (s *DeclContext) Typespec() ITypespecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypespecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypespecContext)
}

func (s *DeclContext) TYPEDEF() antlr.TerminalNode {
	return s.GetToken(alefParserTYPEDEF, 0)
}

func (s *DeclContext) Ztname() IZtnameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IZtnameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IZtnameContext)
}

func (s *DeclContext) Zargs() IZargsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IZargsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IZargsContext)
}

func (s *DeclContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(alefParserIDENTIFIER, 0)
}

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

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

func (s *DeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterDecl(s)
	}
}

func (s *DeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitDecl(s)
	}
}

func (p *alefParser) Decl() (localctx IDeclContext) {
	this := p
	_ = this

	localctx = NewDeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, alefParserRULE_decl)
	var _la int

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

	defer func() {
		if err := recover(); err != nil {
			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(177)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(130)
			p.Tname()
		}
		p.SetState(132)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserT__1 || _la == alefParserT__10 || _la == alefParserIDENTIFIER {
			{
				p.SetState(131)
				p.Vardecllist()
			}

		}
		{
			p.SetState(134)
			p.Match(alefParserT__0)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(136)
			p.Tname()
		}
		{
			p.SetState(137)
			p.Vardecl()
		}
		{
			p.SetState(138)
			p.Match(alefParserT__1)
		}
		p.SetState(140)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__3)|(1<<alefParserT__8)|(1<<alefParserT__10))) != 0) || (((_la-56)&-(0x1f+1)) == 0 && ((1<<uint((_la-56)))&((1<<(alefParserBYTE-56))|(1<<(alefParserCHAN-56))|(1<<(alefParserFLOAT-56))|(1<<(alefParserINT-56))|(1<<(alefParserSINT-56))|(1<<(alefParserTUPLE-56))|(1<<(alefParserUINT-56)))) != 0) || (((_la-90)&-(0x1f+1)) == 0 && ((1<<uint((_la-90)))&((1<<(alefParserUSINT-90))|(1<<(alefParserVOID-90))|(1<<(alefParserIDENTIFIER-90)))) != 0) {
			{
				p.SetState(139)
				p.Arglist()
			}

		}
		{
			p.SetState(142)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(143)
			p.Block()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(145)
			p.Tname()
		}
		{
			p.SetState(146)
			p.Adtfunc()
		}
		{
			p.SetState(147)
			p.Match(alefParserT__1)
		}
		p.SetState(149)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__3)|(1<<alefParserT__8)|(1<<alefParserT__10))) != 0) || (((_la-56)&-(0x1f+1)) == 0 && ((1<<uint((_la-56)))&((1<<(alefParserBYTE-56))|(1<<(alefParserCHAN-56))|(1<<(alefParserFLOAT-56))|(1<<(alefParserINT-56))|(1<<(alefParserSINT-56))|(1<<(alefParserTUPLE-56))|(1<<(alefParserUINT-56)))) != 0) || (((_la-90)&-(0x1f+1)) == 0 && ((1<<uint((_la-90)))&((1<<(alefParserUSINT-90))|(1<<(alefParserVOID-90))|(1<<(alefParserIDENTIFIER-90)))) != 0) {
			{
				p.SetState(148)
				p.Arglist()
			}

		}
		{
			p.SetState(151)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(152)
			p.Block()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(154)
			p.Tname()
		}
		{
			p.SetState(155)
			p.Vardecl()
		}
		{
			p.SetState(156)
			p.Match(alefParserT__1)
		}
		p.SetState(158)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__3)|(1<<alefParserT__8)|(1<<alefParserT__10))) != 0) || (((_la-56)&-(0x1f+1)) == 0 && ((1<<uint((_la-56)))&((1<<(alefParserBYTE-56))|(1<<(alefParserCHAN-56))|(1<<(alefParserFLOAT-56))|(1<<(alefParserINT-56))|(1<<(alefParserSINT-56))|(1<<(alefParserTUPLE-56))|(1<<(alefParserUINT-56)))) != 0) || (((_la-90)&-(0x1f+1)) == 0 && ((1<<uint((_la-90)))&((1<<(alefParserUSINT-90))|(1<<(alefParserVOID-90))|(1<<(alefParserIDENTIFIER-90)))) != 0) {
			{
				p.SetState(157)
				p.Arglist()
			}

		}
		{
			p.SetState(160)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(161)
			p.Match(alefParserT__0)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(163)
			p.Typespec()
		}
		{
			p.SetState(164)
			p.Match(alefParserT__0)
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(166)
			p.Match(alefParserTYPEDEF)
		}
		{
			p.SetState(167)
			p.Ztname()
		}
		{
			p.SetState(168)
			p.Vardecl()
		}
		p.SetState(170)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserT__1 {
			{
				p.SetState(169)
				p.Zargs()
			}

		}
		{
			p.SetState(172)
			p.Match(alefParserT__0)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(174)
			p.Match(alefParserTYPEDEF)
		}
		{
			p.SetState(175)
			p.Match(alefParserIDENTIFIER)
		}
		{
			p.SetState(176)
			p.Match(alefParserT__0)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyZargsContext() *ZargsContext {
	var p = new(ZargsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_zargs
	return p
}

func (*ZargsContext) IsZargsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_zargs

	return p
}

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

func (s *ZargsContext) Arglist() IArglistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArglistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArglistContext)
}

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

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

func (s *ZargsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterZargs(s)
	}
}

func (s *ZargsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitZargs(s)
	}
}

func (p *alefParser) Zargs() (localctx IZargsContext) {
	this := p
	_ = this

	localctx = NewZargsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 6, alefParserRULE_zargs)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(179)
		p.Match(alefParserT__1)
	}
	p.SetState(181)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__3)|(1<<alefParserT__8)|(1<<alefParserT__10))) != 0) || (((_la-56)&-(0x1f+1)) == 0 && ((1<<uint((_la-56)))&((1<<(alefParserBYTE-56))|(1<<(alefParserCHAN-56))|(1<<(alefParserFLOAT-56))|(1<<(alefParserINT-56))|(1<<(alefParserSINT-56))|(1<<(alefParserTUPLE-56))|(1<<(alefParserUINT-56)))) != 0) || (((_la-90)&-(0x1f+1)) == 0 && ((1<<uint((_la-90)))&((1<<(alefParserUSINT-90))|(1<<(alefParserVOID-90))|(1<<(alefParserIDENTIFIER-90)))) != 0) {
		{
			p.SetState(180)
			p.Arglist()
		}

	}
	{
		p.SetState(183)
		p.Match(alefParserT__2)
	}

	return localctx
}

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

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

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

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

func NewEmptyZtnameContext() *ZtnameContext {
	var p = new(ZtnameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_ztname
	return p
}

func (*ZtnameContext) IsZtnameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_ztname

	return p
}

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

func (s *ZtnameContext) Tname() ITnameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITnameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITnameContext)
}

func (s *ZtnameContext) AGGR() antlr.TerminalNode {
	return s.GetToken(alefParserAGGR, 0)
}

func (s *ZtnameContext) ADT() antlr.TerminalNode {
	return s.GetToken(alefParserADT, 0)
}

func (s *ZtnameContext) UNION() antlr.TerminalNode {
	return s.GetToken(alefParserUNION, 0)
}

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

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

func (s *ZtnameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterZtname(s)
	}
}

func (s *ZtnameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitZtname(s)
	}
}

func (p *alefParser) Ztname() (localctx IZtnameContext) {
	this := p
	_ = this

	localctx = NewZtnameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 8, alefParserRULE_ztname)

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

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

	switch p.GetTokenStream().LA(1) {
	case alefParserT__1, alefParserBYTE, alefParserCHAN, alefParserEXTERN, alefParserFLOAT, alefParserINT, alefParserINTERN, alefParserSINT, alefParserTUPLE, alefParserUINT, alefParserUSINT, alefParserVOID, alefParserPRIVATE, alefParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(185)
			p.Tname()
		}

	case alefParserAGGR:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(186)
			p.Match(alefParserAGGR)
		}

	case alefParserADT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(187)
			p.Match(alefParserADT)
		}

	case alefParserUNION:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(188)
			p.Match(alefParserUNION)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAdtfuncContext() *AdtfuncContext {
	var p = new(AdtfuncContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_adtfunc
	return p
}

func (*AdtfuncContext) IsAdtfuncContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_adtfunc

	return p
}

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

func (s *AdtfuncContext) Typename() ITypenameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypenameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *AdtfuncContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *AdtfuncContext) Indsp() IIndspContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndspContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndspContext)
}

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

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

func (s *AdtfuncContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterAdtfunc(s)
	}
}

func (s *AdtfuncContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitAdtfunc(s)
	}
}

func (p *alefParser) Adtfunc() (localctx IAdtfuncContext) {
	this := p
	_ = this

	localctx = NewAdtfuncContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 10, alefParserRULE_adtfunc)

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

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

	switch p.GetTokenStream().LA(1) {
	case alefParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(191)
			p.Typename()
		}
		{
			p.SetState(192)
			p.Match(alefParserT__3)
		}
		{
			p.SetState(193)
			p.Name()
		}

	case alefParserT__10:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(195)
			p.Indsp()
		}
		{
			p.SetState(196)
			p.Typename()
		}
		{
			p.SetState(197)
			p.Match(alefParserT__3)
		}
		{
			p.SetState(198)
			p.Name()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyTypespecContext() *TypespecContext {
	var p = new(TypespecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_typespec
	return p
}

func (*TypespecContext) IsTypespecContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_typespec

	return p
}

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

func (s *TypespecContext) AGGR() antlr.TerminalNode {
	return s.GetToken(alefParserAGGR, 0)
}

func (s *TypespecContext) Memberlist() IMemberlistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMemberlistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMemberlistContext)
}

func (s *TypespecContext) AllZtag() []IZtagContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IZtagContext)(nil)).Elem())
	var tst = make([]IZtagContext, len(ts))

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

	return tst
}

func (s *TypespecContext) Ztag(i int) IZtagContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IZtagContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IZtagContext)
}

func (s *TypespecContext) UNION() antlr.TerminalNode {
	return s.GetToken(alefParserUNION, 0)
}

func (s *TypespecContext) ADT() antlr.TerminalNode {
	return s.GetToken(alefParserADT, 0)
}

func (s *TypespecContext) Zpolytype() IZpolytypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IZpolytypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IZpolytypeContext)
}

func (s *TypespecContext) ENUM() antlr.TerminalNode {
	return s.GetToken(alefParserENUM, 0)
}

func (s *TypespecContext) Setlist() ISetlistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISetlistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISetlistContext)
}

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

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

func (s *TypespecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterTypespec(s)
	}
}

func (s *TypespecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitTypespec(s)
	}
}

func (p *alefParser) Typespec() (localctx ITypespecContext) {
	this := p
	_ = this

	localctx = NewTypespecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 12, alefParserRULE_typespec)
	var _la int

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

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

	switch p.GetTokenStream().LA(1) {
	case alefParserAGGR:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(202)
			p.Match(alefParserAGGR)
		}
		p.SetState(204)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserIDENTIFIER {
			{
				p.SetState(203)
				p.Ztag()
			}

		}
		{
			p.SetState(206)
			p.Match(alefParserT__4)
		}
		{
			p.SetState(207)
			p.memberlist(0)
		}
		{
			p.SetState(208)
			p.Match(alefParserT__5)
		}
		p.SetState(210)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserIDENTIFIER {
			{
				p.SetState(209)
				p.Ztag()
			}

		}

	case alefParserUNION:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(212)
			p.Match(alefParserUNION)
		}
		p.SetState(214)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserIDENTIFIER {
			{
				p.SetState(213)
				p.Ztag()
			}

		}
		{
			p.SetState(216)
			p.Match(alefParserT__4)
		}
		{
			p.SetState(217)
			p.memberlist(0)
		}
		{
			p.SetState(218)
			p.Match(alefParserT__5)
		}
		p.SetState(220)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserIDENTIFIER {
			{
				p.SetState(219)
				p.Ztag()
			}

		}

	case alefParserADT:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(222)
			p.Match(alefParserADT)
		}
		p.SetState(224)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserIDENTIFIER {
			{
				p.SetState(223)
				p.Ztag()
			}

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

		if _la == alefParserT__6 {
			{
				p.SetState(226)
				p.Zpolytype()
			}

		}
		{
			p.SetState(229)
			p.Match(alefParserT__4)
		}
		{
			p.SetState(230)
			p.memberlist(0)
		}
		{
			p.SetState(231)
			p.Match(alefParserT__5)
		}
		p.SetState(233)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserIDENTIFIER {
			{
				p.SetState(232)
				p.Ztag()
			}

		}

	case alefParserENUM:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(235)
			p.Match(alefParserENUM)
		}
		p.SetState(237)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserIDENTIFIER {
			{
				p.SetState(236)
				p.Ztag()
			}

		}
		{
			p.SetState(239)
			p.Match(alefParserT__4)
		}
		{
			p.SetState(240)
			p.setlist(0)
		}
		{
			p.SetState(241)
			p.Match(alefParserT__5)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyZtagContext() *ZtagContext {
	var p = new(ZtagContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_ztag
	return p
}

func (*ZtagContext) IsZtagContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_ztag

	return p
}

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

func (s *ZtagContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *ZtagContext) Typename() ITypenameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypenameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

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

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

func (s *ZtagContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterZtag(s)
	}
}

func (s *ZtagContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitZtag(s)
	}
}

func (p *alefParser) Ztag() (localctx IZtagContext) {
	this := p
	_ = this

	localctx = NewZtagContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 14, alefParserRULE_ztag)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(246)
			p.Typename()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyZpolytypeContext() *ZpolytypeContext {
	var p = new(ZpolytypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_zpolytype
	return p
}

func (*ZpolytypeContext) IsZpolytypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_zpolytype

	return p
}

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

func (s *ZpolytypeContext) Polytype() IPolytypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPolytypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPolytypeContext)
}

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

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

func (s *ZpolytypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterZpolytype(s)
	}
}

func (s *ZpolytypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitZpolytype(s)
	}
}

func (p *alefParser) Zpolytype() (localctx IZpolytypeContext) {
	this := p
	_ = this

	localctx = NewZpolytypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, alefParserRULE_zpolytype)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(249)
		p.Match(alefParserT__6)
	}
	{
		p.SetState(250)
		p.Polytype()
	}
	{
		p.SetState(251)
		p.Match(alefParserT__7)
	}

	return localctx
}

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

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

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

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

func NewEmptyPolytypeContext() *PolytypeContext {
	var p = new(PolytypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_polytype
	return p
}

func (*PolytypeContext) IsPolytypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_polytype

	return p
}

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

func (s *PolytypeContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *PolytypeContext) Polytype() IPolytypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPolytypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPolytypeContext)
}

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

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

func (s *PolytypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterPolytype(s)
	}
}

func (s *PolytypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitPolytype(s)
	}
}

func (p *alefParser) Polytype() (localctx IPolytypeContext) {
	this := p
	_ = this

	localctx = NewPolytypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, alefParserRULE_polytype)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(254)
			p.Name()
		}
		{
			p.SetState(255)
			p.Match(alefParserT__8)
		}
		{
			p.SetState(256)
			p.Polytype()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptySetlistContext() *SetlistContext {
	var p = new(SetlistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_setlist
	return p
}

func (*SetlistContext) IsSetlistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_setlist

	return p
}

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

func (s *SetlistContext) Sname() ISnameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISnameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISnameContext)
}

func (s *SetlistContext) AllSetlist() []ISetlistContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISetlistContext)(nil)).Elem())
	var tst = make([]ISetlistContext, len(ts))

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

	return tst
}

func (s *SetlistContext) Setlist(i int) ISetlistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISetlistContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISetlistContext)
}

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

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

func (s *SetlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterSetlist(s)
	}
}

func (s *SetlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitSetlist(s)
	}
}

func (p *alefParser) Setlist() (localctx ISetlistContext) {
	return p.setlist(0)
}

func (p *alefParser) setlist(_p int) (localctx ISetlistContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewSetlistContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx ISetlistContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 20
	p.EnterRecursionRule(localctx, 20, alefParserRULE_setlist, _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(262)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 22, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(261)
			p.Sname()
		}

	}

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

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

			if !(p.Precpred(p.GetParserRuleContext(), 1)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
			}
			{
				p.SetState(265)
				p.Match(alefParserT__8)
			}
			{
				p.SetState(266)
				p.setlist(2)
			}

		}
		p.SetState(271)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 23, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptySnameContext() *SnameContext {
	var p = new(SnameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_sname
	return p
}

func (*SnameContext) IsSnameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_sname

	return p
}

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

func (s *SnameContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *SnameContext) Expr_() IExpr_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpr_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpr_Context)
}

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

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

func (s *SnameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterSname(s)
	}
}

func (s *SnameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitSname(s)
	}
}

func (p *alefParser) Sname() (localctx ISnameContext) {
	this := p
	_ = this

	localctx = NewSnameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 22, alefParserRULE_sname)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(272)
		p.Name()
	}
	p.SetState(275)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 24, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(273)
			p.Match(alefParserT__9)
		}
		{
			p.SetState(274)
			p.expr_(0)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyNameContext() *NameContext {
	var p = new(NameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_name
	return p
}

func (*NameContext) IsNameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_name

	return p
}

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

func (s *NameContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(alefParserIDENTIFIER, 0)
}

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

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

func (s *NameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterName(s)
	}
}

func (s *NameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitName(s)
	}
}

func (p *alefParser) Name() (localctx INameContext) {
	this := p
	_ = this

	localctx = NewNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, alefParserRULE_name)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(277)
		p.Match(alefParserIDENTIFIER)
	}

	return localctx
}

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

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

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

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

func NewEmptyMemberlistContext() *MemberlistContext {
	var p = new(MemberlistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_memberlist
	return p
}

func (*MemberlistContext) IsMemberlistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_memberlist

	return p
}

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

func (s *MemberlistContext) Decl() IDeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclContext)
}

func (s *MemberlistContext) Memberlist() IMemberlistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMemberlistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMemberlistContext)
}

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

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

func (s *MemberlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterMemberlist(s)
	}
}

func (s *MemberlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitMemberlist(s)
	}
}

func (p *alefParser) Memberlist() (localctx IMemberlistContext) {
	return p.memberlist(0)
}

func (p *alefParser) memberlist(_p int) (localctx IMemberlistContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewMemberlistContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IMemberlistContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 26
	p.EnterRecursionRule(localctx, 26, alefParserRULE_memberlist, _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(280)
		p.Decl()
	}

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

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

			if !(p.Precpred(p.GetParserRuleContext(), 1)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
			}
			{
				p.SetState(283)
				p.Decl()
			}

		}
		p.SetState(288)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 25, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyVardecllistContext() *VardecllistContext {
	var p = new(VardecllistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_vardecllist
	return p
}

func (*VardecllistContext) IsVardecllistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_vardecllist

	return p
}

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

func (s *VardecllistContext) AllIvardecl() []IIvardeclContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIvardeclContext)(nil)).Elem())
	var tst = make([]IIvardeclContext, len(ts))

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

	return tst
}

func (s *VardecllistContext) Ivardecl(i int) IIvardeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIvardeclContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIvardeclContext)
}

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

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

func (s *VardecllistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterVardecllist(s)
	}
}

func (s *VardecllistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitVardecllist(s)
	}
}

func (p *alefParser) Vardecllist() (localctx IVardecllistContext) {
	this := p
	_ = this

	localctx = NewVardecllistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, alefParserRULE_vardecllist)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(289)
		p.Ivardecl()
	}
	p.SetState(294)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == alefParserT__8 {
		{
			p.SetState(290)
			p.Match(alefParserT__8)
		}
		{
			p.SetState(291)
			p.Ivardecl()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyIvardeclContext() *IvardeclContext {
	var p = new(IvardeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_ivardecl
	return p
}

func (*IvardeclContext) IsIvardeclContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_ivardecl

	return p
}

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

func (s *IvardeclContext) Vardecl() IVardeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVardeclContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVardeclContext)
}

func (s *IvardeclContext) Zinit() IZinitContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IZinitContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IZinitContext)
}

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

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

func (s *IvardeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterIvardecl(s)
	}
}

func (s *IvardeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitIvardecl(s)
	}
}

func (p *alefParser) Ivardecl() (localctx IIvardeclContext) {
	this := p
	_ = this

	localctx = NewIvardeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, alefParserRULE_ivardecl)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(297)
		p.Vardecl()
	}
	p.SetState(299)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == alefParserT__9 {
		{
			p.SetState(298)
			p.Zinit()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyZinitContext() *ZinitContext {
	var p = new(ZinitContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_zinit
	return p
}

func (*ZinitContext) IsZinitContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_zinit

	return p
}

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

func (s *ZinitContext) Zelist() IZelistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IZelistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IZelistContext)
}

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

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

func (s *ZinitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterZinit(s)
	}
}

func (s *ZinitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitZinit(s)
	}
}

func (p *alefParser) Zinit() (localctx IZinitContext) {
	this := p
	_ = this

	localctx = NewZinitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, alefParserRULE_zinit)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(301)
		p.Match(alefParserT__9)
	}
	{
		p.SetState(302)
		p.zelist(0)
	}

	return localctx
}

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

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

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

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

func NewEmptyZelistContext() *ZelistContext {
	var p = new(ZelistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_zelist
	return p
}

func (*ZelistContext) IsZelistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_zelist

	return p
}

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

func (s *ZelistContext) Zexpr() IZexprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IZexprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IZexprContext)
}

func (s *ZelistContext) AllExpr_() []IExpr_Context {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpr_Context)(nil)).Elem())
	var tst = make([]IExpr_Context, len(ts))

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

	return tst
}

func (s *ZelistContext) Expr_(i int) IExpr_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpr_Context)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpr_Context)
}

func (s *ZelistContext) Stag() IStagContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStagContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStagContext)
}

func (s *ZelistContext) AllZelist() []IZelistContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IZelistContext)(nil)).Elem())
	var tst = make([]IZelistContext, len(ts))

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

	return tst
}

func (s *ZelistContext) Zelist(i int) IZelistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IZelistContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IZelistContext)
}

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

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

func (s *ZelistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterZelist(s)
	}
}

func (s *ZelistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitZelist(s)
	}
}

func (p *alefParser) Zelist() (localctx IZelistContext) {
	return p.zelist(0)
}

func (p *alefParser) zelist(_p int) (localctx IZelistContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewZelistContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IZelistContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 34
	p.EnterRecursionRule(localctx, 34, alefParserRULE_zelist, _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(328)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 29, p.GetParserRuleContext()) {
	case 1:
		p.SetState(306)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 28, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(305)
				p.Zexpr()
			}

		}

	case 2:
		{
			p.SetState(308)
			p.Match(alefParserT__6)
		}
		{
			p.SetState(309)
			p.expr_(0)
		}
		{
			p.SetState(310)
			p.Match(alefParserT__7)
		}
		{
			p.SetState(311)
			p.expr_(0)
		}

	case 3:
		{
			p.SetState(313)
			p.Match(alefParserT__3)
		}
		{
			p.SetState(314)
			p.Stag()
		}
		{
			p.SetState(315)
			p.expr_(0)
		}

	case 4:
		{
			p.SetState(317)
			p.Match(alefParserT__4)
		}
		{
			p.SetState(318)
			p.zelist(0)
		}
		{
			p.SetState(319)
			p.Match(alefParserT__5)
		}

	case 5:
		{
			p.SetState(321)
			p.Match(alefParserT__6)
		}
		{
			p.SetState(322)
			p.expr_(0)
		}
		{
			p.SetState(323)
			p.Match(alefParserT__7)
		}
		{
			p.SetState(324)
			p.Match(alefParserT__4)
		}
		{
			p.SetState(325)
			p.zelist(0)
		}
		{
			p.SetState(326)
			p.Match(alefParserT__5)
		}

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

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

			if !(p.Precpred(p.GetParserRuleContext(), 1)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
			}
			{
				p.SetState(331)
				p.Match(alefParserT__8)
			}
			{
				p.SetState(332)
				p.zelist(2)
			}

		}
		p.SetState(337)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 30, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyVardeclContext() *VardeclContext {
	var p = new(VardeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_vardecl
	return p
}

func (*VardeclContext) IsVardeclContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_vardecl

	return p
}

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

func (s *VardeclContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(alefParserIDENTIFIER, 0)
}

func (s *VardeclContext) Arrayspec() IArrayspecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayspecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayspecContext)
}

func (s *VardeclContext) AllIndsp() []IIndspContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIndspContext)(nil)).Elem())
	var tst = make([]IIndspContext, len(ts))

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

	return tst
}

func (s *VardeclContext) Indsp(i int) IIndspContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndspContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIndspContext)
}

func (s *VardeclContext) Arglist() IArglistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArglistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArglistContext)
}

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

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

func (s *VardeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterVardecl(s)
	}
}

func (s *VardeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitVardecl(s)
	}
}

func (p *alefParser) Vardecl() (localctx IVardeclContext) {
	this := p
	_ = this

	localctx = NewVardeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, alefParserRULE_vardecl)
	var _la int

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

	defer func() {
		if err := recover(); err != nil {
			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(374)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 37, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(338)
			p.Match(alefParserIDENTIFIER)
		}
		p.SetState(340)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserT__6 {
			{
				p.SetState(339)
				p.Arrayspec()
			}

		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(342)
			p.Indsp()
		}
		{
			p.SetState(343)
			p.Match(alefParserIDENTIFIER)
		}
		p.SetState(345)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserT__6 {
			{
				p.SetState(344)
				p.Arrayspec()
			}

		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(347)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(348)
			p.Indsp()
		}
		{
			p.SetState(349)
			p.Match(alefParserIDENTIFIER)
		}
		p.SetState(351)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserT__6 {
			{
				p.SetState(350)
				p.Arrayspec()
			}

		}
		{
			p.SetState(353)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(354)
			p.Match(alefParserT__1)
		}
		p.SetState(356)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__3)|(1<<alefParserT__8)|(1<<alefParserT__10))) != 0) || (((_la-56)&-(0x1f+1)) == 0 && ((1<<uint((_la-56)))&((1<<(alefParserBYTE-56))|(1<<(alefParserCHAN-56))|(1<<(alefParserFLOAT-56))|(1<<(alefParserINT-56))|(1<<(alefParserSINT-56))|(1<<(alefParserTUPLE-56))|(1<<(alefParserUINT-56)))) != 0) || (((_la-90)&-(0x1f+1)) == 0 && ((1<<uint((_la-90)))&((1<<(alefParserUSINT-90))|(1<<(alefParserVOID-90))|(1<<(alefParserIDENTIFIER-90)))) != 0) {
			{
				p.SetState(355)
				p.Arglist()
			}

		}
		{
			p.SetState(358)
			p.Match(alefParserT__2)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(360)
			p.Indsp()
		}
		{
			p.SetState(361)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(362)
			p.Indsp()
		}
		{
			p.SetState(363)
			p.Match(alefParserIDENTIFIER)
		}
		p.SetState(365)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserT__6 {
			{
				p.SetState(364)
				p.Arrayspec()
			}

		}
		{
			p.SetState(367)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(368)
			p.Match(alefParserT__1)
		}
		p.SetState(370)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__3)|(1<<alefParserT__8)|(1<<alefParserT__10))) != 0) || (((_la-56)&-(0x1f+1)) == 0 && ((1<<uint((_la-56)))&((1<<(alefParserBYTE-56))|(1<<(alefParserCHAN-56))|(1<<(alefParserFLOAT-56))|(1<<(alefParserINT-56))|(1<<(alefParserSINT-56))|(1<<(alefParserTUPLE-56))|(1<<(alefParserUINT-56)))) != 0) || (((_la-90)&-(0x1f+1)) == 0 && ((1<<uint((_la-90)))&((1<<(alefParserUSINT-90))|(1<<(alefParserVOID-90))|(1<<(alefParserIDENTIFIER-90)))) != 0) {
			{
				p.SetState(369)
				p.Arglist()
			}

		}
		{
			p.SetState(372)
			p.Match(alefParserT__2)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyArrayspecContext() *ArrayspecContext {
	var p = new(ArrayspecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_arrayspec
	return p
}

func (*ArrayspecContext) IsArrayspecContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_arrayspec

	return p
}

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

func (s *ArrayspecContext) AllZexpr() []IZexprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IZexprContext)(nil)).Elem())
	var tst = make([]IZexprContext, len(ts))

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

	return tst
}

func (s *ArrayspecContext) Zexpr(i int) IZexprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IZexprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IZexprContext)
}

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

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

func (s *ArrayspecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterArrayspec(s)
	}
}

func (s *ArrayspecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitArrayspec(s)
	}
}

func (p *alefParser) Arrayspec() (localctx IArrayspecContext) {
	this := p
	_ = this

	localctx = NewArrayspecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, alefParserRULE_arrayspec)
	var _la int

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

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

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

	for ok := true; ok; ok = _la == alefParserT__6 {
		{
			p.SetState(376)
			p.Match(alefParserT__6)
		}
		p.SetState(378)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32)))) != 0) || (((_la-73)&-(0x1f+1)) == 0 && ((1<<uint((_la-73)))&((1<<(alefParserNIL-73))|(1<<(alefParserSIZEOF-73))|(1<<(alefParserZEROX-73))|(1<<(alefParserIDENTIFIER-73))|(1<<(alefParserSTRING_CONST-73))|(1<<(alefParserCONSTANT-73))|(1<<(alefParserARITHMETIC_CONST-73)))) != 0) {
			{
				p.SetState(377)
				p.Zexpr()
			}

		}
		{
			p.SetState(380)
			p.Match(alefParserT__7)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyIndspContext() *IndspContext {
	var p = new(IndspContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_indsp
	return p
}

func (*IndspContext) IsIndspContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_indsp

	return p
}

func (s *IndspContext) GetParser() antlr.Parser { return s.parser }
func (s *IndspContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *IndspContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterIndsp(s)
	}
}

func (s *IndspContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitIndsp(s)
	}
}

func (p *alefParser) Indsp() (localctx IIndspContext) {
	this := p
	_ = this

	localctx = NewIndspContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, alefParserRULE_indsp)

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

	defer func() {
		if err := recover(); err != 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(386)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(385)
				p.Match(alefParserT__10)
			}

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

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

	return localctx
}

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

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

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

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

func NewEmptyArglistContext() *ArglistContext {
	var p = new(ArglistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_arglist
	return p
}

func (*ArglistContext) IsArglistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_arglist

	return p
}

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

func (s *ArglistContext) Arg() IArgContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgContext)
}

func (s *ArglistContext) AllArglistp() []IArglistpContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IArglistpContext)(nil)).Elem())
	var tst = make([]IArglistpContext, len(ts))

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

	return tst
}

func (s *ArglistContext) Arglistp(i int) IArglistpContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArglistpContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IArglistpContext)
}

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

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

func (s *ArglistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterArglist(s)
	}
}

func (s *ArglistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitArglist(s)
	}
}

func (p *alefParser) Arglist() (localctx IArglistContext) {
	this := p
	_ = this

	localctx = NewArglistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, alefParserRULE_arglist)
	var _la int

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

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

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

	for _la == alefParserT__3 || _la == alefParserT__10 || (((_la-56)&-(0x1f+1)) == 0 && ((1<<uint((_la-56)))&((1<<(alefParserBYTE-56))|(1<<(alefParserCHAN-56))|(1<<(alefParserFLOAT-56))|(1<<(alefParserINT-56))|(1<<(alefParserSINT-56))|(1<<(alefParserTUPLE-56))|(1<<(alefParserUINT-56)))) != 0) || (((_la-90)&-(0x1f+1)) == 0 && ((1<<uint((_la-90)))&((1<<(alefParserUSINT-90))|(1<<(alefParserVOID-90))|(1<<(alefParserIDENTIFIER-90)))) != 0) {
		{
			p.SetState(390)
			p.Arglistp()
		}

		p.SetState(395)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(396)
		p.Match(alefParserT__8)
	}
	{
		p.SetState(397)
		p.Arg()
	}

	return localctx
}

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

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

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

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

func NewEmptyArglistpContext() *ArglistpContext {
	var p = new(ArglistpContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_arglistp
	return p
}

func (*ArglistpContext) IsArglistpContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_arglistp

	return p
}

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

func (s *ArglistpContext) Arg() IArgContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgContext)
}

func (s *ArglistpContext) Xtname() IXtnameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IXtnameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IXtnameContext)
}

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

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

func (s *ArglistpContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterArglistp(s)
	}
}

func (s *ArglistpContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitArglistp(s)
	}
}

func (p *alefParser) Arglistp() (localctx IArglistpContext) {
	this := p
	_ = this

	localctx = NewArglistpContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, alefParserRULE_arglistp)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(400)
			p.Match(alefParserT__10)
		}
		{
			p.SetState(401)
			p.Xtname()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(402)
			p.Match(alefParserT__3)
		}
		{
			p.SetState(403)
			p.Xtname()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyArgContext() *ArgContext {
	var p = new(ArgContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_arg
	return p
}

func (*ArgContext) IsArgContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_arg

	return p
}

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

func (s *ArgContext) Xtname() IXtnameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IXtnameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IXtnameContext)
}

func (s *ArgContext) AllIndsp() []IIndspContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIndspContext)(nil)).Elem())
	var tst = make([]IIndspContext, len(ts))

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

	return tst
}

func (s *ArgContext) Indsp(i int) IIndspContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndspContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIndspContext)
}

func (s *ArgContext) Arrayspec() IArrayspecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayspecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArrayspecContext)
}

func (s *ArgContext) Arglist() IArglistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArglistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArglistContext)
}

func (s *ArgContext) TUPLE() antlr.TerminalNode {
	return s.GetToken(alefParserTUPLE, 0)
}

func (s *ArgContext) Tuplearg() ITupleargContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITupleargContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITupleargContext)
}

func (s *ArgContext) Vardecl() IVardeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVardeclContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVardeclContext)
}

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

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

func (s *ArgContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterArg(s)
	}
}

func (s *ArgContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitArg(s)
	}
}

func (p *alefParser) Arg() (localctx IArgContext) {
	this := p
	_ = this

	localctx = NewArgContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, alefParserRULE_arg)
	var _la int

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(407)
			p.Xtname()
		}
		{
			p.SetState(408)
			p.Indsp()
		}
		p.SetState(410)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserT__6 {
			{
				p.SetState(409)
				p.Arrayspec()
			}

		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(412)
			p.Xtname()
		}
		{
			p.SetState(413)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(414)
			p.Indsp()
		}
		{
			p.SetState(415)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(416)
			p.Match(alefParserT__1)
		}
		p.SetState(418)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__3)|(1<<alefParserT__8)|(1<<alefParserT__10))) != 0) || (((_la-56)&-(0x1f+1)) == 0 && ((1<<uint((_la-56)))&((1<<(alefParserBYTE-56))|(1<<(alefParserCHAN-56))|(1<<(alefParserFLOAT-56))|(1<<(alefParserINT-56))|(1<<(alefParserSINT-56))|(1<<(alefParserTUPLE-56))|(1<<(alefParserUINT-56)))) != 0) || (((_la-90)&-(0x1f+1)) == 0 && ((1<<uint((_la-90)))&((1<<(alefParserUSINT-90))|(1<<(alefParserVOID-90))|(1<<(alefParserIDENTIFIER-90)))) != 0) {
			{
				p.SetState(417)
				p.Arglist()
			}

		}
		{
			p.SetState(420)
			p.Match(alefParserT__2)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(422)
			p.Xtname()
		}
		{
			p.SetState(423)
			p.Indsp()
		}
		{
			p.SetState(424)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(425)
			p.Indsp()
		}
		{
			p.SetState(426)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(427)
			p.Match(alefParserT__1)
		}
		p.SetState(429)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__3)|(1<<alefParserT__8)|(1<<alefParserT__10))) != 0) || (((_la-56)&-(0x1f+1)) == 0 && ((1<<uint((_la-56)))&((1<<(alefParserBYTE-56))|(1<<(alefParserCHAN-56))|(1<<(alefParserFLOAT-56))|(1<<(alefParserINT-56))|(1<<(alefParserSINT-56))|(1<<(alefParserTUPLE-56))|(1<<(alefParserUINT-56)))) != 0) || (((_la-90)&-(0x1f+1)) == 0 && ((1<<uint((_la-90)))&((1<<(alefParserUSINT-90))|(1<<(alefParserVOID-90))|(1<<(alefParserIDENTIFIER-90)))) != 0) {
			{
				p.SetState(428)
				p.Arglist()
			}

		}
		{
			p.SetState(431)
			p.Match(alefParserT__2)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(433)
			p.Match(alefParserTUPLE)
		}
		{
			p.SetState(434)
			p.Tuplearg()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(435)
			p.Xtname()
		}
		{
			p.SetState(436)
			p.Vardecl()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(438)
			p.Match(alefParserT__3)
		}
		{
			p.SetState(439)
			p.Match(alefParserT__3)
		}
		{
			p.SetState(440)
			p.Match(alefParserT__3)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyTupleargContext() *TupleargContext {
	var p = new(TupleargContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_tuplearg
	return p
}

func (*TupleargContext) IsTupleargContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_tuplearg

	return p
}

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

func (s *TupleargContext) Tname() ITnameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITnameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITnameContext)
}

func (s *TupleargContext) Indsp() IIndspContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndspContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndspContext)
}

func (s *TupleargContext) Arglist() IArglistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArglistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArglistContext)
}

func (s *TupleargContext) Vardecl() IVardeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVardeclContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVardeclContext)
}

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

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

func (s *TupleargContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterTuplearg(s)
	}
}

func (s *TupleargContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitTuplearg(s)
	}
}

func (p *alefParser) Tuplearg() (localctx ITupleargContext) {
	this := p
	_ = this

	localctx = NewTupleargContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, alefParserRULE_tuplearg)
	var _la int

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(444)
			p.Tname()
		}
		{
			p.SetState(445)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(446)
			p.Indsp()
		}
		{
			p.SetState(447)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(448)
			p.Match(alefParserT__1)
		}
		p.SetState(450)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__3)|(1<<alefParserT__8)|(1<<alefParserT__10))) != 0) || (((_la-56)&-(0x1f+1)) == 0 && ((1<<uint((_la-56)))&((1<<(alefParserBYTE-56))|(1<<(alefParserCHAN-56))|(1<<(alefParserFLOAT-56))|(1<<(alefParserINT-56))|(1<<(alefParserSINT-56))|(1<<(alefParserTUPLE-56))|(1<<(alefParserUINT-56)))) != 0) || (((_la-90)&-(0x1f+1)) == 0 && ((1<<uint((_la-90)))&((1<<(alefParserUSINT-90))|(1<<(alefParserVOID-90))|(1<<(alefParserIDENTIFIER-90)))) != 0) {
			{
				p.SetState(449)
				p.Arglist()
			}

		}
		{
			p.SetState(452)
			p.Match(alefParserT__2)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(454)
			p.Tname()
		}
		{
			p.SetState(455)
			p.Vardecl()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyAutolistContext() *AutolistContext {
	var p = new(AutolistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_autolist
	return p
}

func (*AutolistContext) IsAutolistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_autolist

	return p
}

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

func (s *AutolistContext) AllAutodecl() []IAutodeclContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAutodeclContext)(nil)).Elem())
	var tst = make([]IAutodeclContext, len(ts))

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

	return tst
}

func (s *AutolistContext) Autodecl(i int) IAutodeclContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAutodeclContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAutodeclContext)
}

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

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

func (s *AutolistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterAutolist(s)
	}
}

func (s *AutolistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitAutolist(s)
	}
}

func (p *alefParser) Autolist() (localctx IAutolistContext) {
	this := p
	_ = this

	localctx = NewAutolistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 50, alefParserRULE_autolist)

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

	defer func() {
		if err := recover(); err != 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(460)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(459)
				p.Autodecl()
			}

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

		p.SetState(462)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 49, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyAutodeclContext() *AutodeclContext {
	var p = new(AutodeclContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_autodecl
	return p
}

func (*AutodeclContext) IsAutodeclContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_autodecl

	return p
}

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

func (s *AutodeclContext) Xtname() IXtnameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IXtnameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IXtnameContext)
}

func (s *AutodeclContext) Vardecllist() IVardecllistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVardecllistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVardecllistContext)
}

func (s *AutodeclContext) TUPLE() antlr.TerminalNode {
	return s.GetToken(alefParserTUPLE, 0)
}

func (s *AutodeclContext) Tname() ITnameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITnameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITnameContext)
}

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

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

func (s *AutodeclContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterAutodecl(s)
	}
}

func (s *AutodeclContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitAutodecl(s)
	}
}

func (p *alefParser) Autodecl() (localctx IAutodeclContext) {
	this := p
	_ = this

	localctx = NewAutodeclContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, alefParserRULE_autodecl)
	var _la int

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

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

	switch p.GetTokenStream().LA(1) {
	case alefParserBYTE, alefParserCHAN, alefParserFLOAT, alefParserINT, alefParserSINT, alefParserUINT, alefParserUSINT, alefParserVOID, alefParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(464)
			p.Xtname()
		}
		p.SetState(466)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserT__1 || _la == alefParserT__10 || _la == alefParserIDENTIFIER {
			{
				p.SetState(465)
				p.Vardecllist()
			}

		}
		{
			p.SetState(468)
			p.Match(alefParserT__0)
		}

	case alefParserTUPLE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(470)
			p.Match(alefParserTUPLE)
		}
		{
			p.SetState(471)
			p.Tname()
		}
		p.SetState(473)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserT__1 || _la == alefParserT__10 || _la == alefParserIDENTIFIER {
			{
				p.SetState(472)
				p.Vardecllist()
			}

		}
		{
			p.SetState(475)
			p.Match(alefParserT__0)
		}

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

	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 = alefParserRULE_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 = alefParserRULE_block

	return p
}

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

func (s *BlockContext) Autolist() IAutolistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAutolistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAutolistContext)
}

func (s *BlockContext) Slist() ISlistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISlistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISlistContext)
}

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

func (s *BlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitBlock(s)
	}
}

func (p *alefParser) Block() (localctx IBlockContext) {
	this := p
	_ = this

	localctx = NewBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 54, alefParserRULE_block)
	var _la int

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

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

	p.SetState(496)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case alefParserT__4:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(479)
			p.Match(alefParserT__4)
		}
		p.SetState(481)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 53, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(480)
				p.Autolist()
			}

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

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__0)|(1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__4)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32))|(1<<(alefParserALLOC-32))|(1<<(alefParserALT-32))|(1<<(alefParserBECOME-32))|(1<<(alefParserBREAK-32))|(1<<(alefParserCHECK-32))|(1<<(alefParserCONTINUE-32))|(1<<(alefParserDO-32)))) != 0) || (((_la-67)&-(0x1f+1)) == 0 && ((1<<uint((_la-67)))&((1<<(alefParserFOR-67))|(1<<(alefParserGOTO-67))|(1<<(alefParserIF-67))|(1<<(alefParserNIL-67))|(1<<(alefParserPAR-67))|(1<<(alefParserPROC-67))|(1<<(alefParserRAISE-67))|(1<<(alefParserRESCUE-67))|(1<<(alefParserRETURN-67))|(1<<(alefParserSIZEOF-67))|(1<<(alefParserSWITCH-67))|(1<<(alefParserTASK-67))|(1<<(alefParserTYPEOF-67))|(1<<(alefParserUNALLOC-67))|(1<<(alefParserWHILE-67))|(1<<(alefParserZEROX-67))|(1<<(alefParserIDENTIFIER-67))|(1<<(alefParserSTRING_CONST-67))|(1<<(alefParserCONSTANT-67))|(1<<(alefParserARITHMETIC_CONST-67)))) != 0) {
			{
				p.SetState(483)
				p.Slist()
			}

		}
		{
			p.SetState(486)
			p.Match(alefParserT__5)
		}

	case alefParserT__11:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(487)
			p.Match(alefParserT__11)
		}
		{
			p.SetState(488)
			p.Match(alefParserT__4)
		}
		p.SetState(490)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 55, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(489)
				p.Autolist()
			}

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

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__0)|(1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__4)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32))|(1<<(alefParserALLOC-32))|(1<<(alefParserALT-32))|(1<<(alefParserBECOME-32))|(1<<(alefParserBREAK-32))|(1<<(alefParserCHECK-32))|(1<<(alefParserCONTINUE-32))|(1<<(alefParserDO-32)))) != 0) || (((_la-67)&-(0x1f+1)) == 0 && ((1<<uint((_la-67)))&((1<<(alefParserFOR-67))|(1<<(alefParserGOTO-67))|(1<<(alefParserIF-67))|(1<<(alefParserNIL-67))|(1<<(alefParserPAR-67))|(1<<(alefParserPROC-67))|(1<<(alefParserRAISE-67))|(1<<(alefParserRESCUE-67))|(1<<(alefParserRETURN-67))|(1<<(alefParserSIZEOF-67))|(1<<(alefParserSWITCH-67))|(1<<(alefParserTASK-67))|(1<<(alefParserTYPEOF-67))|(1<<(alefParserUNALLOC-67))|(1<<(alefParserWHILE-67))|(1<<(alefParserZEROX-67))|(1<<(alefParserIDENTIFIER-67))|(1<<(alefParserSTRING_CONST-67))|(1<<(alefParserCONSTANT-67))|(1<<(alefParserARITHMETIC_CONST-67)))) != 0) {
			{
				p.SetState(492)
				p.Slist()
			}

		}
		{
			p.SetState(495)
			p.Match(alefParserT__5)
		}

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

	return localctx
}

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

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

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

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

func NewEmptySlistContext() *SlistContext {
	var p = new(SlistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_slist
	return p
}

func (*SlistContext) IsSlistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_slist

	return p
}

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

func (s *SlistContext) AllStmnt() []IStmntContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IStmntContext)(nil)).Elem())
	var tst = make([]IStmntContext, len(ts))

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

	return tst
}

func (s *SlistContext) Stmnt(i int) IStmntContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStmntContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IStmntContext)
}

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

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

func (s *SlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterSlist(s)
	}
}

func (s *SlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitSlist(s)
	}
}

func (p *alefParser) Slist() (localctx ISlistContext) {
	this := p
	_ = this

	localctx = NewSlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, alefParserRULE_slist)
	var _la int

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

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

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

	for ok := true; ok; ok = (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__0)|(1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__4)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32))|(1<<(alefParserALLOC-32))|(1<<(alefParserALT-32))|(1<<(alefParserBECOME-32))|(1<<(alefParserBREAK-32))|(1<<(alefParserCHECK-32))|(1<<(alefParserCONTINUE-32))|(1<<(alefParserDO-32)))) != 0) || (((_la-67)&-(0x1f+1)) == 0 && ((1<<uint((_la-67)))&((1<<(alefParserFOR-67))|(1<<(alefParserGOTO-67))|(1<<(alefParserIF-67))|(1<<(alefParserNIL-67))|(1<<(alefParserPAR-67))|(1<<(alefParserPROC-67))|(1<<(alefParserRAISE-67))|(1<<(alefParserRESCUE-67))|(1<<(alefParserRETURN-67))|(1<<(alefParserSIZEOF-67))|(1<<(alefParserSWITCH-67))|(1<<(alefParserTASK-67))|(1<<(alefParserTYPEOF-67))|(1<<(alefParserUNALLOC-67))|(1<<(alefParserWHILE-67))|(1<<(alefParserZEROX-67))|(1<<(alefParserIDENTIFIER-67))|(1<<(alefParserSTRING_CONST-67))|(1<<(alefParserCONSTANT-67))|(1<<(alefParserARITHMETIC_CONST-67)))) != 0) {
		{
			p.SetState(498)
			p.Stmnt()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyTbodyContext() *TbodyContext {
	var p = new(TbodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_tbody
	return p
}

func (*TbodyContext) IsTbodyContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_tbody

	return p
}

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

func (s *TbodyContext) Ctlist() ICtlistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICtlistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICtlistContext)
}

func (s *TbodyContext) Clist() IClistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClistContext)
}

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

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

func (s *TbodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterTbody(s)
	}
}

func (s *TbodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitTbody(s)
	}
}

func (p *alefParser) Tbody() (localctx ITbodyContext) {
	this := p
	_ = this

	localctx = NewTbodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, alefParserRULE_tbody)
	var _la int

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

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

	switch p.GetTokenStream().LA(1) {
	case alefParserT__4:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(503)
			p.Match(alefParserT__4)
		}
		p.SetState(505)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserCASE || _la == alefParserDEFAULT {
			{
				p.SetState(504)
				p.Ctlist()
			}

		}
		{
			p.SetState(507)
			p.Match(alefParserT__5)
		}

	case alefParserT__11:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(508)
			p.Match(alefParserT__11)
		}
		{
			p.SetState(509)
			p.Match(alefParserT__4)
		}
		p.SetState(511)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserCASE || _la == alefParserDEFAULT {
			{
				p.SetState(510)
				p.Clist()
			}

		}
		{
			p.SetState(513)
			p.Match(alefParserT__5)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyCtlistContext() *CtlistContext {
	var p = new(CtlistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_ctlist
	return p
}

func (*CtlistContext) IsCtlistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_ctlist

	return p
}

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

func (s *CtlistContext) AllTcase() []ITcaseContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITcaseContext)(nil)).Elem())
	var tst = make([]ITcaseContext, len(ts))

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

	return tst
}

func (s *CtlistContext) Tcase(i int) ITcaseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITcaseContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITcaseContext)
}

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

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

func (s *CtlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterCtlist(s)
	}
}

func (s *CtlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitCtlist(s)
	}
}

func (p *alefParser) Ctlist() (localctx ICtlistContext) {
	this := p
	_ = this

	localctx = NewCtlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 60, alefParserRULE_ctlist)
	var _la int

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

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

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

	for ok := true; ok; ok = _la == alefParserCASE || _la == alefParserDEFAULT {
		{
			p.SetState(516)
			p.Tcase()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyTcaseContext() *TcaseContext {
	var p = new(TcaseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_tcase
	return p
}

func (*TcaseContext) IsTcaseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_tcase

	return p
}

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

func (s *TcaseContext) CASE() antlr.TerminalNode {
	return s.GetToken(alefParserCASE, 0)
}

func (s *TcaseContext) Typecast() ITypecastContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypecastContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypecastContext)
}

func (s *TcaseContext) Slist() ISlistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISlistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISlistContext)
}

func (s *TcaseContext) DEFAULT() antlr.TerminalNode {
	return s.GetToken(alefParserDEFAULT, 0)
}

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

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

func (s *TcaseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterTcase(s)
	}
}

func (s *TcaseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitTcase(s)
	}
}

func (p *alefParser) Tcase() (localctx ITcaseContext) {
	this := p
	_ = this

	localctx = NewTcaseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 62, alefParserRULE_tcase)
	var _la int

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

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

	switch p.GetTokenStream().LA(1) {
	case alefParserCASE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(521)
			p.Match(alefParserCASE)
		}
		{
			p.SetState(522)
			p.Typecast()
		}
		{
			p.SetState(523)
			p.Match(alefParserT__12)
		}
		p.SetState(525)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__0)|(1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__4)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32))|(1<<(alefParserALLOC-32))|(1<<(alefParserALT-32))|(1<<(alefParserBECOME-32))|(1<<(alefParserBREAK-32))|(1<<(alefParserCHECK-32))|(1<<(alefParserCONTINUE-32))|(1<<(alefParserDO-32)))) != 0) || (((_la-67)&-(0x1f+1)) == 0 && ((1<<uint((_la-67)))&((1<<(alefParserFOR-67))|(1<<(alefParserGOTO-67))|(1<<(alefParserIF-67))|(1<<(alefParserNIL-67))|(1<<(alefParserPAR-67))|(1<<(alefParserPROC-67))|(1<<(alefParserRAISE-67))|(1<<(alefParserRESCUE-67))|(1<<(alefParserRETURN-67))|(1<<(alefParserSIZEOF-67))|(1<<(alefParserSWITCH-67))|(1<<(alefParserTASK-67))|(1<<(alefParserTYPEOF-67))|(1<<(alefParserUNALLOC-67))|(1<<(alefParserWHILE-67))|(1<<(alefParserZEROX-67))|(1<<(alefParserIDENTIFIER-67))|(1<<(alefParserSTRING_CONST-67))|(1<<(alefParserCONSTANT-67))|(1<<(alefParserARITHMETIC_CONST-67)))) != 0) {
			{
				p.SetState(524)
				p.Slist()
			}

		}

	case alefParserDEFAULT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(527)
			p.Match(alefParserDEFAULT)
		}
		{
			p.SetState(528)
			p.Match(alefParserT__12)
		}
		p.SetState(530)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__0)|(1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__4)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32))|(1<<(alefParserALLOC-32))|(1<<(alefParserALT-32))|(1<<(alefParserBECOME-32))|(1<<(alefParserBREAK-32))|(1<<(alefParserCHECK-32))|(1<<(alefParserCONTINUE-32))|(1<<(alefParserDO-32)))) != 0) || (((_la-67)&-(0x1f+1)) == 0 && ((1<<uint((_la-67)))&((1<<(alefParserFOR-67))|(1<<(alefParserGOTO-67))|(1<<(alefParserIF-67))|(1<<(alefParserNIL-67))|(1<<(alefParserPAR-67))|(1<<(alefParserPROC-67))|(1<<(alefParserRAISE-67))|(1<<(alefParserRESCUE-67))|(1<<(alefParserRETURN-67))|(1<<(alefParserSIZEOF-67))|(1<<(alefParserSWITCH-67))|(1<<(alefParserTASK-67))|(1<<(alefParserTYPEOF-67))|(1<<(alefParserUNALLOC-67))|(1<<(alefParserWHILE-67))|(1<<(alefParserZEROX-67))|(1<<(alefParserIDENTIFIER-67))|(1<<(alefParserSTRING_CONST-67))|(1<<(alefParserCONSTANT-67))|(1<<(alefParserARITHMETIC_CONST-67)))) != 0) {
			{
				p.SetState(529)
				p.Slist()
			}

		}

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

	return localctx
}

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

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

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

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

func NewEmptyCbodyContext() *CbodyContext {
	var p = new(CbodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_cbody
	return p
}

func (*CbodyContext) IsCbodyContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_cbody

	return p
}

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

func (s *CbodyContext) Clist() IClistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClistContext)
}

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

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

func (s *CbodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterCbody(s)
	}
}

func (s *CbodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitCbody(s)
	}
}

func (p *alefParser) Cbody() (localctx ICbodyContext) {
	this := p
	_ = this

	localctx = NewCbodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 64, alefParserRULE_cbody)
	var _la int

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

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

	switch p.GetTokenStream().LA(1) {
	case alefParserT__4:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(534)
			p.Match(alefParserT__4)
		}
		p.SetState(536)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserCASE || _la == alefParserDEFAULT {
			{
				p.SetState(535)
				p.Clist()
			}

		}
		{
			p.SetState(538)
			p.Match(alefParserT__5)
		}

	case alefParserT__11:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(539)
			p.Match(alefParserT__11)
		}
		{
			p.SetState(540)
			p.Match(alefParserT__4)
		}
		p.SetState(542)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserCASE || _la == alefParserDEFAULT {
			{
				p.SetState(541)
				p.Clist()
			}

		}
		{
			p.SetState(544)
			p.Match(alefParserT__5)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyClistContext() *ClistContext {
	var p = new(ClistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_clist
	return p
}

func (*ClistContext) IsClistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_clist

	return p
}

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

func (s *ClistContext) AllCase_() []ICase_Context {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICase_Context)(nil)).Elem())
	var tst = make([]ICase_Context, len(ts))

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

	return tst
}

func (s *ClistContext) Case_(i int) ICase_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICase_Context)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICase_Context)
}

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

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

func (s *ClistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterClist(s)
	}
}

func (s *ClistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitClist(s)
	}
}

func (p *alefParser) Clist() (localctx IClistContext) {
	this := p
	_ = this

	localctx = NewClistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, alefParserRULE_clist)
	var _la int

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

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

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

	for ok := true; ok; ok = _la == alefParserCASE || _la == alefParserDEFAULT {
		{
			p.SetState(547)
			p.Case_()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyCase_Context() *Case_Context {
	var p = new(Case_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_case_
	return p
}

func (*Case_Context) IsCase_Context() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_case_

	return p
}

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

func (s *Case_Context) CASE() antlr.TerminalNode {
	return s.GetToken(alefParserCASE, 0)
}

func (s *Case_Context) Expr_() IExpr_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpr_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpr_Context)
}

func (s *Case_Context) Slist() ISlistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISlistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISlistContext)
}

func (s *Case_Context) DEFAULT() antlr.TerminalNode {
	return s.GetToken(alefParserDEFAULT, 0)
}

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

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

func (s *Case_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterCase_(s)
	}
}

func (s *Case_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitCase_(s)
	}
}

func (p *alefParser) Case_() (localctx ICase_Context) {
	this := p
	_ = this

	localctx = NewCase_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, alefParserRULE_case_)
	var _la int

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

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

	switch p.GetTokenStream().LA(1) {
	case alefParserCASE:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(552)
			p.Match(alefParserCASE)
		}
		{
			p.SetState(553)
			p.expr_(0)
		}
		{
			p.SetState(554)
			p.Match(alefParserT__12)
		}
		p.SetState(556)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__0)|(1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__4)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32))|(1<<(alefParserALLOC-32))|(1<<(alefParserALT-32))|(1<<(alefParserBECOME-32))|(1<<(alefParserBREAK-32))|(1<<(alefParserCHECK-32))|(1<<(alefParserCONTINUE-32))|(1<<(alefParserDO-32)))) != 0) || (((_la-67)&-(0x1f+1)) == 0 && ((1<<uint((_la-67)))&((1<<(alefParserFOR-67))|(1<<(alefParserGOTO-67))|(1<<(alefParserIF-67))|(1<<(alefParserNIL-67))|(1<<(alefParserPAR-67))|(1<<(alefParserPROC-67))|(1<<(alefParserRAISE-67))|(1<<(alefParserRESCUE-67))|(1<<(alefParserRETURN-67))|(1<<(alefParserSIZEOF-67))|(1<<(alefParserSWITCH-67))|(1<<(alefParserTASK-67))|(1<<(alefParserTYPEOF-67))|(1<<(alefParserUNALLOC-67))|(1<<(alefParserWHILE-67))|(1<<(alefParserZEROX-67))|(1<<(alefParserIDENTIFIER-67))|(1<<(alefParserSTRING_CONST-67))|(1<<(alefParserCONSTANT-67))|(1<<(alefParserARITHMETIC_CONST-67)))) != 0) {
			{
				p.SetState(555)
				p.Slist()
			}

		}

	case alefParserDEFAULT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(558)
			p.Match(alefParserDEFAULT)
		}
		{
			p.SetState(559)
			p.Match(alefParserT__12)
		}
		p.SetState(561)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__0)|(1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__4)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32))|(1<<(alefParserALLOC-32))|(1<<(alefParserALT-32))|(1<<(alefParserBECOME-32))|(1<<(alefParserBREAK-32))|(1<<(alefParserCHECK-32))|(1<<(alefParserCONTINUE-32))|(1<<(alefParserDO-32)))) != 0) || (((_la-67)&-(0x1f+1)) == 0 && ((1<<uint((_la-67)))&((1<<(alefParserFOR-67))|(1<<(alefParserGOTO-67))|(1<<(alefParserIF-67))|(1<<(alefParserNIL-67))|(1<<(alefParserPAR-67))|(1<<(alefParserPROC-67))|(1<<(alefParserRAISE-67))|(1<<(alefParserRESCUE-67))|(1<<(alefParserRETURN-67))|(1<<(alefParserSIZEOF-67))|(1<<(alefParserSWITCH-67))|(1<<(alefParserTASK-67))|(1<<(alefParserTYPEOF-67))|(1<<(alefParserUNALLOC-67))|(1<<(alefParserWHILE-67))|(1<<(alefParserZEROX-67))|(1<<(alefParserIDENTIFIER-67))|(1<<(alefParserSTRING_CONST-67))|(1<<(alefParserCONSTANT-67))|(1<<(alefParserARITHMETIC_CONST-67)))) != 0) {
			{
				p.SetState(560)
				p.Slist()
			}

		}

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

	return localctx
}

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

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

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

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

func NewEmptyRbodyContext() *RbodyContext {
	var p = new(RbodyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_rbody
	return p
}

func (*RbodyContext) IsRbodyContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_rbody

	return p
}

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

func (s *RbodyContext) Stmnt() IStmntContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStmntContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStmntContext)
}

func (s *RbodyContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(alefParserIDENTIFIER, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

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

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

func (s *RbodyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterRbody(s)
	}
}

func (s *RbodyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitRbody(s)
	}
}

func (p *alefParser) Rbody() (localctx IRbodyContext) {
	this := p
	_ = this

	localctx = NewRbodyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, alefParserRULE_rbody)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(566)
			p.Match(alefParserIDENTIFIER)
		}
		{
			p.SetState(567)
			p.Block()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyZlabContext() *ZlabContext {
	var p = new(ZlabContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_zlab
	return p
}

func (*ZlabContext) IsZlabContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_zlab

	return p
}

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

func (s *ZlabContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(alefParserIDENTIFIER, 0)
}

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

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

func (s *ZlabContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterZlab(s)
	}
}

func (s *ZlabContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitZlab(s)
	}
}

func (p *alefParser) Zlab() (localctx IZlabContext) {
	this := p
	_ = this

	localctx = NewZlabContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, alefParserRULE_zlab)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(570)
		p.Match(alefParserIDENTIFIER)
	}

	return localctx
}

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

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

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

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

func NewEmptyStmntContext() *StmntContext {
	var p = new(StmntContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_stmnt
	return p
}

func (*StmntContext) IsStmntContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_stmnt

	return p
}

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

func (s *StmntContext) Nlstmnt() INlstmntContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INlstmntContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INlstmntContext)
}

func (s *StmntContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(alefParserIDENTIFIER, 0)
}

func (s *StmntContext) Stmnt() IStmntContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStmntContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStmntContext)
}

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

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

func (s *StmntContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterStmnt(s)
	}
}

func (s *StmntContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitStmnt(s)
	}
}

func (p *alefParser) Stmnt() (localctx IStmntContext) {
	this := p
	_ = this

	localctx = NewStmntContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, alefParserRULE_stmnt)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(573)
			p.Match(alefParserIDENTIFIER)
		}
		{
			p.SetState(574)
			p.Match(alefParserT__12)
		}
		{
			p.SetState(575)
			p.Stmnt()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyInfoContext() *InfoContext {
	var p = new(InfoContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_info
	return p
}

func (*InfoContext) IsInfoContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_info

	return p
}

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

func (s *InfoContext) STRING_CONST() antlr.TerminalNode {
	return s.GetToken(alefParserSTRING_CONST, 0)
}

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

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

func (s *InfoContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterInfo(s)
	}
}

func (s *InfoContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitInfo(s)
	}
}

func (p *alefParser) Info() (localctx IInfoContext) {
	this := p
	_ = this

	localctx = NewInfoContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 76, alefParserRULE_info)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(578)
		p.Match(alefParserT__8)
	}
	{
		p.SetState(579)
		p.Match(alefParserSTRING_CONST)
	}

	return localctx
}

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

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

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

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

func NewEmptyNlstmntContext() *NlstmntContext {
	var p = new(NlstmntContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_nlstmnt
	return p
}

func (*NlstmntContext) IsNlstmntContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_nlstmnt

	return p
}

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

func (s *NlstmntContext) AllZexpr() []IZexprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IZexprContext)(nil)).Elem())
	var tst = make([]IZexprContext, len(ts))

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

	return tst
}

func (s *NlstmntContext) Zexpr(i int) IZexprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IZexprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IZexprContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IBlockContext)
}

func (s *NlstmntContext) CHECK() antlr.TerminalNode {
	return s.GetToken(alefParserCHECK, 0)
}

func (s *NlstmntContext) Expr_() IExpr_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpr_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpr_Context)
}

func (s *NlstmntContext) Info() IInfoContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInfoContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInfoContext)
}

func (s *NlstmntContext) ALLOC() antlr.TerminalNode {
	return s.GetToken(alefParserALLOC, 0)
}

func (s *NlstmntContext) Elist() IElistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElistContext)
}

func (s *NlstmntContext) UNALLOC() antlr.TerminalNode {
	return s.GetToken(alefParserUNALLOC, 0)
}

func (s *NlstmntContext) RESCUE() antlr.TerminalNode {
	return s.GetToken(alefParserRESCUE, 0)
}

func (s *NlstmntContext) Rbody() IRbodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRbodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRbodyContext)
}

func (s *NlstmntContext) RAISE() antlr.TerminalNode {
	return s.GetToken(alefParserRAISE, 0)
}

func (s *NlstmntContext) Zlab() IZlabContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IZlabContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IZlabContext)
}

func (s *NlstmntContext) GOTO() antlr.TerminalNode {
	return s.GetToken(alefParserGOTO, 0)
}

func (s *NlstmntContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(alefParserIDENTIFIER, 0)
}

func (s *NlstmntContext) PROC() antlr.TerminalNode {
	return s.GetToken(alefParserPROC, 0)
}

func (s *NlstmntContext) TASK() antlr.TerminalNode {
	return s.GetToken(alefParserTASK, 0)
}

func (s *NlstmntContext) BECOME() antlr.TerminalNode {
	return s.GetToken(alefParserBECOME, 0)
}

func (s *NlstmntContext) ALT() antlr.TerminalNode {
	return s.GetToken(alefParserALT, 0)
}

func (s *NlstmntContext) Cbody() ICbodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICbodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICbodyContext)
}

func (s *NlstmntContext) RETURN() antlr.TerminalNode {
	return s.GetToken(alefParserRETURN, 0)
}

func (s *NlstmntContext) FOR() antlr.TerminalNode {
	return s.GetToken(alefParserFOR, 0)
}

func (s *NlstmntContext) AllStmnt() []IStmntContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IStmntContext)(nil)).Elem())
	var tst = make([]IStmntContext, len(ts))

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

	return tst
}

func (s *NlstmntContext) Stmnt(i int) IStmntContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStmntContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IStmntContext)
}

func (s *NlstmntContext) WHILE() antlr.TerminalNode {
	return s.GetToken(alefParserWHILE, 0)
}

func (s *NlstmntContext) DO() antlr.TerminalNode {
	return s.GetToken(alefParserDO, 0)
}

func (s *NlstmntContext) IF() antlr.TerminalNode {
	return s.GetToken(alefParserIF, 0)
}

func (s *NlstmntContext) ELSE() antlr.TerminalNode {
	return s.GetToken(alefParserELSE, 0)
}

func (s *NlstmntContext) PAR() antlr.TerminalNode {
	return s.GetToken(alefParserPAR, 0)
}

func (s *NlstmntContext) SWITCH() antlr.TerminalNode {
	return s.GetToken(alefParserSWITCH, 0)
}

func (s *NlstmntContext) TYPEOF() antlr.TerminalNode {
	return s.GetToken(alefParserTYPEOF, 0)
}

func (s *NlstmntContext) Tbody() ITbodyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITbodyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITbodyContext)
}

func (s *NlstmntContext) CONTINUE() antlr.TerminalNode {
	return s.GetToken(alefParserCONTINUE, 0)
}

func (s *NlstmntContext) Zconst() IZconstContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IZconstContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IZconstContext)
}

func (s *NlstmntContext) BREAK() antlr.TerminalNode {
	return s.GetToken(alefParserBREAK, 0)
}

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

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

func (s *NlstmntContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterNlstmnt(s)
	}
}

func (s *NlstmntContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitNlstmnt(s)
	}
}

func (p *alefParser) Nlstmnt() (localctx INlstmntContext) {
	this := p
	_ = this

	localctx = NewNlstmntContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, alefParserRULE_nlstmnt)
	var _la int

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

	defer func() {
		if err := recover(); err != nil {
			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(692)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 84, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(582)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32)))) != 0) || (((_la-73)&-(0x1f+1)) == 0 && ((1<<uint((_la-73)))&((1<<(alefParserNIL-73))|(1<<(alefParserSIZEOF-73))|(1<<(alefParserZEROX-73))|(1<<(alefParserIDENTIFIER-73))|(1<<(alefParserSTRING_CONST-73))|(1<<(alefParserCONSTANT-73))|(1<<(alefParserARITHMETIC_CONST-73)))) != 0) {
			{
				p.SetState(581)
				p.Zexpr()
			}

		}
		{
			p.SetState(584)
			p.Match(alefParserT__0)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(585)
			p.Block()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(586)
			p.Match(alefParserCHECK)
		}
		{
			p.SetState(587)
			p.expr_(0)
		}
		p.SetState(589)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserT__8 {
			{
				p.SetState(588)
				p.Info()
			}

		}
		{
			p.SetState(591)
			p.Match(alefParserT__0)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(593)
			p.Match(alefParserALLOC)
		}
		{
			p.SetState(594)
			p.elist(0)
		}
		{
			p.SetState(595)
			p.Match(alefParserT__0)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(597)
			p.Match(alefParserUNALLOC)
		}
		{
			p.SetState(598)
			p.elist(0)
		}
		{
			p.SetState(599)
			p.Match(alefParserT__0)
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(601)
			p.Match(alefParserRESCUE)
		}
		{
			p.SetState(602)
			p.Rbody()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(603)
			p.Match(alefParserRAISE)
		}
		p.SetState(605)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserIDENTIFIER {
			{
				p.SetState(604)
				p.Zlab()
			}

		}
		{
			p.SetState(607)
			p.Match(alefParserT__0)
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(608)
			p.Match(alefParserGOTO)
		}
		{
			p.SetState(609)
			p.Match(alefParserIDENTIFIER)
		}
		{
			p.SetState(610)
			p.Match(alefParserT__0)
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(611)
			p.Match(alefParserPROC)
		}
		{
			p.SetState(612)
			p.elist(0)
		}
		{
			p.SetState(613)
			p.Match(alefParserT__0)
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(615)
			p.Match(alefParserTASK)
		}
		{
			p.SetState(616)
			p.elist(0)
		}
		{
			p.SetState(617)
			p.Match(alefParserT__0)
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(619)
			p.Match(alefParserBECOME)
		}
		{
			p.SetState(620)
			p.expr_(0)
		}
		{
			p.SetState(621)
			p.Match(alefParserT__0)
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(623)
			p.Match(alefParserALT)
		}
		{
			p.SetState(624)
			p.Cbody()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(625)
			p.Match(alefParserRETURN)
		}
		p.SetState(627)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32)))) != 0) || (((_la-73)&-(0x1f+1)) == 0 && ((1<<uint((_la-73)))&((1<<(alefParserNIL-73))|(1<<(alefParserSIZEOF-73))|(1<<(alefParserZEROX-73))|(1<<(alefParserIDENTIFIER-73))|(1<<(alefParserSTRING_CONST-73))|(1<<(alefParserCONSTANT-73))|(1<<(alefParserARITHMETIC_CONST-73)))) != 0) {
			{
				p.SetState(626)
				p.Zexpr()
			}

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

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(630)
			p.Match(alefParserFOR)
		}
		{
			p.SetState(631)
			p.Match(alefParserT__1)
		}
		p.SetState(633)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32)))) != 0) || (((_la-73)&-(0x1f+1)) == 0 && ((1<<uint((_la-73)))&((1<<(alefParserNIL-73))|(1<<(alefParserSIZEOF-73))|(1<<(alefParserZEROX-73))|(1<<(alefParserIDENTIFIER-73))|(1<<(alefParserSTRING_CONST-73))|(1<<(alefParserCONSTANT-73))|(1<<(alefParserARITHMETIC_CONST-73)))) != 0) {
			{
				p.SetState(632)
				p.Zexpr()
			}

		}
		{
			p.SetState(635)
			p.Match(alefParserT__0)
		}
		p.SetState(637)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32)))) != 0) || (((_la-73)&-(0x1f+1)) == 0 && ((1<<uint((_la-73)))&((1<<(alefParserNIL-73))|(1<<(alefParserSIZEOF-73))|(1<<(alefParserZEROX-73))|(1<<(alefParserIDENTIFIER-73))|(1<<(alefParserSTRING_CONST-73))|(1<<(alefParserCONSTANT-73))|(1<<(alefParserARITHMETIC_CONST-73)))) != 0) {
			{
				p.SetState(636)
				p.Zexpr()
			}

		}
		{
			p.SetState(639)
			p.Match(alefParserT__0)
		}
		p.SetState(641)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32)))) != 0) || (((_la-73)&-(0x1f+1)) == 0 && ((1<<uint((_la-73)))&((1<<(alefParserNIL-73))|(1<<(alefParserSIZEOF-73))|(1<<(alefParserZEROX-73))|(1<<(alefParserIDENTIFIER-73))|(1<<(alefParserSTRING_CONST-73))|(1<<(alefParserCONSTANT-73))|(1<<(alefParserARITHMETIC_CONST-73)))) != 0) {
			{
				p.SetState(640)
				p.Zexpr()
			}

		}
		{
			p.SetState(643)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(644)
			p.Stmnt()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(645)
			p.Match(alefParserWHILE)
		}
		{
			p.SetState(646)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(647)
			p.expr_(0)
		}
		{
			p.SetState(648)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(649)
			p.Stmnt()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(651)
			p.Match(alefParserDO)
		}
		{
			p.SetState(652)
			p.Stmnt()
		}
		{
			p.SetState(653)
			p.Match(alefParserWHILE)
		}
		{
			p.SetState(654)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(655)
			p.expr_(0)
		}
		{
			p.SetState(656)
			p.Match(alefParserT__2)
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(658)
			p.Match(alefParserIF)
		}
		{
			p.SetState(659)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(660)
			p.expr_(0)
		}
		{
			p.SetState(661)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(662)
			p.Stmnt()
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(664)
			p.Match(alefParserIF)
		}
		{
			p.SetState(665)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(666)
			p.expr_(0)
		}
		{
			p.SetState(667)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(668)
			p.Stmnt()
		}
		{
			p.SetState(669)
			p.Match(alefParserELSE)
		}
		{
			p.SetState(670)
			p.Stmnt()
		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(672)
			p.Match(alefParserPAR)
		}
		{
			p.SetState(673)
			p.Block()
		}

	case 20:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(674)
			p.Match(alefParserSWITCH)
		}
		{
			p.SetState(675)
			p.expr_(0)
		}
		{
			p.SetState(676)
			p.Cbody()
		}

	case 21:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(678)
			p.Match(alefParserTYPEOF)
		}
		{
			p.SetState(679)
			p.expr_(0)
		}
		{
			p.SetState(680)
			p.Tbody()
		}

	case 22:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(682)
			p.Match(alefParserCONTINUE)
		}
		p.SetState(684)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserCONSTANT {
			{
				p.SetState(683)
				p.Zconst()
			}

		}
		{
			p.SetState(686)
			p.Match(alefParserT__0)
		}

	case 23:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(687)
			p.Match(alefParserBREAK)
		}
		p.SetState(689)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserCONSTANT {
			{
				p.SetState(688)
				p.Zconst()
			}

		}
		{
			p.SetState(691)
			p.Match(alefParserT__0)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyZconstContext() *ZconstContext {
	var p = new(ZconstContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_zconst
	return p
}

func (*ZconstContext) IsZconstContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_zconst

	return p
}

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

func (s *ZconstContext) CONSTANT() antlr.TerminalNode {
	return s.GetToken(alefParserCONSTANT, 0)
}

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

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

func (s *ZconstContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterZconst(s)
	}
}

func (s *ZconstContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitZconst(s)
	}
}

func (p *alefParser) Zconst() (localctx IZconstContext) {
	this := p
	_ = this

	localctx = NewZconstContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, alefParserRULE_zconst)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(694)
		p.Match(alefParserCONSTANT)
	}

	return localctx
}

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

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

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

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

func NewEmptyZexprContext() *ZexprContext {
	var p = new(ZexprContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_zexpr
	return p
}

func (*ZexprContext) IsZexprContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_zexpr

	return p
}

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

func (s *ZexprContext) Expr_() IExpr_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpr_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpr_Context)
}

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

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

func (s *ZexprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterZexpr(s)
	}
}

func (s *ZexprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitZexpr(s)
	}
}

func (p *alefParser) Zexpr() (localctx IZexprContext) {
	this := p
	_ = this

	localctx = NewZexprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, alefParserRULE_zexpr)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(696)
		p.expr_(0)
	}

	return localctx
}

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

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

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

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

func NewEmptyExpr_Context() *Expr_Context {
	var p = new(Expr_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_expr_
	return p
}

func (*Expr_Context) IsExpr_Context() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_expr_

	return p
}

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

func (s *Expr_Context) Castexpr() ICastexprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICastexprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICastexprContext)
}

func (s *Expr_Context) AllExpr_() []IExpr_Context {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpr_Context)(nil)).Elem())
	var tst = make([]IExpr_Context, len(ts))

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

	return tst
}

func (s *Expr_Context) Expr_(i int) IExpr_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpr_Context)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpr_Context)
}

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

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

func (s *Expr_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterExpr_(s)
	}
}

func (s *Expr_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitExpr_(s)
	}
}

func (p *alefParser) Expr_() (localctx IExpr_Context) {
	return p.expr_(0)
}

func (p *alefParser) expr_(_p int) (localctx IExpr_Context) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewExpr_Context(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IExpr_Context = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 84
	p.EnterRecursionRule(localctx, 84, alefParserRULE_expr_, _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(699)
		p.Castexpr()
	}

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

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(798)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 85, p.GetParserRuleContext()) {
			case 1:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(701)

				if !(p.Precpred(p.GetParserRuleContext(), 32)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 32)", ""))
				}
				{
					p.SetState(702)
					p.Match(alefParserT__10)
				}
				{
					p.SetState(703)
					p.expr_(33)
				}

			case 2:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(704)

				if !(p.Precpred(p.GetParserRuleContext(), 31)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 31)", ""))
				}
				{
					p.SetState(705)
					p.Match(alefParserT__13)
				}
				{
					p.SetState(706)
					p.expr_(32)
				}

			case 3:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(707)

				if !(p.Precpred(p.GetParserRuleContext(), 30)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 30)", ""))
				}
				{
					p.SetState(708)
					p.Match(alefParserT__14)
				}
				{
					p.SetState(709)
					p.expr_(31)
				}

			case 4:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(710)

				if !(p.Precpred(p.GetParserRuleContext(), 29)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 29)", ""))
				}
				{
					p.SetState(711)
					p.Match(alefParserT__15)
				}
				{
					p.SetState(712)
					p.expr_(30)
				}

			case 5:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(713)

				if !(p.Precpred(p.GetParserRuleContext(), 28)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 28)", ""))
				}
				{
					p.SetState(714)
					p.Match(alefParserT__16)
				}
				{
					p.SetState(715)
					p.expr_(29)
				}

			case 6:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(716)

				if !(p.Precpred(p.GetParserRuleContext(), 27)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 27)", ""))
				}
				{
					p.SetState(717)
					p.Match(alefParserT__17)
				}
				{
					p.SetState(718)
					p.expr_(28)
				}

			case 7:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(719)

				if !(p.Precpred(p.GetParserRuleContext(), 26)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 26)", ""))
				}
				{
					p.SetState(720)
					p.Match(alefParserT__18)
				}
				{
					p.SetState(721)
					p.expr_(27)
				}

			case 8:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(722)

				if !(p.Precpred(p.GetParserRuleContext(), 25)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 25)", ""))
				}
				{
					p.SetState(723)
					p.Match(alefParserT__19)
				}
				{
					p.SetState(724)
					p.expr_(26)
				}

			case 9:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(725)

				if !(p.Precpred(p.GetParserRuleContext(), 24)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 24)", ""))
				}
				{
					p.SetState(726)
					p.Match(alefParserT__20)
				}
				{
					p.SetState(727)
					p.expr_(25)
				}

			case 10:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(728)

				if !(p.Precpred(p.GetParserRuleContext(), 23)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 23)", ""))
				}
				{
					p.SetState(729)
					p.Match(alefParserT__21)
				}
				{
					p.SetState(730)
					p.expr_(24)
				}

			case 11:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(731)

				if !(p.Precpred(p.GetParserRuleContext(), 22)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 22)", ""))
				}
				{
					p.SetState(732)
					p.Match(alefParserT__22)
				}
				{
					p.SetState(733)
					p.expr_(23)
				}

			case 12:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(734)

				if !(p.Precpred(p.GetParserRuleContext(), 21)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 21)", ""))
				}
				{
					p.SetState(735)
					p.Match(alefParserT__23)
				}
				{
					p.SetState(736)
					p.expr_(22)
				}

			case 13:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(737)

				if !(p.Precpred(p.GetParserRuleContext(), 20)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 20)", ""))
				}
				{
					p.SetState(738)
					p.Match(alefParserT__24)
				}
				{
					p.SetState(739)
					p.expr_(21)
				}

			case 14:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(740)

				if !(p.Precpred(p.GetParserRuleContext(), 19)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 19)", ""))
				}
				{
					p.SetState(741)
					p.Match(alefParserT__25)
				}
				{
					p.SetState(742)
					p.expr_(20)
				}

			case 15:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(743)

				if !(p.Precpred(p.GetParserRuleContext(), 18)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 18)", ""))
				}
				{
					p.SetState(744)
					p.Match(alefParserT__26)
				}
				{
					p.SetState(745)
					p.expr_(19)
				}

			case 16:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(746)

				if !(p.Precpred(p.GetParserRuleContext(), 17)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 17)", ""))
				}
				{
					p.SetState(747)
					p.Match(alefParserT__27)
				}
				{
					p.SetState(748)
					p.expr_(18)
				}

			case 17:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(749)

				if !(p.Precpred(p.GetParserRuleContext(), 16)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 16)", ""))
				}
				{
					p.SetState(750)
					p.Match(alefParserT__28)
				}
				{
					p.SetState(751)
					p.expr_(17)
				}

			case 18:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(752)

				if !(p.Precpred(p.GetParserRuleContext(), 15)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 15)", ""))
				}
				{
					p.SetState(753)
					p.Match(alefParserT__29)
				}
				{
					p.SetState(754)
					p.expr_(16)
				}

			case 19:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(755)

				if !(p.Precpred(p.GetParserRuleContext(), 14)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", ""))
				}
				{
					p.SetState(756)
					p.Match(alefParserT__9)
				}
				{
					p.SetState(757)
					p.expr_(15)
				}

			case 20:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(758)

				if !(p.Precpred(p.GetParserRuleContext(), 13)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 13)", ""))
				}
				{
					p.SetState(759)
					p.Match(alefParserT__30)
				}
				{
					p.SetState(760)
					p.expr_(14)
				}

			case 21:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(761)

				if !(p.Precpred(p.GetParserRuleContext(), 12)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 12)", ""))
				}
				{
					p.SetState(762)
					p.Match(alefParserT__31)
				}
				{
					p.SetState(763)
					p.Match(alefParserT__9)
				}
				{
					p.SetState(764)
					p.expr_(13)
				}

			case 22:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(765)

				if !(p.Precpred(p.GetParserRuleContext(), 11)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 11)", ""))
				}
				{
					p.SetState(766)
					p.Match(alefParserT__32)
				}
				{
					p.SetState(767)
					p.expr_(12)
				}

			case 23:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(768)

				if !(p.Precpred(p.GetParserRuleContext(), 10)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", ""))
				}
				{
					p.SetState(769)
					p.Match(alefParserT__33)
				}
				{
					p.SetState(770)
					p.expr_(11)
				}

			case 24:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(771)

				if !(p.Precpred(p.GetParserRuleContext(), 9)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", ""))
				}
				{
					p.SetState(772)
					p.Match(alefParserT__34)
				}
				{
					p.SetState(773)
					p.expr_(10)
				}

			case 25:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(774)

				if !(p.Precpred(p.GetParserRuleContext(), 8)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", ""))
				}
				{
					p.SetState(775)
					p.Match(alefParserT__35)
				}
				{
					p.SetState(776)
					p.expr_(9)
				}

			case 26:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(777)

				if !(p.Precpred(p.GetParserRuleContext(), 7)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", ""))
				}
				{
					p.SetState(778)
					p.Match(alefParserT__36)
				}
				{
					p.SetState(779)
					p.expr_(8)
				}

			case 27:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(780)

				if !(p.Precpred(p.GetParserRuleContext(), 6)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", ""))
				}
				{
					p.SetState(781)
					p.Match(alefParserT__37)
				}
				{
					p.SetState(782)
					p.expr_(7)
				}

			case 28:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(783)

				if !(p.Precpred(p.GetParserRuleContext(), 5)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
				}
				{
					p.SetState(784)
					p.Match(alefParserT__38)
				}
				{
					p.SetState(785)
					p.expr_(6)
				}

			case 29:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(786)

				if !(p.Precpred(p.GetParserRuleContext(), 4)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
				}
				{
					p.SetState(787)
					p.Match(alefParserT__39)
				}
				{
					p.SetState(788)
					p.expr_(5)
				}

			case 30:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(789)

				if !(p.Precpred(p.GetParserRuleContext(), 3)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
				}
				{
					p.SetState(790)
					p.Match(alefParserT__40)
				}
				{
					p.SetState(791)
					p.expr_(4)
				}

			case 31:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(792)

				if !(p.Precpred(p.GetParserRuleContext(), 2)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
				}
				{
					p.SetState(793)
					p.Match(alefParserT__41)
				}
				{
					p.SetState(794)
					p.expr_(3)
				}

			case 32:
				localctx = NewExpr_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_expr_)
				p.SetState(795)

				if !(p.Precpred(p.GetParserRuleContext(), 1)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
				}
				{
					p.SetState(796)
					p.Match(alefParserT__42)
				}
				{
					p.SetState(797)
					p.expr_(2)
				}

			}

		}
		p.SetState(802)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 86, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyCastexprContext() *CastexprContext {
	var p = new(CastexprContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_castexpr
	return p
}

func (*CastexprContext) IsCastexprContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_castexpr

	return p
}

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

func (s *CastexprContext) Monexpr() IMonexprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMonexprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMonexprContext)
}

func (s *CastexprContext) Typecast() ITypecastContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypecastContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypecastContext)
}

func (s *CastexprContext) Castexpr() ICastexprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICastexprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICastexprContext)
}

func (s *CastexprContext) ALLOC() antlr.TerminalNode {
	return s.GetToken(alefParserALLOC, 0)
}

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

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

func (s *CastexprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterCastexpr(s)
	}
}

func (s *CastexprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitCastexpr(s)
	}
}

func (p *alefParser) Castexpr() (localctx ICastexprContext) {
	this := p
	_ = this

	localctx = NewCastexprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, alefParserRULE_castexpr)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(804)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(805)
			p.Typecast()
		}
		{
			p.SetState(806)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(807)
			p.Castexpr()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(809)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(810)
			p.Match(alefParserALLOC)
		}
		{
			p.SetState(811)
			p.Typecast()
		}
		{
			p.SetState(812)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(813)
			p.Castexpr()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyTypecastContext() *TypecastContext {
	var p = new(TypecastContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_typecast
	return p
}

func (*TypecastContext) IsTypecastContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_typecast

	return p
}

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

func (s *TypecastContext) Xtname() IXtnameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IXtnameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IXtnameContext)
}

func (s *TypecastContext) Indsp() IIndspContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndspContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndspContext)
}

func (s *TypecastContext) Arglist() IArglistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArglistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArglistContext)
}

func (s *TypecastContext) TUPLE() antlr.TerminalNode {
	return s.GetToken(alefParserTUPLE, 0)
}

func (s *TypecastContext) Tname() ITnameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITnameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITnameContext)
}

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

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

func (s *TypecastContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterTypecast(s)
	}
}

func (s *TypecastContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitTypecast(s)
	}
}

func (p *alefParser) Typecast() (localctx ITypecastContext) {
	this := p
	_ = this

	localctx = NewTypecastContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, alefParserRULE_typecast)
	var _la int

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(818)
			p.Xtname()
		}
		{
			p.SetState(819)
			p.Indsp()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(821)
			p.Xtname()
		}
		{
			p.SetState(822)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(823)
			p.Indsp()
		}
		{
			p.SetState(824)
			p.Match(alefParserT__2)
		}
		{
			p.SetState(825)
			p.Match(alefParserT__1)
		}
		p.SetState(827)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__3)|(1<<alefParserT__8)|(1<<alefParserT__10))) != 0) || (((_la-56)&-(0x1f+1)) == 0 && ((1<<uint((_la-56)))&((1<<(alefParserBYTE-56))|(1<<(alefParserCHAN-56))|(1<<(alefParserFLOAT-56))|(1<<(alefParserINT-56))|(1<<(alefParserSINT-56))|(1<<(alefParserTUPLE-56))|(1<<(alefParserUINT-56)))) != 0) || (((_la-90)&-(0x1f+1)) == 0 && ((1<<uint((_la-90)))&((1<<(alefParserUSINT-90))|(1<<(alefParserVOID-90))|(1<<(alefParserIDENTIFIER-90)))) != 0) {
			{
				p.SetState(826)
				p.Arglist()
			}

		}
		{
			p.SetState(829)
			p.Match(alefParserT__2)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(831)
			p.Match(alefParserTUPLE)
		}
		{
			p.SetState(832)
			p.Tname()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyMonexprContext() *MonexprContext {
	var p = new(MonexprContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_monexpr
	return p
}

func (*MonexprContext) IsMonexprContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_monexpr

	return p
}

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

func (s *MonexprContext) Term_() ITerm_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITerm_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITerm_Context)
}

func (s *MonexprContext) Castexpr() ICastexprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICastexprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICastexprContext)
}

func (s *MonexprContext) ZEROX() antlr.TerminalNode {
	return s.GetToken(alefParserZEROX, 0)
}

func (s *MonexprContext) SIZEOF() antlr.TerminalNode {
	return s.GetToken(alefParserSIZEOF, 0)
}

func (s *MonexprContext) Monexpr() IMonexprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMonexprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMonexprContext)
}

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

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

func (s *MonexprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterMonexpr(s)
	}
}

func (s *MonexprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitMonexpr(s)
	}
}

func (p *alefParser) Monexpr() (localctx IMonexprContext) {
	this := p
	_ = this

	localctx = NewMonexprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, alefParserRULE_monexpr)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(836)
			p.Match(alefParserT__10)
		}
		{
			p.SetState(837)
			p.Castexpr()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(838)
			p.Match(alefParserT__25)
		}
		{
			p.SetState(839)
			p.Castexpr()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(840)
			p.Match(alefParserT__15)
		}
		{
			p.SetState(841)
			p.Castexpr()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(842)
			p.Match(alefParserT__16)
		}
		{
			p.SetState(843)
			p.Castexpr()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(844)
			p.Match(alefParserT__43)
		}
		{
			p.SetState(845)
			p.Castexpr()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(846)
			p.Match(alefParserZEROX)
		}
		{
			p.SetState(847)
			p.Castexpr()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(848)
			p.Match(alefParserT__44)
		}
		{
			p.SetState(849)
			p.Castexpr()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(850)
			p.Match(alefParserT__11)
		}
		{
			p.SetState(851)
			p.Castexpr()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(852)
			p.Match(alefParserT__45)
		}
		{
			p.SetState(853)
			p.Castexpr()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(854)
			p.Match(alefParserSIZEOF)
		}
		{
			p.SetState(855)
			p.Monexpr()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(856)
			p.Match(alefParserT__31)
		}
		{
			p.SetState(857)
			p.Castexpr()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(858)
			p.Match(alefParserT__46)
		}
		{
			p.SetState(859)
			p.Castexpr()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyZtelistContext() *ZtelistContext {
	var p = new(ZtelistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_ztelist
	return p
}

func (*ZtelistContext) IsZtelistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_ztelist

	return p
}

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

func (s *ZtelistContext) Telist() ITelistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITelistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITelistContext)
}

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

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

func (s *ZtelistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterZtelist(s)
	}
}

func (s *ZtelistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitZtelist(s)
	}
}

func (p *alefParser) Ztelist() (localctx IZtelistContext) {
	this := p
	_ = this

	localctx = NewZtelistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, alefParserRULE_ztelist)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(862)
		p.Telist()
	}

	return localctx
}

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

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

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

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

func NewEmptyTelistContext() *TelistContext {
	var p = new(TelistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_telist
	return p
}

func (*TelistContext) IsTelistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_telist

	return p
}

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

func (s *TelistContext) AllTcomp() []ITcompContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITcompContext)(nil)).Elem())
	var tst = make([]ITcompContext, len(ts))

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

	return tst
}

func (s *TelistContext) Tcomp(i int) ITcompContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITcompContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITcompContext)
}

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

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

func (s *TelistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterTelist(s)
	}
}

func (s *TelistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitTelist(s)
	}
}

func (p *alefParser) Telist() (localctx ITelistContext) {
	this := p
	_ = this

	localctx = NewTelistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, alefParserRULE_telist)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(864)
		p.Tcomp()
	}
	p.SetState(869)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == alefParserT__8 {
		{
			p.SetState(865)
			p.Match(alefParserT__8)
		}
		{
			p.SetState(866)
			p.Tcomp()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyTcompContext() *TcompContext {
	var p = new(TcompContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_tcomp
	return p
}

func (*TcompContext) IsTcompContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_tcomp

	return p
}

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

func (s *TcompContext) Expr_() IExpr_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpr_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpr_Context)
}

func (s *TcompContext) Ztelist() IZtelistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IZtelistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IZtelistContext)
}

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

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

func (s *TcompContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterTcomp(s)
	}
}

func (s *TcompContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitTcomp(s)
	}
}

func (p *alefParser) Tcomp() (localctx ITcompContext) {
	this := p
	_ = this

	localctx = NewTcompContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 96, alefParserRULE_tcomp)
	var _la int

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

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

	switch p.GetTokenStream().LA(1) {
	case alefParserT__1, alefParserT__3, alefParserT__10, alefParserT__11, alefParserT__15, alefParserT__16, alefParserT__25, alefParserT__31, alefParserT__43, alefParserT__44, alefParserT__45, alefParserT__46, alefParserT__48, alefParserNIL, alefParserSIZEOF, alefParserZEROX, alefParserIDENTIFIER, alefParserSTRING_CONST, alefParserCONSTANT, alefParserARITHMETIC_CONST:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(872)
			p.expr_(0)
		}

	case alefParserT__4:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(873)
			p.Match(alefParserT__4)
		}
		p.SetState(875)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__4)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32)))) != 0) || (((_la-73)&-(0x1f+1)) == 0 && ((1<<uint((_la-73)))&((1<<(alefParserNIL-73))|(1<<(alefParserSIZEOF-73))|(1<<(alefParserZEROX-73))|(1<<(alefParserIDENTIFIER-73))|(1<<(alefParserSTRING_CONST-73))|(1<<(alefParserCONSTANT-73))|(1<<(alefParserARITHMETIC_CONST-73)))) != 0) {
			{
				p.SetState(874)
				p.Ztelist()
			}

		}
		{
			p.SetState(877)
			p.Match(alefParserT__5)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyTerm_Context() *Term_Context {
	var p = new(Term_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_term_
	return p
}

func (*Term_Context) IsTerm_Context() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_term_

	return p
}

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

func (s *Term_Context) Telist() ITelistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITelistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITelistContext)
}

func (s *Term_Context) SIZEOF() antlr.TerminalNode {
	return s.GetToken(alefParserSIZEOF, 0)
}

func (s *Term_Context) Typecast() ITypecastContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypecastContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypecastContext)
}

func (s *Term_Context) Typename() ITypenameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypenameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *Term_Context) Stag() IStagContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStagContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStagContext)
}

func (s *Term_Context) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Term_Context) ARITHMETIC_CONST() antlr.TerminalNode {
	return s.GetToken(alefParserARITHMETIC_CONST, 0)
}

func (s *Term_Context) NIL() antlr.TerminalNode {
	return s.GetToken(alefParserNIL, 0)
}

func (s *Term_Context) CONSTANT() antlr.TerminalNode {
	return s.GetToken(alefParserCONSTANT, 0)
}

func (s *Term_Context) Enum_member() IEnum_memberContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnum_memberContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnum_memberContext)
}

func (s *Term_Context) STRING_CONST() antlr.TerminalNode {
	return s.GetToken(alefParserSTRING_CONST, 0)
}

func (s *Term_Context) Term_() ITerm_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITerm_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITerm_Context)
}

func (s *Term_Context) Zarlist() IZarlistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IZarlistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IZarlistContext)
}

func (s *Term_Context) Expr_() IExpr_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpr_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpr_Context)
}

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

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

func (s *Term_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterTerm_(s)
	}
}

func (s *Term_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitTerm_(s)
	}
}

func (p *alefParser) Term_() (localctx ITerm_Context) {
	return p.term_(0)
}

func (p *alefParser) term_(_p int) (localctx ITerm_Context) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewTerm_Context(p, p.GetParserRuleContext(), _parentState)
	var _prevctx ITerm_Context = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 98
	p.EnterRecursionRule(localctx, 98, alefParserRULE_term_, _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(906)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 94, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(881)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(882)
			p.Telist()
		}
		{
			p.SetState(883)
			p.Match(alefParserT__2)
		}

	case 2:
		{
			p.SetState(885)
			p.Match(alefParserSIZEOF)
		}
		{
			p.SetState(886)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(887)
			p.Typecast()
		}
		{
			p.SetState(888)
			p.Match(alefParserT__2)
		}

	case 3:
		{
			p.SetState(890)
			p.Match(alefParserT__3)
		}
		{
			p.SetState(891)
			p.Typename()
		}
		{
			p.SetState(892)
			p.Match(alefParserT__3)
		}
		{
			p.SetState(893)
			p.Stag()
		}

	case 4:
		{
			p.SetState(895)
			p.Name()
		}

	case 5:
		{
			p.SetState(896)
			p.Match(alefParserT__3)
		}
		{
			p.SetState(897)
			p.Match(alefParserT__3)
		}
		{
			p.SetState(898)
			p.Match(alefParserT__3)
		}

	case 6:
		{
			p.SetState(899)
			p.Match(alefParserARITHMETIC_CONST)
		}

	case 7:
		{
			p.SetState(900)
			p.Match(alefParserNIL)
		}

	case 8:
		{
			p.SetState(901)
			p.Match(alefParserCONSTANT)
		}

	case 9:
		{
			p.SetState(902)
			p.Enum_member()
		}

	case 10:
		{
			p.SetState(903)
			p.Match(alefParserSTRING_CONST)
		}

	case 11:
		{
			p.SetState(904)
			p.Match(alefParserT__48)
		}
		{
			p.SetState(905)
			p.Match(alefParserSTRING_CONST)
		}

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

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(931)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 96, p.GetParserRuleContext()) {
			case 1:
				localctx = NewTerm_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_term_)
				p.SetState(908)

				if !(p.Precpred(p.GetParserRuleContext(), 16)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 16)", ""))
				}
				{
					p.SetState(909)
					p.Match(alefParserT__1)
				}
				p.SetState(911)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<alefParserT__1)|(1<<alefParserT__3)|(1<<alefParserT__10)|(1<<alefParserT__11)|(1<<alefParserT__15)|(1<<alefParserT__16)|(1<<alefParserT__25))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(alefParserT__31-32))|(1<<(alefParserT__43-32))|(1<<(alefParserT__44-32))|(1<<(alefParserT__45-32))|(1<<(alefParserT__46-32))|(1<<(alefParserT__48-32)))) != 0) || (((_la-73)&-(0x1f+1)) == 0 && ((1<<uint((_la-73)))&((1<<(alefParserNIL-73))|(1<<(alefParserSIZEOF-73))|(1<<(alefParserZEROX-73))|(1<<(alefParserIDENTIFIER-73))|(1<<(alefParserSTRING_CONST-73))|(1<<(alefParserCONSTANT-73))|(1<<(alefParserARITHMETIC_CONST-73)))) != 0) {
					{
						p.SetState(910)
						p.Zarlist()
					}

				}
				{
					p.SetState(913)
					p.Match(alefParserT__2)
				}

			case 2:
				localctx = NewTerm_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_term_)
				p.SetState(914)

				if !(p.Precpred(p.GetParserRuleContext(), 15)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 15)", ""))
				}
				{
					p.SetState(915)
					p.Match(alefParserT__6)
				}
				{
					p.SetState(916)
					p.expr_(0)
				}
				{
					p.SetState(917)
					p.Match(alefParserT__7)
				}

			case 3:
				localctx = NewTerm_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_term_)
				p.SetState(919)

				if !(p.Precpred(p.GetParserRuleContext(), 14)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", ""))
				}
				{
					p.SetState(920)
					p.Match(alefParserT__3)
				}
				{
					p.SetState(921)
					p.Stag()
				}

			case 4:
				localctx = NewTerm_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_term_)
				p.SetState(922)

				if !(p.Precpred(p.GetParserRuleContext(), 12)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 12)", ""))
				}
				{
					p.SetState(923)
					p.Match(alefParserT__47)
				}
				{
					p.SetState(924)
					p.Stag()
				}

			case 5:
				localctx = NewTerm_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_term_)
				p.SetState(925)

				if !(p.Precpred(p.GetParserRuleContext(), 11)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 11)", ""))
				}
				{
					p.SetState(926)
					p.Match(alefParserT__43)
				}

			case 6:
				localctx = NewTerm_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_term_)
				p.SetState(927)

				if !(p.Precpred(p.GetParserRuleContext(), 10)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", ""))
				}
				{
					p.SetState(928)
					p.Match(alefParserT__44)
				}

			case 7:
				localctx = NewTerm_Context(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, alefParserRULE_term_)
				p.SetState(929)

				if !(p.Precpred(p.GetParserRuleContext(), 9)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", ""))
				}
				{
					p.SetState(930)
					p.Match(alefParserT__46)
				}

			}

		}
		p.SetState(935)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 97, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyStagContext() *StagContext {
	var p = new(StagContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_stag
	return p
}

func (*StagContext) IsStagContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_stag

	return p
}

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

func (s *StagContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(alefParserIDENTIFIER, 0)
}

func (s *StagContext) Typename() ITypenameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypenameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

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

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

func (s *StagContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterStag(s)
	}
}

func (s *StagContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitStag(s)
	}
}

func (p *alefParser) Stag() (localctx IStagContext) {
	this := p
	_ = this

	localctx = NewStagContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, alefParserRULE_stag)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(937)
			p.Typename()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyZarlistContext() *ZarlistContext {
	var p = new(ZarlistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_zarlist
	return p
}

func (*ZarlistContext) IsZarlistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_zarlist

	return p
}

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

func (s *ZarlistContext) Elist() IElistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElistContext)
}

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

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

func (s *ZarlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterZarlist(s)
	}
}

func (s *ZarlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitZarlist(s)
	}
}

func (p *alefParser) Zarlist() (localctx IZarlistContext) {
	this := p
	_ = this

	localctx = NewZarlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, alefParserRULE_zarlist)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(940)
		p.elist(0)
	}

	return localctx
}

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

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

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

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

func NewEmptyElistContext() *ElistContext {
	var p = new(ElistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_elist
	return p
}

func (*ElistContext) IsElistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_elist

	return p
}

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

func (s *ElistContext) Expr_() IExpr_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpr_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpr_Context)
}

func (s *ElistContext) Elist() IElistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IElistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IElistContext)
}

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

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

func (s *ElistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterElist(s)
	}
}

func (s *ElistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitElist(s)
	}
}

func (p *alefParser) Elist() (localctx IElistContext) {
	return p.elist(0)
}

func (p *alefParser) elist(_p int) (localctx IElistContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewElistContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IElistContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 104
	p.EnterRecursionRule(localctx, 104, alefParserRULE_elist, _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(943)
		p.expr_(0)
	}

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

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

			if !(p.Precpred(p.GetParserRuleContext(), 1)) {
				panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
			}
			{
				p.SetState(946)
				p.Match(alefParserT__8)
			}
			{
				p.SetState(947)
				p.expr_(0)
			}

		}
		p.SetState(952)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 99, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyTlistContext() *TlistContext {
	var p = new(TlistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_tlist
	return p
}

func (*TlistContext) IsTlistContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_tlist

	return p
}

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

func (s *TlistContext) Typecast() ITypecastContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypecastContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypecastContext)
}

func (s *TlistContext) Tlist() ITlistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITlistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITlistContext)
}

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

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

func (s *TlistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterTlist(s)
	}
}

func (s *TlistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitTlist(s)
	}
}

func (p *alefParser) Tlist() (localctx ITlistContext) {
	this := p
	_ = this

	localctx = NewTlistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, alefParserRULE_tlist)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(954)
			p.Typecast()
		}
		{
			p.SetState(955)
			p.Match(alefParserT__8)
		}
		{
			p.SetState(956)
			p.Tlist()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyTnameContext() *TnameContext {
	var p = new(TnameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_tname
	return p
}

func (*TnameContext) IsTnameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_tname

	return p
}

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

func (s *TnameContext) Xtname() IXtnameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IXtnameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IXtnameContext)
}

func (s *TnameContext) Sclass() ISclassContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISclassContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISclassContext)
}

func (s *TnameContext) TUPLE() antlr.TerminalNode {
	return s.GetToken(alefParserTUPLE, 0)
}

func (s *TnameContext) Tlist() ITlistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITlistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITlistContext)
}

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

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

func (s *TnameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterTname(s)
	}
}

func (s *TnameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitTname(s)
	}
}

func (p *alefParser) Tname() (localctx ITnameContext) {
	this := p
	_ = this

	localctx = NewTnameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, alefParserRULE_tname)
	var _la int

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

	defer func() {
		if err := recover(); err != nil {
			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(979)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 104, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(961)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if ((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(alefParserEXTERN-65))|(1<<(alefParserINTERN-65))|(1<<(alefParserPRIVATE-65)))) != 0 {
			{
				p.SetState(960)
				p.Sclass()
			}

		}
		{
			p.SetState(963)
			p.Xtname()
		}

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

		if ((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(alefParserEXTERN-65))|(1<<(alefParserINTERN-65))|(1<<(alefParserPRIVATE-65)))) != 0 {
			{
				p.SetState(964)
				p.Sclass()
			}

		}
		{
			p.SetState(967)
			p.Match(alefParserTUPLE)
		}
		{
			p.SetState(968)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(969)
			p.Tlist()
		}
		{
			p.SetState(970)
			p.Match(alefParserT__2)
		}

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

		if ((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(alefParserEXTERN-65))|(1<<(alefParserINTERN-65))|(1<<(alefParserPRIVATE-65)))) != 0 {
			{
				p.SetState(972)
				p.Sclass()
			}

		}
		{
			p.SetState(975)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(976)
			p.Tlist()
		}
		{
			p.SetState(977)
			p.Match(alefParserT__2)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyVariantContext() *VariantContext {
	var p = new(VariantContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_variant
	return p
}

func (*VariantContext) IsVariantContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_variant

	return p
}

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

func (s *VariantContext) Typecast() ITypecastContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypecastContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypecastContext)
}

func (s *VariantContext) Variant() IVariantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariantContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariantContext)
}

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

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

func (s *VariantContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterVariant(s)
	}
}

func (s *VariantContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitVariant(s)
	}
}

func (p *alefParser) Variant() (localctx IVariantContext) {
	this := p
	_ = this

	localctx = NewVariantContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, alefParserRULE_variant)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(982)
			p.Typecast()
		}
		{
			p.SetState(983)
			p.Match(alefParserT__8)
		}
		{
			p.SetState(984)
			p.Variant()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyXtnameContext() *XtnameContext {
	var p = new(XtnameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_xtname
	return p
}

func (*XtnameContext) IsXtnameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_xtname

	return p
}

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

func (s *XtnameContext) INT() antlr.TerminalNode {
	return s.GetToken(alefParserINT, 0)
}

func (s *XtnameContext) UINT() antlr.TerminalNode {
	return s.GetToken(alefParserUINT, 0)
}

func (s *XtnameContext) SINT() antlr.TerminalNode {
	return s.GetToken(alefParserSINT, 0)
}

func (s *XtnameContext) USINT() antlr.TerminalNode {
	return s.GetToken(alefParserUSINT, 0)
}

func (s *XtnameContext) BYTE() antlr.TerminalNode {
	return s.GetToken(alefParserBYTE, 0)
}

func (s *XtnameContext) FLOAT() antlr.TerminalNode {
	return s.GetToken(alefParserFLOAT, 0)
}

func (s *XtnameContext) VOID() antlr.TerminalNode {
	return s.GetToken(alefParserVOID, 0)
}

func (s *XtnameContext) Typename() ITypenameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypenameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypenameContext)
}

func (s *XtnameContext) Variant() IVariantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVariantContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVariantContext)
}

func (s *XtnameContext) CHAN() antlr.TerminalNode {
	return s.GetToken(alefParserCHAN, 0)
}

func (s *XtnameContext) Bufdim() IBufdimContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBufdimContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBufdimContext)
}

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

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

func (s *XtnameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterXtname(s)
	}
}

func (s *XtnameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitXtname(s)
	}
}

func (p *alefParser) Xtname() (localctx IXtnameContext) {
	this := p
	_ = this

	localctx = NewXtnameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 112, alefParserRULE_xtname)
	var _la int

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(989)
			p.Match(alefParserUINT)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(990)
			p.Match(alefParserSINT)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(991)
			p.Match(alefParserUSINT)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(992)
			p.Match(alefParserBYTE)
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(993)
			p.Match(alefParserFLOAT)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(994)
			p.Match(alefParserVOID)
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(995)
			p.Typename()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(996)
			p.Typename()
		}
		{
			p.SetState(997)
			p.Match(alefParserT__6)
		}
		{
			p.SetState(998)
			p.Variant()
		}
		{
			p.SetState(999)
			p.Match(alefParserT__7)
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(1001)
			p.Match(alefParserCHAN)
		}
		{
			p.SetState(1002)
			p.Match(alefParserT__1)
		}
		{
			p.SetState(1003)
			p.Variant()
		}
		{
			p.SetState(1004)
			p.Match(alefParserT__2)
		}
		p.SetState(1006)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == alefParserT__6 {
			{
				p.SetState(1005)
				p.Bufdim()
			}

		}

	}

	return localctx
}

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

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

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

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

func NewEmptyBufdimContext() *BufdimContext {
	var p = new(BufdimContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_bufdim
	return p
}

func (*BufdimContext) IsBufdimContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_bufdim

	return p
}

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

func (s *BufdimContext) Expr_() IExpr_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpr_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpr_Context)
}

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

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

func (s *BufdimContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterBufdim(s)
	}
}

func (s *BufdimContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitBufdim(s)
	}
}

func (p *alefParser) Bufdim() (localctx IBufdimContext) {
	this := p
	_ = this

	localctx = NewBufdimContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 114, alefParserRULE_bufdim)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1010)
		p.Match(alefParserT__6)
	}
	{
		p.SetState(1011)
		p.expr_(0)
	}
	{
		p.SetState(1012)
		p.Match(alefParserT__7)
	}

	return localctx
}

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

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

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

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

func NewEmptySclassContext() *SclassContext {
	var p = new(SclassContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_sclass
	return p
}

func (*SclassContext) IsSclassContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_sclass

	return p
}

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

func (s *SclassContext) EXTERN() antlr.TerminalNode {
	return s.GetToken(alefParserEXTERN, 0)
}

func (s *SclassContext) INTERN() antlr.TerminalNode {
	return s.GetToken(alefParserINTERN, 0)
}

func (s *SclassContext) PRIVATE() antlr.TerminalNode {
	return s.GetToken(alefParserPRIVATE, 0)
}

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

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

func (s *SclassContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterSclass(s)
	}
}

func (s *SclassContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitSclass(s)
	}
}

func (p *alefParser) Sclass() (localctx ISclassContext) {
	this := p
	_ = this

	localctx = NewSclassContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, alefParserRULE_sclass)
	var _la int

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

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

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

		if !(((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(alefParserEXTERN-65))|(1<<(alefParserINTERN-65))|(1<<(alefParserPRIVATE-65)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	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 = alefParserRULE_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 = alefParserRULE_typename

	return p
}

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

func (s *TypenameContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(alefParserIDENTIFIER, 0)
}

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

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

func (s *TypenameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterTypename(s)
	}
}

func (s *TypenameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitTypename(s)
	}
}

func (p *alefParser) Typename() (localctx ITypenameContext) {
	this := p
	_ = this

	localctx = NewTypenameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, alefParserRULE_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.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1016)
		p.Match(alefParserIDENTIFIER)
	}

	return localctx
}

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

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

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

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

func NewEmptyEnum_memberContext() *Enum_memberContext {
	var p = new(Enum_memberContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = alefParserRULE_enum_member
	return p
}

func (*Enum_memberContext) IsEnum_memberContext() {}

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

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

	p.parser = parser
	p.RuleIndex = alefParserRULE_enum_member

	return p
}

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

func (s *Enum_memberContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(alefParserIDENTIFIER, 0)
}

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

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

func (s *Enum_memberContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.EnterEnum_member(s)
	}
}

func (s *Enum_memberContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(alefListener); ok {
		listenerT.ExitEnum_member(s)
	}
}

func (p *alefParser) Enum_member() (localctx IEnum_memberContext) {
	this := p
	_ = this

	localctx = NewEnum_memberContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, alefParserRULE_enum_member)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1018)
		p.Match(alefParserIDENTIFIER)
	}

	return localctx
}

func (p *alefParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
	switch ruleIndex {
	case 10:
		var t *SetlistContext = nil
		if localctx != nil {
			t = localctx.(*SetlistContext)
		}
		return p.Setlist_Sempred(t, predIndex)

	case 13:
		var t *MemberlistContext = nil
		if localctx != nil {
			t = localctx.(*MemberlistContext)
		}
		return p.Memberlist_Sempred(t, predIndex)

	case 17:
		var t *ZelistContext = nil
		if localctx != nil {
			t = localctx.(*ZelistContext)
		}
		return p.Zelist_Sempred(t, predIndex)

	case 42:
		var t *Expr_Context = nil
		if localctx != nil {
			t = localctx.(*Expr_Context)
		}
		return p.Expr__Sempred(t, predIndex)

	case 49:
		var t *Term_Context = nil
		if localctx != nil {
			t = localctx.(*Term_Context)
		}
		return p.Term__Sempred(t, predIndex)

	case 52:
		var t *ElistContext = nil
		if localctx != nil {
			t = localctx.(*ElistContext)
		}
		return p.Elist_Sempred(t, predIndex)

	default:
		panic("No predicate with index: " + fmt.Sprint(ruleIndex))
	}
}

func (p *alefParser) Setlist_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 0:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *alefParser) Memberlist_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 1:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *alefParser) Zelist_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 2:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *alefParser) Expr__Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 3:
		return p.Precpred(p.GetParserRuleContext(), 32)

	case 4:
		return p.Precpred(p.GetParserRuleContext(), 31)

	case 5:
		return p.Precpred(p.GetParserRuleContext(), 30)

	case 6:
		return p.Precpred(p.GetParserRuleContext(), 29)

	case 7:
		return p.Precpred(p.GetParserRuleContext(), 28)

	case 8:
		return p.Precpred(p.GetParserRuleContext(), 27)

	case 9:
		return p.Precpred(p.GetParserRuleContext(), 26)

	case 10:
		return p.Precpred(p.GetParserRuleContext(), 25)

	case 11:
		return p.Precpred(p.GetParserRuleContext(), 24)

	case 12:
		return p.Precpred(p.GetParserRuleContext(), 23)

	case 13:
		return p.Precpred(p.GetParserRuleContext(), 22)

	case 14:
		return p.Precpred(p.GetParserRuleContext(), 21)

	case 15:
		return p.Precpred(p.GetParserRuleContext(), 20)

	case 16:
		return p.Precpred(p.GetParserRuleContext(), 19)

	case 17:
		return p.Precpred(p.GetParserRuleContext(), 18)

	case 18:
		return p.Precpred(p.GetParserRuleContext(), 17)

	case 19:
		return p.Precpred(p.GetParserRuleContext(), 16)

	case 20:
		return p.Precpred(p.GetParserRuleContext(), 15)

	case 21:
		return p.Precpred(p.GetParserRuleContext(), 14)

	case 22:
		return p.Precpred(p.GetParserRuleContext(), 13)

	case 23:
		return p.Precpred(p.GetParserRuleContext(), 12)

	case 24:
		return p.Precpred(p.GetParserRuleContext(), 11)

	case 25:
		return p.Precpred(p.GetParserRuleContext(), 10)

	case 26:
		return p.Precpred(p.GetParserRuleContext(), 9)

	case 27:
		return p.Precpred(p.GetParserRuleContext(), 8)

	case 28:
		return p.Precpred(p.GetParserRuleContext(), 7)

	case 29:
		return p.Precpred(p.GetParserRuleContext(), 6)

	case 30:
		return p.Precpred(p.GetParserRuleContext(), 5)

	case 31:
		return p.Precpred(p.GetParserRuleContext(), 4)

	case 32:
		return p.Precpred(p.GetParserRuleContext(), 3)

	case 33:
		return p.Precpred(p.GetParserRuleContext(), 2)

	case 34:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *alefParser) Term__Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 35:
		return p.Precpred(p.GetParserRuleContext(), 16)

	case 36:
		return p.Precpred(p.GetParserRuleContext(), 15)

	case 37:
		return p.Precpred(p.GetParserRuleContext(), 14)

	case 38:
		return p.Precpred(p.GetParserRuleContext(), 12)

	case 39:
		return p.Precpred(p.GetParserRuleContext(), 11)

	case 40:
		return p.Precpred(p.GetParserRuleContext(), 10)

	case 41:
		return p.Precpred(p.GetParserRuleContext(), 9)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *alefParser) Elist_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 42:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}
