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

package c // C
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, 120, 1098,
	4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7,
	4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13,
	9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9,
	18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23,
	4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4,
	29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34,
	9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9,
	39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44,
	4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4,
	50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55,
	9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9,
	60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65,
	4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4,
	71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76,
	9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9,
	81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86,
	4, 87, 9, 87, 4, 88, 9, 88, 3, 2, 3, 2, 3, 2, 6, 2, 180, 10, 2, 13, 2,
	14, 2, 181, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 2, 190, 10, 2, 3, 2,
	3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2,
	3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 2, 210, 10, 2, 3, 3, 3, 3, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 7, 4, 222, 10, 4, 12, 4, 14, 4, 225,
	11, 4, 3, 5, 3, 5, 5, 5, 229, 10, 5, 3, 5, 3, 5, 3, 5, 3, 6, 3, 6, 5, 6,
	236, 10, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 5, 6, 244, 10, 6, 3, 6,
	3, 6, 5, 6, 248, 10, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 5, 6, 256,
	10, 6, 3, 6, 3, 6, 3, 6, 3, 6, 7, 6, 262, 10, 6, 12, 6, 14, 6, 265, 11,
	6, 3, 7, 3, 7, 3, 7, 7, 7, 270, 10, 7, 12, 7, 14, 7, 273, 11, 7, 3, 8,
	7, 8, 276, 10, 8, 12, 8, 14, 8, 279, 11, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3,
	8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 5, 8, 292, 10, 8, 3, 9, 3, 9, 3,
	10, 5, 10, 297, 10, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10,
	5, 10, 306, 10, 10, 3, 11, 3, 11, 3, 11, 7, 11, 311, 10, 11, 12, 11, 14,
	11, 314, 11, 11, 3, 12, 3, 12, 3, 12, 7, 12, 319, 10, 12, 12, 12, 14, 12,
	322, 11, 12, 3, 13, 3, 13, 3, 13, 7, 13, 327, 10, 13, 12, 13, 14, 13, 330,
	11, 13, 3, 14, 3, 14, 3, 14, 7, 14, 335, 10, 14, 12, 14, 14, 14, 338, 11,
	14, 3, 15, 3, 15, 3, 15, 7, 15, 343, 10, 15, 12, 15, 14, 15, 346, 11, 15,
	3, 16, 3, 16, 3, 16, 7, 16, 351, 10, 16, 12, 16, 14, 16, 354, 11, 16, 3,
	17, 3, 17, 3, 17, 7, 17, 359, 10, 17, 12, 17, 14, 17, 362, 11, 17, 3, 18,
	3, 18, 3, 18, 7, 18, 367, 10, 18, 12, 18, 14, 18, 370, 11, 18, 3, 19, 3,
	19, 3, 19, 7, 19, 375, 10, 19, 12, 19, 14, 19, 378, 11, 19, 3, 20, 3, 20,
	3, 20, 7, 20, 383, 10, 20, 12, 20, 14, 20, 386, 11, 20, 3, 21, 3, 21, 3,
	21, 3, 21, 3, 21, 3, 21, 5, 21, 394, 10, 21, 3, 22, 3, 22, 3, 22, 3, 22,
	3, 22, 3, 22, 5, 22, 402, 10, 22, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 7,
	24, 409, 10, 24, 12, 24, 14, 24, 412, 11, 24, 3, 25, 3, 25, 3, 26, 3, 26,
	5, 26, 418, 10, 26, 3, 26, 3, 26, 3, 26, 5, 26, 423, 10, 26, 3, 27, 6,
	27, 426, 10, 27, 13, 27, 14, 27, 427, 3, 28, 6, 28, 431, 10, 28, 13, 28,
	14, 28, 432, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 5, 29, 440, 10, 29, 3,
	30, 3, 30, 3, 30, 7, 30, 445, 10, 30, 12, 30, 14, 30, 448, 11, 30, 3, 31,
	3, 31, 3, 31, 5, 31, 453, 10, 31, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3,
	33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33,
	3, 33, 5, 33, 472, 10, 33, 3, 33, 3, 33, 7, 33, 476, 10, 33, 12, 33, 14,
	33, 479, 11, 33, 3, 34, 3, 34, 5, 34, 483, 10, 34, 3, 34, 3, 34, 3, 34,
	3, 34, 3, 34, 3, 34, 3, 34, 5, 34, 492, 10, 34, 3, 35, 3, 35, 3, 36, 6,
	36, 497, 10, 36, 13, 36, 14, 36, 498, 3, 37, 3, 37, 5, 37, 503, 10, 37,
	3, 37, 3, 37, 3, 37, 5, 37, 508, 10, 37, 3, 38, 3, 38, 5, 38, 512, 10,
	38, 3, 38, 5, 38, 515, 10, 38, 3, 39, 3, 39, 3, 39, 7, 39, 520, 10, 39,
	12, 39, 14, 39, 523, 11, 39, 3, 40, 3, 40, 5, 40, 527, 10, 40, 3, 40, 3,
	40, 5, 40, 531, 10, 40, 3, 41, 3, 41, 5, 41, 535, 10, 41, 3, 41, 3, 41,
	3, 41, 5, 41, 540, 10, 41, 3, 41, 3, 41, 3, 41, 3, 41, 5, 41, 546, 10,
	41, 3, 42, 3, 42, 3, 42, 7, 42, 551, 10, 42, 12, 42, 14, 42, 554, 11, 42,
	3, 43, 3, 43, 3, 43, 5, 43, 559, 10, 43, 3, 44, 3, 44, 3, 45, 3, 45, 3,
	45, 3, 45, 3, 45, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47,
	5, 47, 576, 10, 47, 3, 48, 3, 48, 3, 48, 3, 48, 5, 48, 582, 10, 48, 3,
	48, 3, 48, 3, 49, 5, 49, 587, 10, 49, 3, 49, 3, 49, 7, 49, 591, 10, 49,
	12, 49, 14, 49, 594, 11, 49, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50,
	3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 607, 10, 50, 3, 50, 3, 50, 3,
	50, 3, 50, 5, 50, 613, 10, 50, 3, 50, 3, 50, 3, 50, 5, 50, 618, 10, 50,
	3, 50, 5, 50, 621, 10, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 628,
	10, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50,
	3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 643, 10, 50, 3, 50, 3, 50, 3, 50, 3,
	50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 655, 10, 50, 3, 50,
	7, 50, 658, 10, 50, 12, 50, 14, 50, 661, 11, 50, 3, 51, 3, 51, 3, 51, 6,
	51, 666, 10, 51, 13, 51, 14, 51, 667, 3, 51, 3, 51, 5, 51, 672, 10, 51,
	3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 53, 5, 53, 682, 10,
	53, 3, 53, 3, 53, 5, 53, 686, 10, 53, 7, 53, 688, 10, 53, 12, 53, 14, 53,
	691, 11, 53, 3, 54, 3, 54, 3, 54, 5, 54, 696, 10, 54, 3, 54, 5, 54, 699,
	10, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 7, 55, 706, 10, 55, 12, 55,
	14, 55, 709, 11, 55, 3, 56, 3, 56, 5, 56, 713, 10, 56, 6, 56, 715, 10,
	56, 13, 56, 14, 56, 716, 3, 57, 6, 57, 720, 10, 57, 13, 57, 14, 57, 721,
	3, 58, 3, 58, 3, 58, 5, 58, 727, 10, 58, 3, 59, 3, 59, 3, 59, 7, 59, 732,
	10, 59, 12, 59, 14, 59, 735, 11, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60,
	5, 60, 742, 10, 60, 5, 60, 744, 10, 60, 3, 61, 3, 61, 3, 61, 7, 61, 749,
	10, 61, 12, 61, 14, 61, 752, 11, 61, 3, 62, 3, 62, 5, 62, 756, 10, 62,
	3, 63, 3, 63, 5, 63, 760, 10, 63, 3, 63, 3, 63, 7, 63, 764, 10, 63, 12,
	63, 14, 63, 767, 11, 63, 5, 63, 769, 10, 63, 3, 64, 3, 64, 3, 64, 3, 64,
	3, 64, 7, 64, 776, 10, 64, 12, 64, 14, 64, 779, 11, 64, 3, 64, 3, 64, 5,
	64, 783, 10, 64, 3, 64, 5, 64, 786, 10, 64, 3, 64, 3, 64, 3, 64, 3, 64,
	5, 64, 792, 10, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3,
	64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 5, 64, 808, 10, 64, 3, 64,
	3, 64, 7, 64, 812, 10, 64, 12, 64, 14, 64, 815, 11, 64, 5, 64, 817, 10,
	64, 3, 64, 3, 64, 3, 64, 5, 64, 822, 10, 64, 3, 64, 5, 64, 825, 10, 64,
	3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 5, 64, 832, 10, 64, 3, 64, 3, 64, 3,
	64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64,
	3, 64, 3, 64, 3, 64, 3, 64, 5, 64, 851, 10, 64, 3, 64, 3, 64, 7, 64, 855,
	10, 64, 12, 64, 14, 64, 858, 11, 64, 7, 64, 860, 10, 64, 12, 64, 14, 64,
	863, 11, 64, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3, 66, 5, 66, 871, 10,
	66, 3, 66, 3, 66, 5, 66, 875, 10, 66, 3, 67, 5, 67, 878, 10, 67, 3, 67,
	3, 67, 3, 67, 5, 67, 883, 10, 67, 3, 67, 7, 67, 886, 10, 67, 12, 67, 14,
	67, 889, 11, 67, 3, 68, 3, 68, 3, 68, 3, 69, 6, 69, 895, 10, 69, 13, 69,
	14, 69, 896, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 905, 10,
	70, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 6, 71, 912, 10, 71, 13, 71, 14,
	71, 913, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72,
	3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 7, 72, 931, 10, 72, 12, 72, 14,
	72, 934, 11, 72, 5, 72, 936, 10, 72, 3, 72, 3, 72, 3, 72, 3, 72, 7, 72,
	942, 10, 72, 12, 72, 14, 72, 945, 11, 72, 5, 72, 947, 10, 72, 7, 72, 949,
	10, 72, 12, 72, 14, 72, 952, 11, 72, 3, 72, 3, 72, 5, 72, 956, 10, 72,
	3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3,
	73, 5, 73, 969, 10, 73, 3, 74, 3, 74, 5, 74, 973, 10, 74, 3, 74, 3, 74,
	3, 75, 6, 75, 978, 10, 75, 13, 75, 14, 75, 979, 3, 76, 3, 76, 5, 76, 984,
	10, 76, 3, 77, 5, 77, 987, 10, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 78, 3,
	78, 3, 78, 3, 78, 3, 78, 5, 78, 998, 10, 78, 3, 78, 3, 78, 3, 78, 3, 78,
	3, 78, 3, 78, 5, 78, 1006, 10, 78, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3,
	79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79,
	3, 79, 3, 79, 3, 79, 3, 79, 5, 79, 1028, 10, 79, 3, 80, 3, 80, 5, 80, 1032,
	10, 80, 5, 80, 1034, 10, 80, 3, 80, 3, 80, 5, 80, 1038, 10, 80, 3, 80,
	3, 80, 5, 80, 1042, 10, 80, 3, 81, 3, 81, 5, 81, 1046, 10, 81, 3, 82, 3,
	82, 3, 82, 7, 82, 1051, 10, 82, 12, 82, 14, 82, 1054, 11, 82, 3, 83, 3,
	83, 3, 83, 3, 83, 3, 83, 5, 83, 1061, 10, 83, 3, 83, 3, 83, 5, 83, 1065,
	10, 83, 3, 83, 3, 83, 3, 84, 5, 84, 1070, 10, 84, 3, 84, 3, 84, 3, 85,
	6, 85, 1075, 10, 85, 13, 85, 14, 85, 1076, 3, 86, 3, 86, 3, 86, 5, 86,
	1082, 10, 86, 3, 87, 5, 87, 1085, 10, 87, 3, 87, 3, 87, 5, 87, 1089, 10,
	87, 3, 87, 3, 87, 3, 88, 6, 88, 1094, 10, 88, 13, 88, 14, 88, 1095, 3,
	88, 2, 5, 64, 98, 126, 89, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24,
	26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60,
	62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96,
	98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126,
	128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156,
	158, 160, 162, 164, 166, 168, 170, 172, 174, 2, 25, 3, 2, 104, 105, 4,
	2, 74, 74, 76, 76, 5, 2, 41, 41, 74, 74, 76, 76, 4, 2, 41, 41, 52, 52,
	7, 2, 73, 73, 75, 75, 77, 77, 80, 80, 85, 86, 3, 2, 77, 79, 4, 2, 73, 73,
	75, 75, 3, 2, 71, 72, 3, 2, 67, 70, 3, 2, 102, 103, 3, 2, 91, 101, 8, 2,
	17, 17, 28, 28, 36, 36, 42, 42, 45, 45, 60, 60, 10, 2, 6, 8, 20, 20, 25,
	25, 29, 29, 34, 35, 39, 40, 47, 48, 54, 55, 3, 2, 6, 8, 4, 2, 43, 43, 46,
	46, 6, 2, 21, 21, 37, 37, 49, 49, 53, 53, 5, 2, 10, 11, 33, 33, 58, 58,
	4, 2, 61, 62, 90, 90, 3, 2, 61, 62, 4, 2, 77, 77, 84, 84, 4, 2, 13, 13,
	15, 15, 4, 2, 16, 16, 49, 49, 4, 2, 18, 18, 22, 22, 2, 1191, 2, 209, 3,
	2, 2, 2, 4, 211, 3, 2, 2, 2, 6, 218, 3, 2, 2, 2, 8, 228, 3, 2, 2, 2, 10,
	247, 3, 2, 2, 2, 12, 266, 3, 2, 2, 2, 14, 277, 3, 2, 2, 2, 16, 293, 3,
	2, 2, 2, 18, 305, 3, 2, 2, 2, 20, 307, 3, 2, 2, 2, 22, 315, 3, 2, 2, 2,
	24, 323, 3, 2, 2, 2, 26, 331, 3, 2, 2, 2, 28, 339, 3, 2, 2, 2, 30, 347,
	3, 2, 2, 2, 32, 355, 3, 2, 2, 2, 34, 363, 3, 2, 2, 2, 36, 371, 3, 2, 2,
	2, 38, 379, 3, 2, 2, 2, 40, 387, 3, 2, 2, 2, 42, 401, 3, 2, 2, 2, 44, 403,
	3, 2, 2, 2, 46, 405, 3, 2, 2, 2, 48, 413, 3, 2, 2, 2, 50, 422, 3, 2, 2,
	2, 52, 425, 3, 2, 2, 2, 54, 430, 3, 2, 2, 2, 56, 439, 3, 2, 2, 2, 58, 441,
	3, 2, 2, 2, 60, 449, 3, 2, 2, 2, 62, 454, 3, 2, 2, 2, 64, 471, 3, 2, 2,
	2, 66, 491, 3, 2, 2, 2, 68, 493, 3, 2, 2, 2, 70, 496, 3, 2, 2, 2, 72, 507,
	3, 2, 2, 2, 74, 511, 3, 2, 2, 2, 76, 516, 3, 2, 2, 2, 78, 530, 3, 2, 2,
	2, 80, 545, 3, 2, 2, 2, 82, 547, 3, 2, 2, 2, 84, 555, 3, 2, 2, 2, 86, 560,
	3, 2, 2, 2, 88, 562, 3, 2, 2, 2, 90, 567, 3, 2, 2, 2, 92, 575, 3, 2, 2,
	2, 94, 577, 3, 2, 2, 2, 96, 586, 3, 2, 2, 2, 98, 612, 3, 2, 2, 2, 100,
	671, 3, 2, 2, 2, 102, 673, 3, 2, 2, 2, 104, 681, 3, 2, 2, 2, 106, 692,
	3, 2, 2, 2, 108, 707, 3, 2, 2, 2, 110, 714, 3, 2, 2, 2, 112, 719, 3, 2,
	2, 2, 114, 723, 3, 2, 2, 2, 116, 728, 3, 2, 2, 2, 118, 743, 3, 2, 2, 2,
	120, 745, 3, 2, 2, 2, 122, 753, 3, 2, 2, 2, 124, 768, 3, 2, 2, 2, 126,
	816, 3, 2, 2, 2, 128, 864, 3, 2, 2, 2, 130, 874, 3, 2, 2, 2, 132, 877,
	3, 2, 2, 2, 134, 890, 3, 2, 2, 2, 136, 894, 3, 2, 2, 2, 138, 904, 3, 2,
	2, 2, 140, 906, 3, 2, 2, 2, 142, 955, 3, 2, 2, 2, 144, 968, 3, 2, 2, 2,
	146, 970, 3, 2, 2, 2, 148, 977, 3, 2, 2, 2, 150, 983, 3, 2, 2, 2, 152,
	986, 3, 2, 2, 2, 154, 1005, 3, 2, 2, 2, 156, 1027, 3, 2, 2, 2, 158, 1033,
	3, 2, 2, 2, 160, 1043, 3, 2, 2, 2, 162, 1047, 3, 2, 2, 2, 164, 1064, 3,
	2, 2, 2, 166, 1069, 3, 2, 2, 2, 168, 1074, 3, 2, 2, 2, 170, 1081, 3, 2,
	2, 2, 172, 1084, 3, 2, 2, 2, 174, 1093, 3, 2, 2, 2, 176, 210, 7, 107, 2,
	2, 177, 210, 7, 108, 2, 2, 178, 180, 7, 110, 2, 2, 179, 178, 3, 2, 2, 2,
	180, 181, 3, 2, 2, 2, 181, 179, 3, 2, 2, 2, 181, 182, 3, 2, 2, 2, 182,
	210, 3, 2, 2, 2, 183, 184, 7, 61, 2, 2, 184, 185, 5, 46, 24, 2, 185, 186,
	7, 62, 2, 2, 186, 210, 3, 2, 2, 2, 187, 210, 5, 4, 3, 2, 188, 190, 7, 3,
	2, 2, 189, 188, 3, 2, 2, 2, 189, 190, 3, 2, 2, 2, 190, 191, 3, 2, 2, 2,
	191, 192, 7, 61, 2, 2, 192, 193, 5, 146, 74, 2, 193, 194, 7, 62, 2, 2,
	194, 210, 3, 2, 2, 2, 195, 196, 7, 4, 2, 2, 196, 197, 7, 61, 2, 2, 197,
	198, 5, 14, 8, 2, 198, 199, 7, 90, 2, 2, 199, 200, 5, 122, 62, 2, 200,
	201, 7, 62, 2, 2, 201, 210, 3, 2, 2, 2, 202, 203, 7, 5, 2, 2, 203, 204,
	7, 61, 2, 2, 204, 205, 5, 122, 62, 2, 205, 206, 7, 90, 2, 2, 206, 207,
	5, 14, 8, 2, 207, 208, 7, 62, 2, 2, 208, 210, 3, 2, 2, 2, 209, 176, 3,
	2, 2, 2, 209, 177, 3, 2, 2, 2, 209, 179, 3, 2, 2, 2, 209, 183, 3, 2, 2,
	2, 209, 187, 3, 2, 2, 2, 209, 189, 3, 2, 2, 2, 209, 195, 3, 2, 2, 2, 209,
	202, 3, 2, 2, 2, 210, 3, 3, 2, 2, 2, 211, 212, 7, 56, 2, 2, 212, 213, 7,
	61, 2, 2, 213, 214, 5, 42, 22, 2, 214, 215, 7, 90, 2, 2, 215, 216, 5, 6,
	4, 2, 216, 217, 7, 62, 2, 2, 217, 5, 3, 2, 2, 2, 218, 223, 5, 8, 5, 2,
	219, 220, 7, 90, 2, 2, 220, 222, 5, 8, 5, 2, 221, 219, 3, 2, 2, 2, 222,
	225, 3, 2, 2, 2, 223, 221, 3, 2, 2, 2, 223, 224, 3, 2, 2, 2, 224, 7, 3,
	2, 2, 2, 225, 223, 3, 2, 2, 2, 226, 229, 5, 122, 62, 2, 227, 229, 7, 23,
	2, 2, 228, 226, 3, 2, 2, 2, 228, 227, 3, 2, 2, 2, 229, 230, 3, 2, 2, 2,
	230, 231, 7, 88, 2, 2, 231, 232, 5, 42, 22, 2, 232, 9, 3, 2, 2, 2, 233,
	248, 5, 2, 2, 2, 234, 236, 7, 3, 2, 2, 235, 234, 3, 2, 2, 2, 235, 236,
	3, 2, 2, 2, 236, 237, 3, 2, 2, 2, 237, 238, 7, 61, 2, 2, 238, 239, 5, 122,
	62, 2, 239, 240, 7, 62, 2, 2, 240, 241, 7, 65, 2, 2, 241, 243, 5, 132,
	67, 2, 242, 244, 7, 90, 2, 2, 243, 242, 3, 2, 2, 2, 243, 244, 3, 2, 2,
	2, 244, 245, 3, 2, 2, 2, 245, 246, 7, 66, 2, 2, 246, 248, 3, 2, 2, 2, 247,
	233, 3, 2, 2, 2, 247, 235, 3, 2, 2, 2, 248, 263, 3, 2, 2, 2, 249, 250,
	7, 63, 2, 2, 250, 251, 5, 46, 24, 2, 251, 252, 7, 64, 2, 2, 252, 262, 3,
	2, 2, 2, 253, 255, 7, 61, 2, 2, 254, 256, 5, 12, 7, 2, 255, 254, 3, 2,
	2, 2, 255, 256, 3, 2, 2, 2, 256, 257, 3, 2, 2, 2, 257, 262, 7, 62, 2, 2,
	258, 259, 9, 2, 2, 2, 259, 262, 7, 107, 2, 2, 260, 262, 9, 3, 2, 2, 261,
	249, 3, 2, 2, 2, 261, 253, 3, 2, 2, 2, 261, 258, 3, 2, 2, 2, 261, 260,
	3, 2, 2, 2, 262, 265, 3, 2, 2, 2, 263, 261, 3, 2, 2, 2, 263, 264, 3, 2,
	2, 2, 264, 11, 3, 2, 2, 2, 265, 263, 3, 2, 2, 2, 266, 271, 5, 42, 22, 2,
	267, 268, 7, 90, 2, 2, 268, 270, 5, 42, 22, 2, 269, 267, 3, 2, 2, 2, 270,
	273, 3, 2, 2, 2, 271, 269, 3, 2, 2, 2, 271, 272, 3, 2, 2, 2, 272, 13, 3,
	2, 2, 2, 273, 271, 3, 2, 2, 2, 274, 276, 9, 4, 2, 2, 275, 274, 3, 2, 2,
	2, 276, 279, 3, 2, 2, 2, 277, 275, 3, 2, 2, 2, 277, 278, 3, 2, 2, 2, 278,
	291, 3, 2, 2, 2, 279, 277, 3, 2, 2, 2, 280, 292, 5, 10, 6, 2, 281, 282,
	5, 16, 9, 2, 282, 283, 5, 18, 10, 2, 283, 292, 3, 2, 2, 2, 284, 285, 9,
	5, 2, 2, 285, 286, 7, 61, 2, 2, 286, 287, 5, 122, 62, 2, 287, 288, 7, 62,
	2, 2, 288, 292, 3, 2, 2, 2, 289, 290, 7, 82, 2, 2, 290, 292, 7, 107, 2,
	2, 291, 280, 3, 2, 2, 2, 291, 281, 3, 2, 2, 2, 291, 284, 3, 2, 2, 2, 291,
	289, 3, 2, 2, 2, 292, 15, 3, 2, 2, 2, 293, 294, 9, 6, 2, 2, 294, 17, 3,
	2, 2, 2, 295, 297, 7, 3, 2, 2, 296, 295, 3, 2, 2, 2, 296, 297, 3, 2, 2,
	2, 297, 298, 3, 2, 2, 2, 298, 299, 7, 61, 2, 2, 299, 300, 5, 122, 62, 2,
	300, 301, 7, 62, 2, 2, 301, 302, 5, 18, 10, 2, 302, 306, 3, 2, 2, 2, 303,
	306, 5, 14, 8, 2, 304, 306, 7, 109, 2, 2, 305, 296, 3, 2, 2, 2, 305, 303,
	3, 2, 2, 2, 305, 304, 3, 2, 2, 2, 306, 19, 3, 2, 2, 2, 307, 312, 5, 18,
	10, 2, 308, 309, 9, 7, 2, 2, 309, 311, 5, 18, 10, 2, 310, 308, 3, 2, 2,
	2, 311, 314, 3, 2, 2, 2, 312, 310, 3, 2, 2, 2, 312, 313, 3, 2, 2, 2, 313,
	21, 3, 2, 2, 2, 314, 312, 3, 2, 2, 2, 315, 320, 5, 20, 11, 2, 316, 317,
	9, 8, 2, 2, 317, 319, 5, 20, 11, 2, 318, 316, 3, 2, 2, 2, 319, 322, 3,
	2, 2, 2, 320, 318, 3, 2, 2, 2, 320, 321, 3, 2, 2, 2, 321, 23, 3, 2, 2,
	2, 322, 320, 3, 2, 2, 2, 323, 328, 5, 22, 12, 2, 324, 325, 9, 9, 2, 2,
	325, 327, 5, 22, 12, 2, 326, 324, 3, 2, 2, 2, 327, 330, 3, 2, 2, 2, 328,
	326, 3, 2, 2, 2, 328, 329, 3, 2, 2, 2, 329, 25, 3, 2, 2, 2, 330, 328, 3,
	2, 2, 2, 331, 336, 5, 24, 13, 2, 332, 333, 9, 10, 2, 2, 333, 335, 5, 24,
	13, 2, 334, 332, 3, 2, 2, 2, 335, 338, 3, 2, 2, 2, 336, 334, 3, 2, 2, 2,
	336, 337, 3, 2, 2, 2, 337, 27, 3, 2, 2, 2, 338, 336, 3, 2, 2, 2, 339, 344,
	5, 26, 14, 2, 340, 341, 9, 11, 2, 2, 341, 343, 5, 26, 14, 2, 342, 340,
	3, 2, 2, 2, 343, 346, 3, 2, 2, 2, 344, 342, 3, 2, 2, 2, 344, 345, 3, 2,
	2, 2, 345, 29, 3, 2, 2, 2, 346, 344, 3, 2, 2, 2, 347, 352, 5, 28, 15, 2,
	348, 349, 7, 80, 2, 2, 349, 351, 5, 28, 15, 2, 350, 348, 3, 2, 2, 2, 351,
	354, 3, 2, 2, 2, 352, 350, 3, 2, 2, 2, 352, 353, 3, 2, 2, 2, 353, 31, 3,
	2, 2, 2, 354, 352, 3, 2, 2, 2, 355, 360, 5, 30, 16, 2, 356, 357, 7, 84,
	2, 2, 357, 359, 5, 30, 16, 2, 358, 356, 3, 2, 2, 2, 359, 362, 3, 2, 2,
	2, 360, 358, 3, 2, 2, 2, 360, 361, 3, 2, 2, 2, 361, 33, 3, 2, 2, 2, 362,
	360, 3, 2, 2, 2, 363, 368, 5, 32, 17, 2, 364, 365, 7, 81, 2, 2, 365, 367,
	5, 32, 17, 2, 366, 364, 3, 2, 2, 2, 367, 370, 3, 2, 2, 2, 368, 366, 3,
	2, 2, 2, 368, 369, 3, 2, 2, 2, 369, 35, 3, 2, 2, 2, 370, 368, 3, 2, 2,
	2, 371, 376, 5, 34, 18, 2, 372, 373, 7, 82, 2, 2, 373, 375, 5, 34, 18,
	2, 374, 372, 3, 2, 2, 2, 375, 378, 3, 2, 2, 2, 376, 374, 3, 2, 2, 2, 376,
	377, 3, 2, 2, 2, 377, 37, 3, 2, 2, 2, 378, 376, 3, 2, 2, 2, 379, 384, 5,
	36, 19, 2, 380, 381, 7, 83, 2, 2, 381, 383, 5, 36, 19, 2, 382, 380, 3,
	2, 2, 2, 383, 386, 3, 2, 2, 2, 384, 382, 3, 2, 2, 2, 384, 385, 3, 2, 2,
	2, 385, 39, 3, 2, 2, 2, 386, 384, 3, 2, 2, 2, 387, 393, 5, 38, 20, 2, 388,
	389, 7, 87, 2, 2, 389, 390, 5, 46, 24, 2, 390, 391, 7, 88, 2, 2, 391, 392,
	5, 40, 21, 2, 392, 394, 3, 2, 2, 2, 393, 388, 3, 2, 2, 2, 393, 394, 3,
	2, 2, 2, 394, 41, 3, 2, 2, 2, 395, 402, 5, 40, 21, 2, 396, 397, 5, 14,
	8, 2, 397, 398, 5, 44, 23, 2, 398, 399, 5, 42, 22, 2, 399, 402, 3, 2, 2,
	2, 400, 402, 7, 109, 2, 2, 401, 395, 3, 2, 2, 2, 401, 396, 3, 2, 2, 2,
	401, 400, 3, 2, 2, 2, 402, 43, 3, 2, 2, 2, 403, 404, 9, 12, 2, 2, 404,
	45, 3, 2, 2, 2, 405, 410, 5, 42, 22, 2, 406, 407, 7, 90, 2, 2, 407, 409,
	5, 42, 22, 2, 408, 406, 3, 2, 2, 2, 409, 412, 3, 2, 2, 2, 410, 408, 3,
	2, 2, 2, 410, 411, 3, 2, 2, 2, 411, 47, 3, 2, 2, 2, 412, 410, 3, 2, 2,
	2, 413, 414, 5, 40, 21, 2, 414, 49, 3, 2, 2, 2, 415, 417, 5, 52, 27, 2,
	416, 418, 5, 58, 30, 2, 417, 416, 3, 2, 2, 2, 417, 418, 3, 2, 2, 2, 418,
	419, 3, 2, 2, 2, 419, 420, 7, 89, 2, 2, 420, 423, 3, 2, 2, 2, 421, 423,
	5, 140, 71, 2, 422, 415, 3, 2, 2, 2, 422, 421, 3, 2, 2, 2, 423, 51, 3,
	2, 2, 2, 424, 426, 5, 56, 29, 2, 425, 424, 3, 2, 2, 2, 426, 427, 3, 2,
	2, 2, 427, 425, 3, 2, 2, 2, 427, 428, 3, 2, 2, 2, 428, 53, 3, 2, 2, 2,
	429, 431, 5, 56, 29, 2, 430, 429, 3, 2, 2, 2, 431, 432, 3, 2, 2, 2, 432,
	430, 3, 2, 2, 2, 432, 433, 3, 2, 2, 2, 433, 55, 3, 2, 2, 2, 434, 440, 5,
	62, 32, 2, 435, 440, 5, 64, 33, 2, 436, 440, 5, 90, 46, 2, 437, 440, 5,
	92, 47, 2, 438, 440, 5, 94, 48, 2, 439, 434, 3, 2, 2, 2, 439, 435, 3, 2,
	2, 2, 439, 436, 3, 2, 2, 2, 439, 437, 3, 2, 2, 2, 439, 438, 3, 2, 2, 2,
	440, 57, 3, 2, 2, 2, 441, 446, 5, 60, 31, 2, 442, 443, 7, 90, 2, 2, 443,
	445, 5, 60, 31, 2, 444, 442, 3, 2, 2, 2, 445, 448, 3, 2, 2, 2, 446, 444,
	3, 2, 2, 2, 446, 447, 3, 2, 2, 2, 447, 59, 3, 2, 2, 2, 448, 446, 3, 2,
	2, 2, 449, 452, 5, 96, 49, 2, 450, 451, 7, 91, 2, 2, 451, 453, 5, 130,
	66, 2, 452, 450, 3, 2, 2, 2, 452, 453, 3, 2, 2, 2, 453, 61, 3, 2, 2, 2,
	454, 455, 9, 13, 2, 2, 455, 63, 3, 2, 2, 2, 456, 457, 8, 33, 1, 2, 457,
	472, 9, 14, 2, 2, 458, 459, 7, 3, 2, 2, 459, 460, 7, 61, 2, 2, 460, 461,
	9, 15, 2, 2, 461, 472, 7, 62, 2, 2, 462, 472, 5, 88, 45, 2, 463, 472, 5,
	66, 34, 2, 464, 472, 5, 80, 41, 2, 465, 472, 5, 128, 65, 2, 466, 467, 7,
	9, 2, 2, 467, 468, 7, 61, 2, 2, 468, 469, 5, 48, 25, 2, 469, 470, 7, 62,
	2, 2, 470, 472, 3, 2, 2, 2, 471, 456, 3, 2, 2, 2, 471, 458, 3, 2, 2, 2,
	471, 462, 3, 2, 2, 2, 471, 463, 3, 2, 2, 2, 471, 464, 3, 2, 2, 2, 471,
	465, 3, 2, 2, 2, 471, 466, 3, 2, 2, 2, 472, 477, 3, 2, 2, 2, 473, 474,
	12, 3, 2, 2, 474, 476, 5, 110, 56, 2, 475, 473, 3, 2, 2, 2, 476, 479, 3,
	2, 2, 2, 477, 475, 3, 2, 2, 2, 477, 478, 3, 2, 2, 2, 478, 65, 3, 2, 2,
	2, 479, 477, 3, 2, 2, 2, 480, 482, 5, 68, 35, 2, 481, 483, 7, 107, 2, 2,
	482, 481, 3, 2, 2, 2, 482, 483, 3, 2, 2, 2, 483, 484, 3, 2, 2, 2, 484,
	485, 7, 65, 2, 2, 485, 486, 5, 70, 36, 2, 486, 487, 7, 66, 2, 2, 487, 492,
	3, 2, 2, 2, 488, 489, 5, 68, 35, 2, 489, 490, 7, 107, 2, 2, 490, 492, 3,
	2, 2, 2, 491, 480, 3, 2, 2, 2, 491, 488, 3, 2, 2, 2, 492, 67, 3, 2, 2,
	2, 493, 494, 9, 16, 2, 2, 494, 69, 3, 2, 2, 2, 495, 497, 5, 72, 37, 2,
	496, 495, 3, 2, 2, 2, 497, 498, 3, 2, 2, 2, 498, 496, 3, 2, 2, 2, 498,
	499, 3, 2, 2, 2, 499, 71, 3, 2, 2, 2, 500, 502, 5, 74, 38, 2, 501, 503,
	5, 76, 39, 2, 502, 501, 3, 2, 2, 2, 502, 503, 3, 2, 2, 2, 503, 504, 3,
	2, 2, 2, 504, 505, 7, 89, 2, 2, 505, 508, 3, 2, 2, 2, 506, 508, 5, 140,
	71, 2, 507, 500, 3, 2, 2, 2, 507, 506, 3, 2, 2, 2, 508, 73, 3, 2, 2, 2,
	509, 512, 5, 64, 33, 2, 510, 512, 5, 90, 46, 2, 511, 509, 3, 2, 2, 2, 511,
	510, 3, 2, 2, 2, 512, 514, 3, 2, 2, 2, 513, 515, 5, 74, 38, 2, 514, 513,
	3, 2, 2, 2, 514, 515, 3, 2, 2, 2, 515, 75, 3, 2, 2, 2, 516, 521, 5, 78,
	40, 2, 517, 518, 7, 90, 2, 2, 518, 520, 5, 78, 40, 2, 519, 517, 3, 2, 2,
	2, 520, 523, 3, 2, 2, 2, 521, 519, 3, 2, 2, 2, 521, 522, 3, 2, 2, 2, 522,
	77, 3, 2, 2, 2, 523, 521, 3, 2, 2, 2, 524, 531, 5, 96, 49, 2, 525, 527,
	5, 96, 49, 2, 526, 525, 3, 2, 2, 2, 526, 527, 3, 2, 2, 2, 527, 528, 3,
	2, 2, 2, 528, 529, 7, 88, 2, 2, 529, 531, 5, 48, 25, 2, 530, 524, 3, 2,
	2, 2, 530, 526, 3, 2, 2, 2, 531, 79, 3, 2, 2, 2, 532, 534, 7, 27, 2, 2,
	533, 535, 7, 107, 2, 2, 534, 533, 3, 2, 2, 2, 534, 535, 3, 2, 2, 2, 535,
	536, 3, 2, 2, 2, 536, 537, 7, 65, 2, 2, 537, 539, 5, 82, 42, 2, 538, 540,
	7, 90, 2, 2, 539, 538, 3, 2, 2, 2, 539, 540, 3, 2, 2, 2, 540, 541, 3, 2,
	2, 2, 541, 542, 7, 66, 2, 2, 542, 546, 3, 2, 2, 2, 543, 544, 7, 27, 2,
	2, 544, 546, 7, 107, 2, 2, 545, 532, 3, 2, 2, 2, 545, 543, 3, 2, 2, 2,
	546, 81, 3, 2, 2, 2, 547, 552, 5, 84, 43, 2, 548, 549, 7, 90, 2, 2, 549,
	551, 5, 84, 43, 2, 550, 548, 3, 2, 2, 2, 551, 554, 3, 2, 2, 2, 552, 550,
	3, 2, 2, 2, 552, 553, 3, 2, 2, 2, 553, 83, 3, 2, 2, 2, 554, 552, 3, 2,
	2, 2, 555, 558, 5, 86, 44, 2, 556, 557, 7, 91, 2, 2, 557, 559, 5, 48, 25,
	2, 558, 556, 3, 2, 2, 2, 558, 559, 3, 2, 2, 2, 559, 85, 3, 2, 2, 2, 560,
	561, 7, 107, 2, 2, 561, 87, 3, 2, 2, 2, 562, 563, 7, 53, 2, 2, 563, 564,
	7, 61, 2, 2, 564, 565, 5, 122, 62, 2, 565, 566, 7, 62, 2, 2, 566, 89, 3,
	2, 2, 2, 567, 568, 9, 17, 2, 2, 568, 91, 3, 2, 2, 2, 569, 576, 9, 18, 2,
	2, 570, 576, 5, 102, 52, 2, 571, 572, 7, 12, 2, 2, 572, 573, 7, 61, 2,
	2, 573, 574, 7, 107, 2, 2, 574, 576, 7, 62, 2, 2, 575, 569, 3, 2, 2, 2,
	575, 570, 3, 2, 2, 2, 575, 571, 3, 2, 2, 2, 576, 93, 3, 2, 2, 2, 577, 578,
	7, 51, 2, 2, 578, 581, 7, 61, 2, 2, 579, 582, 5, 122, 62, 2, 580, 582,
	5, 48, 25, 2, 581, 579, 3, 2, 2, 2, 581, 580, 3, 2, 2, 2, 582, 583, 3,
	2, 2, 2, 583, 584, 7, 62, 2, 2, 584, 95, 3, 2, 2, 2, 585, 587, 5, 110,
	56, 2, 586, 585, 3, 2, 2, 2, 586, 587, 3, 2, 2, 2, 587, 588, 3, 2, 2, 2,
	588, 592, 5, 98, 50, 2, 589, 591, 5, 100, 51, 2, 590, 589, 3, 2, 2, 2,
	591, 594, 3, 2, 2, 2, 592, 590, 3, 2, 2, 2, 592, 593, 3, 2, 2, 2, 593,
	97, 3, 2, 2, 2, 594, 592, 3, 2, 2, 2, 595, 596, 8, 50, 1, 2, 596, 613,
	7, 107, 2, 2, 597, 598, 7, 61, 2, 2, 598, 599, 5, 96, 49, 2, 599, 600,
	7, 62, 2, 2, 600, 613, 3, 2, 2, 2, 601, 602, 7, 107, 2, 2, 602, 603, 7,
	88, 2, 2, 603, 613, 7, 109, 2, 2, 604, 606, 7, 61, 2, 2, 605, 607, 5, 64,
	33, 2, 606, 605, 3, 2, 2, 2, 606, 607, 3, 2, 2, 2, 607, 608, 3, 2, 2, 2,
	608, 609, 5, 110, 56, 2, 609, 610, 5, 98, 50, 2, 610, 611, 7, 62, 2, 2,
	611, 613, 3, 2, 2, 2, 612, 595, 3, 2, 2, 2, 612, 597, 3, 2, 2, 2, 612,
	601, 3, 2, 2, 2, 612, 604, 3, 2, 2, 2, 613, 659, 3, 2, 2, 2, 614, 615,
	12, 10, 2, 2, 615, 617, 7, 63, 2, 2, 616, 618, 5, 112, 57, 2, 617, 616,
	3, 2, 2, 2, 617, 618, 3, 2, 2, 2, 618, 620, 3, 2, 2, 2, 619, 621, 5, 42,
	22, 2, 620, 619, 3, 2, 2, 2, 620, 621, 3, 2, 2, 2, 621, 622, 3, 2, 2, 2,
	622, 658, 7, 64, 2, 2, 623, 624, 12, 9, 2, 2, 624, 625, 7, 63, 2, 2, 625,
	627, 7, 42, 2, 2, 626, 628, 5, 112, 57, 2, 627, 626, 3, 2, 2, 2, 627, 628,
	3, 2, 2, 2, 628, 629, 3, 2, 2, 2, 629, 630, 5, 42, 22, 2, 630, 631, 7,
	64, 2, 2, 631, 658, 3, 2, 2, 2, 632, 633, 12, 8, 2, 2, 633, 634, 7, 63,
	2, 2, 634, 635, 5, 112, 57, 2, 635, 636, 7, 42, 2, 2, 636, 637, 5, 42,
	22, 2, 637, 638, 7, 64, 2, 2, 638, 658, 3, 2, 2, 2, 639, 640, 12, 7, 2,
	2, 640, 642, 7, 63, 2, 2, 641, 643, 5, 112, 57, 2, 642, 641, 3, 2, 2, 2,
	642, 643, 3, 2, 2, 2, 643, 644, 3, 2, 2, 2, 644, 645, 7, 77, 2, 2, 645,
	658, 7, 64, 2, 2, 646, 647, 12, 6, 2, 2, 647, 648, 7, 61, 2, 2, 648, 649,
	5, 114, 58, 2, 649, 650, 7, 62, 2, 2, 650, 658, 3, 2, 2, 2, 651, 652, 12,
	5, 2, 2, 652, 654, 7, 61, 2, 2, 653, 655, 5, 120, 61, 2, 654, 653, 3, 2,
	2, 2, 654, 655, 3, 2, 2, 2, 655, 656, 3, 2, 2, 2, 656, 658, 7, 62, 2, 2,
	657, 614, 3, 2, 2, 2, 657, 623, 3, 2, 2, 2, 657, 632, 3, 2, 2, 2, 657,
	639, 3, 2, 2, 2, 657, 646, 3, 2, 2, 2, 657, 651, 3, 2, 2, 2, 658, 661,
	3, 2, 2, 2, 659, 657, 3, 2, 2, 2, 659, 660, 3, 2, 2, 2, 660, 99, 3, 2,
	2, 2, 661, 659, 3, 2, 2, 2, 662, 663, 7, 13, 2, 2, 663, 665, 7, 61, 2,
	2, 664, 666, 7, 110, 2, 2, 665, 664, 3, 2, 2, 2, 666, 667, 3, 2, 2, 2,
	667, 665, 3, 2, 2, 2, 667, 668, 3, 2, 2, 2, 668, 669, 3, 2, 2, 2, 669,
	672, 7, 62, 2, 2, 670, 672, 5, 102, 52, 2, 671, 662, 3, 2, 2, 2, 671, 670,
	3, 2, 2, 2, 672, 101, 3, 2, 2, 2, 673, 674, 7, 14, 2, 2, 674, 675, 7, 61,
	2, 2, 675, 676, 7, 61, 2, 2, 676, 677, 5, 104, 53, 2, 677, 678, 7, 62,
	2, 2, 678, 679, 7, 62, 2, 2, 679, 103, 3, 2, 2, 2, 680, 682, 5, 106, 54,
	2, 681, 680, 3, 2, 2, 2, 681, 682, 3, 2, 2, 2, 682, 689, 3, 2, 2, 2, 683,
	685, 7, 90, 2, 2, 684, 686, 5, 106, 54, 2, 685, 684, 3, 2, 2, 2, 685, 686,
	3, 2, 2, 2, 686, 688, 3, 2, 2, 2, 687, 683, 3, 2, 2, 2, 688, 691, 3, 2,
	2, 2, 689, 687, 3, 2, 2, 2, 689, 690, 3, 2, 2, 2, 690, 105, 3, 2, 2, 2,
	691, 689, 3, 2, 2, 2, 692, 698, 10, 19, 2, 2, 693, 695, 7, 61, 2, 2, 694,
	696, 5, 12, 7, 2, 695, 694, 3, 2, 2, 2, 695, 696, 3, 2, 2, 2, 696, 697,
	3, 2, 2, 2, 697, 699, 7, 62, 2, 2, 698, 693, 3, 2, 2, 2, 698, 699, 3, 2,
	2, 2, 699, 107, 3, 2, 2, 2, 700, 706, 10, 20, 2, 2, 701, 702, 7, 61, 2,
	2, 702, 703, 5, 108, 55, 2, 703, 704, 7, 62, 2, 2, 704, 706, 3, 2, 2, 2,
	705, 700, 3, 2, 2, 2, 705, 701, 3, 2, 2, 2, 706, 709, 3, 2, 2, 2, 707,
	705, 3, 2, 2, 2, 707, 708, 3, 2, 2, 2, 708, 109, 3, 2, 2, 2, 709, 707,
	3, 2, 2, 2, 710, 712, 9, 21, 2, 2, 711, 713, 5, 112, 57, 2, 712, 711, 3,
	2, 2, 2, 712, 713, 3, 2, 2, 2, 713, 715, 3, 2, 2, 2, 714, 710, 3, 2, 2,
	2, 715, 716, 3, 2, 2, 2, 716, 714, 3, 2, 2, 2, 716, 717, 3, 2, 2, 2, 717,
	111, 3, 2, 2, 2, 718, 720, 5, 90, 46, 2, 719, 718, 3, 2, 2, 2, 720, 721,
	3, 2, 2, 2, 721, 719, 3, 2, 2, 2, 721, 722, 3, 2, 2, 2, 722, 113, 3, 2,
	2, 2, 723, 726, 5, 116, 59, 2, 724, 725, 7, 90, 2, 2, 725, 727, 7, 106,
	2, 2, 726, 724, 3, 2, 2, 2, 726, 727, 3, 2, 2, 2, 727, 115, 3, 2, 2, 2,
	728, 733, 5, 118, 60, 2, 729, 730, 7, 90, 2, 2, 730, 732, 5, 118, 60, 2,
	731, 729, 3, 2, 2, 2, 732, 735, 3, 2, 2, 2, 733, 731, 3, 2, 2, 2, 733,
	734, 3, 2, 2, 2, 734, 117, 3, 2, 2, 2, 735, 733, 3, 2, 2, 2, 736, 737,
	5, 52, 27, 2, 737, 738, 5, 96, 49, 2, 738, 744, 3, 2, 2, 2, 739, 741, 5,
	54, 28, 2, 740, 742, 5, 124, 63, 2, 741, 740, 3, 2, 2, 2, 741, 742, 3,
	2, 2, 2, 742, 744, 3, 2, 2, 2, 743, 736, 3, 2, 2, 2, 743, 739, 3, 2, 2,
	2, 744, 119, 3, 2, 2, 2, 745, 750, 7, 107, 2, 2, 746, 747, 7, 90, 2, 2,
	747, 749, 7, 107, 2, 2, 748, 746, 3, 2, 2, 2, 749, 752, 3, 2, 2, 2, 750,
	748, 3, 2, 2, 2, 750, 751, 3, 2, 2, 2, 751, 121, 3, 2, 2, 2, 752, 750,
	3, 2, 2, 2, 753, 755, 5, 74, 38, 2, 754, 756, 5, 124, 63, 2, 755, 754,
	3, 2, 2, 2, 755, 756, 3, 2, 2, 2, 756, 123, 3, 2, 2, 2, 757, 769, 5, 110,
	56, 2, 758, 760, 5, 110, 56, 2, 759, 758, 3, 2, 2, 2, 759, 760, 3, 2, 2,
	2, 760, 761, 3, 2, 2, 2, 761, 765, 5, 126, 64, 2, 762, 764, 5, 100, 51,
	2, 763, 762, 3, 2, 2, 2, 764, 767, 3, 2, 2, 2, 765, 763, 3, 2, 2, 2, 765,
	766, 3, 2, 2, 2, 766, 769, 3, 2, 2, 2, 767, 765, 3, 2, 2, 2, 768, 757,
	3, 2, 2, 2, 768, 759, 3, 2, 2, 2, 769, 125, 3, 2, 2, 2, 770, 771, 8, 64,
	1, 2, 771, 772, 7, 61, 2, 2, 772, 773, 5, 124, 63, 2, 773, 777, 7, 62,
	2, 2, 774, 776, 5, 100, 51, 2, 775, 774, 3, 2, 2, 2, 776, 779, 3, 2, 2,
	2, 777, 775, 3, 2, 2, 2, 777, 778, 3, 2, 2, 2, 778, 817, 3, 2, 2, 2, 779,
	777, 3, 2, 2, 2, 780, 782, 7, 63, 2, 2, 781, 783, 5, 112, 57, 2, 782, 781,
	3, 2, 2, 2, 782, 783, 3, 2, 2, 2, 783, 785, 3, 2, 2, 2, 784, 786, 5, 42,
	22, 2, 785, 784, 3, 2, 2, 2, 785, 786, 3, 2, 2, 2, 786, 787, 3, 2, 2, 2,
	787, 817, 7, 64, 2, 2, 788, 789, 7, 63, 2, 2, 789, 791, 7, 42, 2, 2, 790,
	792, 5, 112, 57, 2, 791, 790, 3, 2, 2, 2, 791, 792, 3, 2, 2, 2, 792, 793,
	3, 2, 2, 2, 793, 794, 5, 42, 22, 2, 794, 795, 7, 64, 2, 2, 795, 817, 3,
	2, 2, 2, 796, 797, 7, 63, 2, 2, 797, 798, 5, 112, 57, 2, 798, 799, 7, 42,
	2, 2, 799, 800, 5, 42, 22, 2, 800, 801, 7, 64, 2, 2, 801, 817, 3, 2, 2,
	2, 802, 803, 7, 63, 2, 2, 803, 804, 7, 77, 2, 2, 804, 817, 7, 64, 2, 2,
	805, 807, 7, 61, 2, 2, 806, 808, 5, 114, 58, 2, 807, 806, 3, 2, 2, 2, 807,
	808, 3, 2, 2, 2, 808, 809, 3, 2, 2, 2, 809, 813, 7, 62, 2, 2, 810, 812,
	5, 100, 51, 2, 811, 810, 3, 2, 2, 2, 812, 815, 3, 2, 2, 2, 813, 811, 3,
	2, 2, 2, 813, 814, 3, 2, 2, 2, 814, 817, 3, 2, 2, 2, 815, 813, 3, 2, 2,
	2, 816, 770, 3, 2, 2, 2, 816, 780, 3, 2, 2, 2, 816, 788, 3, 2, 2, 2, 816,
	796, 3, 2, 2, 2, 816, 802, 3, 2, 2, 2, 816, 805, 3, 2, 2, 2, 817, 861,
	3, 2, 2, 2, 818, 819, 12, 7, 2, 2, 819, 821, 7, 63, 2, 2, 820, 822, 5,
	112, 57, 2, 821, 820, 3, 2, 2, 2, 821, 822, 3, 2, 2, 2, 822, 824, 3, 2,
	2, 2, 823, 825, 5, 42, 22, 2, 824, 823, 3, 2, 2, 2, 824, 825, 3, 2, 2,
	2, 825, 826, 3, 2, 2, 2, 826, 860, 7, 64, 2, 2, 827, 828, 12, 6, 2, 2,
	828, 829, 7, 63, 2, 2, 829, 831, 7, 42, 2, 2, 830, 832, 5, 112, 57, 2,
	831, 830, 3, 2, 2, 2, 831, 832, 3, 2, 2, 2, 832, 833, 3, 2, 2, 2, 833,
	834, 5, 42, 22, 2, 834, 835, 7, 64, 2, 2, 835, 860, 3, 2, 2, 2, 836, 837,
	12, 5, 2, 2, 837, 838, 7, 63, 2, 2, 838, 839, 5, 112, 57, 2, 839, 840,
	7, 42, 2, 2, 840, 841, 5, 42, 22, 2, 841, 842, 7, 64, 2, 2, 842, 860, 3,
	2, 2, 2, 843, 844, 12, 4, 2, 2, 844, 845, 7, 63, 2, 2, 845, 846, 7, 77,
	2, 2, 846, 860, 7, 64, 2, 2, 847, 848, 12, 3, 2, 2, 848, 850, 7, 61, 2,
	2, 849, 851, 5, 114, 58, 2, 850, 849, 3, 2, 2, 2, 850, 851, 3, 2, 2, 2,
	851, 852, 3, 2, 2, 2, 852, 856, 7, 62, 2, 2, 853, 855, 5, 100, 51, 2, 854,
	853, 3, 2, 2, 2, 855, 858, 3, 2, 2, 2, 856, 854, 3, 2, 2, 2, 856, 857,
	3, 2, 2, 2, 857, 860, 3, 2, 2, 2, 858, 856, 3, 2, 2, 2, 859, 818, 3, 2,
	2, 2, 859, 827, 3, 2, 2, 2, 859, 836, 3, 2, 2, 2, 859, 843, 3, 2, 2, 2,
	859, 847, 3, 2, 2, 2, 860, 863, 3, 2, 2, 2, 861, 859, 3, 2, 2, 2, 861,
	862, 3, 2, 2, 2, 862, 127, 3, 2, 2, 2, 863, 861, 3, 2, 2, 2, 864, 865,
	7, 107, 2, 2, 865, 129, 3, 2, 2, 2, 866, 875, 5, 42, 22, 2, 867, 868, 7,
	65, 2, 2, 868, 870, 5, 132, 67, 2, 869, 871, 7, 90, 2, 2, 870, 869, 3,
	2, 2, 2, 870, 871, 3, 2, 2, 2, 871, 872, 3, 2, 2, 2, 872, 873, 7, 66, 2,
	2, 873, 875, 3, 2, 2, 2, 874, 866, 3, 2, 2, 2, 874, 867, 3, 2, 2, 2, 875,
	131, 3, 2, 2, 2, 876, 878, 5, 134, 68, 2, 877, 876, 3, 2, 2, 2, 877, 878,
	3, 2, 2, 2, 878, 879, 3, 2, 2, 2, 879, 887, 5, 130, 66, 2, 880, 882, 7,
	90, 2, 2, 881, 883, 5, 134, 68, 2, 882, 881, 3, 2, 2, 2, 882, 883, 3, 2,
	2, 2, 883, 884, 3, 2, 2, 2, 884, 886, 5, 130, 66, 2, 885, 880, 3, 2, 2,
	2, 886, 889, 3, 2, 2, 2, 887, 885, 3, 2, 2, 2, 887, 888, 3, 2, 2, 2, 888,
	133, 3, 2, 2, 2, 889, 887, 3, 2, 2, 2, 890, 891, 5, 136, 69, 2, 891, 892,
	7, 91, 2, 2, 892, 135, 3, 2, 2, 2, 893, 895, 5, 138, 70, 2, 894, 893, 3,
	2, 2, 2, 895, 896, 3, 2, 2, 2, 896, 894, 3, 2, 2, 2, 896, 897, 3, 2, 2,
	2, 897, 137, 3, 2, 2, 2, 898, 899, 7, 63, 2, 2, 899, 900, 5, 48, 25, 2,
	900, 901, 7, 64, 2, 2, 901, 905, 3, 2, 2, 2, 902, 903, 7, 105, 2, 2, 903,
	905, 7, 107, 2, 2, 904, 898, 3, 2, 2, 2, 904, 902, 3, 2, 2, 2, 905, 139,
	3, 2, 2, 2, 906, 907, 7, 59, 2, 2, 907, 908, 7, 61, 2, 2, 908, 909, 5,
	48, 25, 2, 909, 911, 7, 90, 2, 2, 910, 912, 7, 110, 2, 2, 911, 910, 3,
	2, 2, 2, 912, 913, 3, 2, 2, 2, 913, 911, 3, 2, 2, 2, 913, 914, 3, 2, 2,
	2, 914, 915, 3, 2, 2, 2, 915, 916, 7, 62, 2, 2, 916, 917, 7, 89, 2, 2,
	917, 141, 3, 2, 2, 2, 918, 956, 5, 144, 73, 2, 919, 956, 5, 146, 74, 2,
	920, 956, 5, 152, 77, 2, 921, 956, 5, 154, 78, 2, 922, 956, 5, 156, 79,
	2, 923, 956, 5, 164, 83, 2, 924, 925, 9, 22, 2, 2, 925, 926, 9, 23, 2,
	2, 926, 935, 7, 61, 2, 2, 927, 932, 5, 38, 20, 2, 928, 929, 7, 90, 2, 2,
	929, 931, 5, 38, 20, 2, 930, 928, 3, 2, 2, 2, 931, 934, 3, 2, 2, 2, 932,
	930, 3, 2, 2, 2, 932, 933, 3, 2, 2, 2, 933, 936, 3, 2, 2, 2, 934, 932,
	3, 2, 2, 2, 935, 927, 3, 2, 2, 2, 935, 936, 3, 2, 2, 2, 936, 950, 3, 2,
	2, 2, 937, 946, 7, 88, 2, 2, 938, 943, 5, 38, 20, 2, 939, 940, 7, 90, 2,
	2, 940, 942, 5, 38, 20, 2, 941, 939, 3, 2, 2, 2, 942, 945, 3, 2, 2, 2,
	943, 941, 3, 2, 2, 2, 943, 944, 3, 2, 2, 2, 944, 947, 3, 2, 2, 2, 945,
	943, 3, 2, 2, 2, 946, 938, 3, 2, 2, 2, 946, 947, 3, 2, 2, 2, 947, 949,
	3, 2, 2, 2, 948, 937, 3, 2, 2, 2, 949, 952, 3, 2, 2, 2, 950, 948, 3, 2,
	2, 2, 950, 951, 3, 2, 2, 2, 951, 953, 3, 2, 2, 2, 952, 950, 3, 2, 2, 2,
	953, 954, 7, 62, 2, 2, 954, 956, 7, 89, 2, 2, 955, 918, 3, 2, 2, 2, 955,
	919, 3, 2, 2, 2, 955, 920, 3, 2, 2, 2, 955, 921, 3, 2, 2, 2, 955, 922,
	3, 2, 2, 2, 955, 923, 3, 2, 2, 2, 955, 924, 3, 2, 2, 2, 956, 143, 3, 2,
	2, 2, 957, 958, 7, 107, 2, 2, 958, 959, 7, 88, 2, 2, 959, 969, 5, 142,
	72, 2, 960, 961, 7, 19, 2, 2, 961, 962, 5, 48, 25, 2, 962, 963, 7, 88,
	2, 2, 963, 964, 5, 142, 72, 2, 964, 969, 3, 2, 2, 2, 965, 966, 7, 23, 2,
	2, 966, 967, 7, 88, 2, 2, 967, 969, 5, 142, 72, 2, 968, 957, 3, 2, 2, 2,
	968, 960, 3, 2, 2, 2, 968, 965, 3, 2, 2, 2, 969, 145, 3, 2, 2, 2, 970,
	972, 7, 65, 2, 2, 971, 973, 5, 148, 75, 2, 972, 971, 3, 2, 2, 2, 972, 973,
	3, 2, 2, 2, 973, 974, 3, 2, 2, 2, 974, 975, 7, 66, 2, 2, 975, 147, 3, 2,
	2, 2, 976, 978, 5, 150, 76, 2, 977, 976, 3, 2, 2, 2, 978, 979, 3, 2, 2,
	2, 979, 977, 3, 2, 2, 2, 979, 980, 3, 2, 2, 2, 980, 149, 3, 2, 2, 2, 981,
	984, 5, 142, 72, 2, 982, 984, 5, 50, 26, 2, 983, 981, 3, 2, 2, 2, 983,
	982, 3, 2, 2, 2, 984, 151, 3, 2, 2, 2, 985, 987, 5, 46, 24, 2, 986, 985,
	3, 2, 2, 2, 986, 987, 3, 2, 2, 2, 987, 988, 3, 2, 2, 2, 988, 989, 7, 89,
	2, 2, 989, 153, 3, 2, 2, 2, 990, 991, 7, 32, 2, 2, 991, 992, 7, 61, 2,
	2, 992, 993, 5, 46, 24, 2, 993, 994, 7, 62, 2, 2, 994, 997, 5, 142, 72,
	2, 995, 996, 7, 26, 2, 2, 996, 998, 5, 142, 72, 2, 997, 995, 3, 2, 2, 2,
	997, 998, 3, 2, 2, 2, 998, 1006, 3, 2, 2, 2, 999, 1000, 7, 44, 2, 2, 1000,
	1001, 7, 61, 2, 2, 1001, 1002, 5, 46, 24, 2, 1002, 1003, 7, 62, 2, 2, 1003,
	1004, 5, 142, 72, 2, 1004, 1006, 3, 2, 2, 2, 1005, 990, 3, 2, 2, 2, 1005,
	999, 3, 2, 2, 2, 1006, 155, 3, 2, 2, 2, 1007, 1008, 7, 50, 2, 2, 1008,
	1009, 7, 61, 2, 2, 1009, 1010, 5, 46, 24, 2, 1010, 1011, 7, 62, 2, 2, 1011,
	1012, 5, 142, 72, 2, 1012, 1028, 3, 2, 2, 2, 1013, 1014, 7, 24, 2, 2, 1014,
	1015, 5, 142, 72, 2, 1015, 1016, 7, 50, 2, 2, 1016, 1017, 7, 61, 2, 2,
	1017, 1018, 5, 46, 24, 2, 1018, 1019, 7, 62, 2, 2, 1019, 1020, 7, 89, 2,
	2, 1020, 1028, 3, 2, 2, 2, 1021, 1022, 7, 30, 2, 2, 1022, 1023, 7, 61,
	2, 2, 1023, 1024, 5, 158, 80, 2, 1024, 1025, 7, 62, 2, 2, 1025, 1026, 5,
	142, 72, 2, 1026, 1028, 3, 2, 2, 2, 1027, 1007, 3, 2, 2, 2, 1027, 1013,
	3, 2, 2, 2, 1027, 1021, 3, 2, 2, 2, 1028, 157, 3, 2, 2, 2, 1029, 1034,
	5, 160, 81, 2, 1030, 1032, 5, 46, 24, 2, 1031, 1030, 3, 2, 2, 2, 1031,
	1032, 3, 2, 2, 2, 1032, 1034, 3, 2, 2, 2, 1033, 1029, 3, 2, 2, 2, 1033,
	1031, 3, 2, 2, 2, 1034, 1035, 3, 2, 2, 2, 1035, 1037, 7, 89, 2, 2, 1036,
	1038, 5, 162, 82, 2, 1037, 1036, 3, 2, 2, 2, 1037, 1038, 3, 2, 2, 2, 1038,
	1039, 3, 2, 2, 2, 1039, 1041, 7, 89, 2, 2, 1040, 1042, 5, 162, 82, 2, 1041,
	1040, 3, 2, 2, 2, 1041, 1042, 3, 2, 2, 2, 1042, 159, 3, 2, 2, 2, 1043,
	1045, 5, 52, 27, 2, 1044, 1046, 5, 58, 30, 2, 1045, 1044, 3, 2, 2, 2, 1045,
	1046, 3, 2, 2, 2, 1046, 161, 3, 2, 2, 2, 1047, 1052, 5, 42, 22, 2, 1048,
	1049, 7, 90, 2, 2, 1049, 1051, 5, 42, 22, 2, 1050, 1048, 3, 2, 2, 2, 1051,
	1054, 3, 2, 2, 2, 1052, 1050, 3, 2, 2, 2, 1052, 1053, 3, 2, 2, 2, 1053,
	163, 3, 2, 2, 2, 1054, 1052, 3, 2, 2, 2, 1055, 1056, 7, 31, 2, 2, 1056,
	1065, 7, 107, 2, 2, 1057, 1065, 9, 24, 2, 2, 1058, 1060, 7, 38, 2, 2, 1059,
	1061, 5, 46, 24, 2, 1060, 1059, 3, 2, 2, 2, 1060, 1061, 3, 2, 2, 2, 1061,
	1065, 3, 2, 2, 2, 1062, 1063, 7, 31, 2, 2, 1063, 1065, 5, 14, 8, 2, 1064,
	1055, 3, 2, 2, 2, 1064, 1057, 3, 2, 2, 2, 1064, 1058, 3, 2, 2, 2, 1064,
	1062, 3, 2, 2, 2, 1065, 1066, 3, 2, 2, 2, 1066, 1067, 7, 89, 2, 2, 1067,
	165, 3, 2, 2, 2, 1068, 1070, 5, 168, 85, 2, 1069, 1068, 3, 2, 2, 2, 1069,
	1070, 3, 2, 2, 2, 1070, 1071, 3, 2, 2, 2, 1071, 1072, 7, 2, 2, 3, 1072,
	167, 3, 2, 2, 2, 1073, 1075, 5, 170, 86, 2, 1074, 1073, 3, 2, 2, 2, 1075,
	1076, 3, 2, 2, 2, 1076, 1074, 3, 2, 2, 2, 1076, 1077, 3, 2, 2, 2, 1077,
	169, 3, 2, 2, 2, 1078, 1082, 5, 172, 87, 2, 1079, 1082, 5, 50, 26, 2, 1080,
	1082, 7, 89, 2, 2, 1081, 1078, 3, 2, 2, 2, 1081, 1079, 3, 2, 2, 2, 1081,
	1080, 3, 2, 2, 2, 1082, 171, 3, 2, 2, 2, 1083, 1085, 5, 52, 27, 2, 1084,
	1083, 3, 2, 2, 2, 1084, 1085, 3, 2, 2, 2, 1085, 1086, 3, 2, 2, 2, 1086,
	1088, 5, 96, 49, 2, 1087, 1089, 5, 174, 88, 2, 1088, 1087, 3, 2, 2, 2,
	1088, 1089, 3, 2, 2, 2, 1089, 1090, 3, 2, 2, 2, 1090, 1091, 5, 146, 74,
	2, 1091, 173, 3, 2, 2, 2, 1092, 1094, 5, 50, 26, 2, 1093, 1092, 3, 2, 2,
	2, 1094, 1095, 3, 2, 2, 2, 1095, 1093, 3, 2, 2, 2, 1095, 1096, 3, 2, 2,
	2, 1096, 175, 3, 2, 2, 2, 139, 181, 189, 209, 223, 228, 235, 243, 247,
	255, 261, 263, 271, 277, 291, 296, 305, 312, 320, 328, 336, 344, 352, 360,
	368, 376, 384, 393, 401, 410, 417, 422, 427, 432, 439, 446, 452, 471, 477,
	482, 491, 498, 502, 507, 511, 514, 521, 526, 530, 534, 539, 545, 552, 558,
	575, 581, 586, 592, 606, 612, 617, 620, 627, 642, 654, 657, 659, 667, 671,
	681, 685, 689, 695, 698, 705, 707, 712, 716, 721, 726, 733, 741, 743, 750,
	755, 759, 765, 768, 777, 782, 785, 791, 807, 813, 816, 821, 824, 831, 850,
	856, 859, 861, 870, 874, 877, 882, 887, 896, 904, 913, 932, 935, 943, 946,
	950, 955, 968, 972, 979, 983, 986, 997, 1005, 1027, 1031, 1033, 1037, 1041,
	1045, 1052, 1060, 1064, 1069, 1076, 1081, 1084, 1088, 1095,
}
var literalNames = []string{
	"", "'__extension__'", "'__builtin_va_arg'", "'__builtin_offsetof'", "'__m128'",
	"'__m128d'", "'__m128i'", "'__typeof__'", "'__inline__'", "'__stdcall'",
	"'__declspec'", "'__asm'", "'__attribute__'", "'__asm__'", "'__volatile__'",
	"'auto'", "'break'", "'case'", "'char'", "'const'", "'continue'", "'default'",
	"'do'", "'double'", "'else'", "'enum'", "'extern'", "'float'", "'for'",
	"'goto'", "'if'", "'inline'", "'int'", "'long'", "'register'", "'restrict'",
	"'return'", "'short'", "'signed'", "'sizeof'", "'static'", "'struct'",
	"'switch'", "'typedef'", "'union'", "'unsigned'", "'void'", "'volatile'",
	"'while'", "'_Alignas'", "'_Alignof'", "'_Atomic'", "'_Bool'", "'_Complex'",
	"'_Generic'", "'_Imaginary'", "'_Noreturn'", "'_Static_assert'", "'_Thread_local'",
	"'('", "')'", "'['", "']'", "'{'", "'}'", "'<'", "'<='", "'>'", "'>='",
	"'<<'", "'>>'", "'+'", "'++'", "'-'", "'--'", "'*'", "'/'", "'%'", "'&'",
	"'|'", "'&&'", "'||'", "'^'", "'!'", "'~'", "'?'", "':'", "';'", "','",
	"'='", "'*='", "'/='", "'%='", "'+='", "'-='", "'<<='", "'>>='", "'&='",
	"'^='", "'|='", "'=='", "'!='", "'->'", "'.'", "'...'",
}
var symbolicNames = []string{
	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "Auto", "Break",
	"Case", "Char", "Const", "Continue", "Default", "Do", "Double", "Else",
	"Enum", "Extern", "Float", "For", "Goto", "If", "Inline", "Int", "Long",
	"Register", "Restrict", "Return", "Short", "Signed", "Sizeof", "Static",
	"Struct", "Switch", "Typedef", "Union", "Unsigned", "Void", "Volatile",
	"While", "Alignas", "Alignof", "Atomic", "Bool", "Complex", "Generic",
	"Imaginary", "Noreturn", "StaticAssert", "ThreadLocal", "LeftParen", "RightParen",
	"LeftBracket", "RightBracket", "LeftBrace", "RightBrace", "Less", "LessEqual",
	"Greater", "GreaterEqual", "LeftShift", "RightShift", "Plus", "PlusPlus",
	"Minus", "MinusMinus", "Star", "Div", "Mod", "And", "Or", "AndAnd", "OrOr",
	"Caret", "Not", "Tilde", "Question", "Colon", "Semi", "Comma", "Assign",
	"StarAssign", "DivAssign", "ModAssign", "PlusAssign", "MinusAssign", "LeftShiftAssign",
	"RightShiftAssign", "AndAssign", "XorAssign", "OrAssign", "Equal", "NotEqual",
	"Arrow", "Dot", "Ellipsis", "Identifier", "Constant", "DigitSequence",
	"StringLiteral", "ComplexDefine", "IncludeDirective", "AsmBlock", "LineAfterPreprocessing",
	"LineDirective", "PragmaDirective", "Whitespace", "Newline", "BlockComment",
	"LineComment",
}

var ruleNames = []string{
	"primaryExpression", "genericSelection", "genericAssocList", "genericAssociation",
	"postfixExpression", "argumentExpressionList", "unaryExpression", "unaryOperator",
	"castExpression", "multiplicativeExpression", "additiveExpression", "shiftExpression",
	"relationalExpression", "equalityExpression", "andExpression", "exclusiveOrExpression",
	"inclusiveOrExpression", "logicalAndExpression", "logicalOrExpression",
	"conditionalExpression", "assignmentExpression", "assignmentOperator",
	"expression", "constantExpression", "declaration", "declarationSpecifiers",
	"declarationSpecifiers2", "declarationSpecifier", "initDeclaratorList",
	"initDeclarator", "storageClassSpecifier", "typeSpecifier", "structOrUnionSpecifier",
	"structOrUnion", "structDeclarationList", "structDeclaration", "specifierQualifierList",
	"structDeclaratorList", "structDeclarator", "enumSpecifier", "enumeratorList",
	"enumerator", "enumerationConstant", "atomicTypeSpecifier", "typeQualifier",
	"functionSpecifier", "alignmentSpecifier", "declarator", "directDeclarator",
	"gccDeclaratorExtension", "gccAttributeSpecifier", "gccAttributeList",
	"gccAttribute", "nestedParenthesesBlock", "pointer", "typeQualifierList",
	"parameterTypeList", "parameterList", "parameterDeclaration", "identifierList",
	"typeName", "abstractDeclarator", "directAbstractDeclarator", "typedefName",
	"initializer", "initializerList", "designation", "designatorList", "designator",
	"staticAssertDeclaration", "statement", "labeledStatement", "compoundStatement",
	"blockItemList", "blockItem", "expressionStatement", "selectionStatement",
	"iterationStatement", "forCondition", "forDeclaration", "forExpression",
	"jumpStatement", "compilationUnit", "translationUnit", "externalDeclaration",
	"functionDefinition", "declarationList",
}

type CParser struct {
	*antlr.BaseParser
}

// NewCParser produces a new parser instance for the optional input antlr.TokenStream.
//
// The *CParser 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 NewCParser(input antlr.TokenStream) *CParser {
	this := new(CParser)
	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 = "C.g4"

	return this
}

// CParser tokens.
const (
	CParserEOF                    = antlr.TokenEOF
	CParserT__0                   = 1
	CParserT__1                   = 2
	CParserT__2                   = 3
	CParserT__3                   = 4
	CParserT__4                   = 5
	CParserT__5                   = 6
	CParserT__6                   = 7
	CParserT__7                   = 8
	CParserT__8                   = 9
	CParserT__9                   = 10
	CParserT__10                  = 11
	CParserT__11                  = 12
	CParserT__12                  = 13
	CParserT__13                  = 14
	CParserAuto                   = 15
	CParserBreak                  = 16
	CParserCase                   = 17
	CParserChar                   = 18
	CParserConst                  = 19
	CParserContinue               = 20
	CParserDefault                = 21
	CParserDo                     = 22
	CParserDouble                 = 23
	CParserElse                   = 24
	CParserEnum                   = 25
	CParserExtern                 = 26
	CParserFloat                  = 27
	CParserFor                    = 28
	CParserGoto                   = 29
	CParserIf                     = 30
	CParserInline                 = 31
	CParserInt                    = 32
	CParserLong                   = 33
	CParserRegister               = 34
	CParserRestrict               = 35
	CParserReturn                 = 36
	CParserShort                  = 37
	CParserSigned                 = 38
	CParserSizeof                 = 39
	CParserStatic                 = 40
	CParserStruct                 = 41
	CParserSwitch                 = 42
	CParserTypedef                = 43
	CParserUnion                  = 44
	CParserUnsigned               = 45
	CParserVoid                   = 46
	CParserVolatile               = 47
	CParserWhile                  = 48
	CParserAlignas                = 49
	CParserAlignof                = 50
	CParserAtomic                 = 51
	CParserBool                   = 52
	CParserComplex                = 53
	CParserGeneric                = 54
	CParserImaginary              = 55
	CParserNoreturn               = 56
	CParserStaticAssert           = 57
	CParserThreadLocal            = 58
	CParserLeftParen              = 59
	CParserRightParen             = 60
	CParserLeftBracket            = 61
	CParserRightBracket           = 62
	CParserLeftBrace              = 63
	CParserRightBrace             = 64
	CParserLess                   = 65
	CParserLessEqual              = 66
	CParserGreater                = 67
	CParserGreaterEqual           = 68
	CParserLeftShift              = 69
	CParserRightShift             = 70
	CParserPlus                   = 71
	CParserPlusPlus               = 72
	CParserMinus                  = 73
	CParserMinusMinus             = 74
	CParserStar                   = 75
	CParserDiv                    = 76
	CParserMod                    = 77
	CParserAnd                    = 78
	CParserOr                     = 79
	CParserAndAnd                 = 80
	CParserOrOr                   = 81
	CParserCaret                  = 82
	CParserNot                    = 83
	CParserTilde                  = 84
	CParserQuestion               = 85
	CParserColon                  = 86
	CParserSemi                   = 87
	CParserComma                  = 88
	CParserAssign                 = 89
	CParserStarAssign             = 90
	CParserDivAssign              = 91
	CParserModAssign              = 92
	CParserPlusAssign             = 93
	CParserMinusAssign            = 94
	CParserLeftShiftAssign        = 95
	CParserRightShiftAssign       = 96
	CParserAndAssign              = 97
	CParserXorAssign              = 98
	CParserOrAssign               = 99
	CParserEqual                  = 100
	CParserNotEqual               = 101
	CParserArrow                  = 102
	CParserDot                    = 103
	CParserEllipsis               = 104
	CParserIdentifier             = 105
	CParserConstant               = 106
	CParserDigitSequence          = 107
	CParserStringLiteral          = 108
	CParserComplexDefine          = 109
	CParserIncludeDirective       = 110
	CParserAsmBlock               = 111
	CParserLineAfterPreprocessing = 112
	CParserLineDirective          = 113
	CParserPragmaDirective        = 114
	CParserWhitespace             = 115
	CParserNewline                = 116
	CParserBlockComment           = 117
	CParserLineComment            = 118
)

// CParser rules.
const (
	CParserRULE_primaryExpression        = 0
	CParserRULE_genericSelection         = 1
	CParserRULE_genericAssocList         = 2
	CParserRULE_genericAssociation       = 3
	CParserRULE_postfixExpression        = 4
	CParserRULE_argumentExpressionList   = 5
	CParserRULE_unaryExpression          = 6
	CParserRULE_unaryOperator            = 7
	CParserRULE_castExpression           = 8
	CParserRULE_multiplicativeExpression = 9
	CParserRULE_additiveExpression       = 10
	CParserRULE_shiftExpression          = 11
	CParserRULE_relationalExpression     = 12
	CParserRULE_equalityExpression       = 13
	CParserRULE_andExpression            = 14
	CParserRULE_exclusiveOrExpression    = 15
	CParserRULE_inclusiveOrExpression    = 16
	CParserRULE_logicalAndExpression     = 17
	CParserRULE_logicalOrExpression      = 18
	CParserRULE_conditionalExpression    = 19
	CParserRULE_assignmentExpression     = 20
	CParserRULE_assignmentOperator       = 21
	CParserRULE_expression               = 22
	CParserRULE_constantExpression       = 23
	CParserRULE_declaration              = 24
	CParserRULE_declarationSpecifiers    = 25
	CParserRULE_declarationSpecifiers2   = 26
	CParserRULE_declarationSpecifier     = 27
	CParserRULE_initDeclaratorList       = 28
	CParserRULE_initDeclarator           = 29
	CParserRULE_storageClassSpecifier    = 30
	CParserRULE_typeSpecifier            = 31
	CParserRULE_structOrUnionSpecifier   = 32
	CParserRULE_structOrUnion            = 33
	CParserRULE_structDeclarationList    = 34
	CParserRULE_structDeclaration        = 35
	CParserRULE_specifierQualifierList   = 36
	CParserRULE_structDeclaratorList     = 37
	CParserRULE_structDeclarator         = 38
	CParserRULE_enumSpecifier            = 39
	CParserRULE_enumeratorList           = 40
	CParserRULE_enumerator               = 41
	CParserRULE_enumerationConstant      = 42
	CParserRULE_atomicTypeSpecifier      = 43
	CParserRULE_typeQualifier            = 44
	CParserRULE_functionSpecifier        = 45
	CParserRULE_alignmentSpecifier       = 46
	CParserRULE_declarator               = 47
	CParserRULE_directDeclarator         = 48
	CParserRULE_gccDeclaratorExtension   = 49
	CParserRULE_gccAttributeSpecifier    = 50
	CParserRULE_gccAttributeList         = 51
	CParserRULE_gccAttribute             = 52
	CParserRULE_nestedParenthesesBlock   = 53
	CParserRULE_pointer                  = 54
	CParserRULE_typeQualifierList        = 55
	CParserRULE_parameterTypeList        = 56
	CParserRULE_parameterList            = 57
	CParserRULE_parameterDeclaration     = 58
	CParserRULE_identifierList           = 59
	CParserRULE_typeName                 = 60
	CParserRULE_abstractDeclarator       = 61
	CParserRULE_directAbstractDeclarator = 62
	CParserRULE_typedefName              = 63
	CParserRULE_initializer              = 64
	CParserRULE_initializerList          = 65
	CParserRULE_designation              = 66
	CParserRULE_designatorList           = 67
	CParserRULE_designator               = 68
	CParserRULE_staticAssertDeclaration  = 69
	CParserRULE_statement                = 70
	CParserRULE_labeledStatement         = 71
	CParserRULE_compoundStatement        = 72
	CParserRULE_blockItemList            = 73
	CParserRULE_blockItem                = 74
	CParserRULE_expressionStatement      = 75
	CParserRULE_selectionStatement       = 76
	CParserRULE_iterationStatement       = 77
	CParserRULE_forCondition             = 78
	CParserRULE_forDeclaration           = 79
	CParserRULE_forExpression            = 80
	CParserRULE_jumpStatement            = 81
	CParserRULE_compilationUnit          = 82
	CParserRULE_translationUnit          = 83
	CParserRULE_externalDeclaration      = 84
	CParserRULE_functionDefinition       = 85
	CParserRULE_declarationList          = 86
)

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

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

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

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

func NewEmptyPrimaryExpressionContext() *PrimaryExpressionContext {
	var p = new(PrimaryExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_primaryExpression
	return p
}

func (*PrimaryExpressionContext) IsPrimaryExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_primaryExpression

	return p
}

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

func (s *PrimaryExpressionContext) Identifier() antlr.TerminalNode {
	return s.GetToken(CParserIdentifier, 0)
}

func (s *PrimaryExpressionContext) Constant() antlr.TerminalNode {
	return s.GetToken(CParserConstant, 0)
}

func (s *PrimaryExpressionContext) AllStringLiteral() []antlr.TerminalNode {
	return s.GetTokens(CParserStringLiteral)
}

func (s *PrimaryExpressionContext) StringLiteral(i int) antlr.TerminalNode {
	return s.GetToken(CParserStringLiteral, i)
}

func (s *PrimaryExpressionContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *PrimaryExpressionContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

func (s *PrimaryExpressionContext) GenericSelection() IGenericSelectionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGenericSelectionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGenericSelectionContext)
}

func (s *PrimaryExpressionContext) CompoundStatement() ICompoundStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompoundStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICompoundStatementContext)
}

func (s *PrimaryExpressionContext) UnaryExpression() IUnaryExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryExpressionContext)
}

func (s *PrimaryExpressionContext) Comma() antlr.TerminalNode {
	return s.GetToken(CParserComma, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

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

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

func (s *PrimaryExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterPrimaryExpression(s)
	}
}

func (s *PrimaryExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitPrimaryExpression(s)
	}
}

func (p *CParser) PrimaryExpression() (localctx IPrimaryExpressionContext) {
	this := p
	_ = this

	localctx = NewPrimaryExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 0, CParserRULE_primaryExpression)
	var _la int

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(175)
			p.Match(CParserConstant)
		}

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

		for ok := true; ok; ok = _la == CParserStringLiteral {
			{
				p.SetState(176)
				p.Match(CParserStringLiteral)
			}

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

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(181)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(182)
			p.Expression()
		}
		{
			p.SetState(183)
			p.Match(CParserRightParen)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(185)
			p.GenericSelection()
		}

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

		if _la == CParserT__0 {
			{
				p.SetState(186)
				p.Match(CParserT__0)
			}

		}
		{
			p.SetState(189)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(190)
			p.CompoundStatement()
		}
		{
			p.SetState(191)
			p.Match(CParserRightParen)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(193)
			p.Match(CParserT__1)
		}
		{
			p.SetState(194)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(195)
			p.UnaryExpression()
		}
		{
			p.SetState(196)
			p.Match(CParserComma)
		}
		{
			p.SetState(197)
			p.TypeName()
		}
		{
			p.SetState(198)
			p.Match(CParserRightParen)
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(200)
			p.Match(CParserT__2)
		}
		{
			p.SetState(201)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(202)
			p.TypeName()
		}
		{
			p.SetState(203)
			p.Match(CParserComma)
		}
		{
			p.SetState(204)
			p.UnaryExpression()
		}
		{
			p.SetState(205)
			p.Match(CParserRightParen)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyGenericSelectionContext() *GenericSelectionContext {
	var p = new(GenericSelectionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_genericSelection
	return p
}

func (*GenericSelectionContext) IsGenericSelectionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_genericSelection

	return p
}

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

func (s *GenericSelectionContext) Generic() antlr.TerminalNode {
	return s.GetToken(CParserGeneric, 0)
}

func (s *GenericSelectionContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

func (s *GenericSelectionContext) AssignmentExpression() IAssignmentExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentExpressionContext)
}

func (s *GenericSelectionContext) Comma() antlr.TerminalNode {
	return s.GetToken(CParserComma, 0)
}

func (s *GenericSelectionContext) GenericAssocList() IGenericAssocListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGenericAssocListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGenericAssocListContext)
}

func (s *GenericSelectionContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

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

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

func (s *GenericSelectionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterGenericSelection(s)
	}
}

func (s *GenericSelectionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitGenericSelection(s)
	}
}

func (p *CParser) GenericSelection() (localctx IGenericSelectionContext) {
	this := p
	_ = this

	localctx = NewGenericSelectionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 2, CParserRULE_genericSelection)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(209)
		p.Match(CParserGeneric)
	}
	{
		p.SetState(210)
		p.Match(CParserLeftParen)
	}
	{
		p.SetState(211)
		p.AssignmentExpression()
	}
	{
		p.SetState(212)
		p.Match(CParserComma)
	}
	{
		p.SetState(213)
		p.GenericAssocList()
	}
	{
		p.SetState(214)
		p.Match(CParserRightParen)
	}

	return localctx
}

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

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

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

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

func NewEmptyGenericAssocListContext() *GenericAssocListContext {
	var p = new(GenericAssocListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_genericAssocList
	return p
}

func (*GenericAssocListContext) IsGenericAssocListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_genericAssocList

	return p
}

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

func (s *GenericAssocListContext) AllGenericAssociation() []IGenericAssociationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IGenericAssociationContext)(nil)).Elem())
	var tst = make([]IGenericAssociationContext, len(ts))

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

	return tst
}

func (s *GenericAssocListContext) GenericAssociation(i int) IGenericAssociationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGenericAssociationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IGenericAssociationContext)
}

func (s *GenericAssocListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(CParserComma)
}

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

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

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

func (s *GenericAssocListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterGenericAssocList(s)
	}
}

func (s *GenericAssocListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitGenericAssocList(s)
	}
}

func (p *CParser) GenericAssocList() (localctx IGenericAssocListContext) {
	this := p
	_ = this

	localctx = NewGenericAssocListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, CParserRULE_genericAssocList)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(216)
		p.GenericAssociation()
	}
	p.SetState(221)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserComma {
		{
			p.SetState(217)
			p.Match(CParserComma)
		}
		{
			p.SetState(218)
			p.GenericAssociation()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyGenericAssociationContext() *GenericAssociationContext {
	var p = new(GenericAssociationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_genericAssociation
	return p
}

func (*GenericAssociationContext) IsGenericAssociationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_genericAssociation

	return p
}

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

func (s *GenericAssociationContext) Colon() antlr.TerminalNode {
	return s.GetToken(CParserColon, 0)
}

func (s *GenericAssociationContext) AssignmentExpression() IAssignmentExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentExpressionContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *GenericAssociationContext) Default() antlr.TerminalNode {
	return s.GetToken(CParserDefault, 0)
}

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

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

func (s *GenericAssociationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterGenericAssociation(s)
	}
}

func (s *GenericAssociationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitGenericAssociation(s)
	}
}

func (p *CParser) GenericAssociation() (localctx IGenericAssociationContext) {
	this := p
	_ = this

	localctx = NewGenericAssociationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 6, CParserRULE_genericAssociation)

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

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

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

	switch p.GetTokenStream().LA(1) {
	case CParserT__0, CParserT__3, CParserT__4, CParserT__5, CParserT__6, CParserChar, CParserConst, CParserDouble, CParserEnum, CParserFloat, CParserInt, CParserLong, CParserRestrict, CParserShort, CParserSigned, CParserStruct, CParserUnion, CParserUnsigned, CParserVoid, CParserVolatile, CParserAtomic, CParserBool, CParserComplex, CParserIdentifier:
		{
			p.SetState(224)
			p.TypeName()
		}

	case CParserDefault:
		{
			p.SetState(225)
			p.Match(CParserDefault)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(228)
		p.Match(CParserColon)
	}
	{
		p.SetState(229)
		p.AssignmentExpression()
	}

	return localctx
}

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

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

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

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

func NewEmptyPostfixExpressionContext() *PostfixExpressionContext {
	var p = new(PostfixExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_postfixExpression
	return p
}

func (*PostfixExpressionContext) IsPostfixExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_postfixExpression

	return p
}

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

func (s *PostfixExpressionContext) PrimaryExpression() IPrimaryExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryExpressionContext)
}

func (s *PostfixExpressionContext) AllLeftParen() []antlr.TerminalNode {
	return s.GetTokens(CParserLeftParen)
}

func (s *PostfixExpressionContext) LeftParen(i int) antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, i)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *PostfixExpressionContext) AllRightParen() []antlr.TerminalNode {
	return s.GetTokens(CParserRightParen)
}

func (s *PostfixExpressionContext) RightParen(i int) antlr.TerminalNode {
	return s.GetToken(CParserRightParen, i)
}

func (s *PostfixExpressionContext) LeftBrace() antlr.TerminalNode {
	return s.GetToken(CParserLeftBrace, 0)
}

func (s *PostfixExpressionContext) InitializerList() IInitializerListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitializerListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInitializerListContext)
}

func (s *PostfixExpressionContext) RightBrace() antlr.TerminalNode {
	return s.GetToken(CParserRightBrace, 0)
}

func (s *PostfixExpressionContext) AllLeftBracket() []antlr.TerminalNode {
	return s.GetTokens(CParserLeftBracket)
}

func (s *PostfixExpressionContext) LeftBracket(i int) antlr.TerminalNode {
	return s.GetToken(CParserLeftBracket, i)
}

func (s *PostfixExpressionContext) AllExpression() []IExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem())
	var tst = make([]IExpressionContext, len(ts))

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

	return tst
}

func (s *PostfixExpressionContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *PostfixExpressionContext) AllRightBracket() []antlr.TerminalNode {
	return s.GetTokens(CParserRightBracket)
}

func (s *PostfixExpressionContext) RightBracket(i int) antlr.TerminalNode {
	return s.GetToken(CParserRightBracket, i)
}

func (s *PostfixExpressionContext) AllIdentifier() []antlr.TerminalNode {
	return s.GetTokens(CParserIdentifier)
}

func (s *PostfixExpressionContext) Identifier(i int) antlr.TerminalNode {
	return s.GetToken(CParserIdentifier, i)
}

func (s *PostfixExpressionContext) AllDot() []antlr.TerminalNode {
	return s.GetTokens(CParserDot)
}

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

func (s *PostfixExpressionContext) AllArrow() []antlr.TerminalNode {
	return s.GetTokens(CParserArrow)
}

func (s *PostfixExpressionContext) Arrow(i int) antlr.TerminalNode {
	return s.GetToken(CParserArrow, i)
}

func (s *PostfixExpressionContext) AllPlusPlus() []antlr.TerminalNode {
	return s.GetTokens(CParserPlusPlus)
}

func (s *PostfixExpressionContext) PlusPlus(i int) antlr.TerminalNode {
	return s.GetToken(CParserPlusPlus, i)
}

func (s *PostfixExpressionContext) AllMinusMinus() []antlr.TerminalNode {
	return s.GetTokens(CParserMinusMinus)
}

func (s *PostfixExpressionContext) MinusMinus(i int) antlr.TerminalNode {
	return s.GetToken(CParserMinusMinus, i)
}

func (s *PostfixExpressionContext) Comma() antlr.TerminalNode {
	return s.GetToken(CParserComma, 0)
}

func (s *PostfixExpressionContext) AllArgumentExpressionList() []IArgumentExpressionListContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IArgumentExpressionListContext)(nil)).Elem())
	var tst = make([]IArgumentExpressionListContext, len(ts))

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

	return tst
}

func (s *PostfixExpressionContext) ArgumentExpressionList(i int) IArgumentExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentExpressionListContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IArgumentExpressionListContext)
}

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

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

func (s *PostfixExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterPostfixExpression(s)
	}
}

func (s *PostfixExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitPostfixExpression(s)
	}
}

func (p *CParser) PostfixExpression() (localctx IPostfixExpressionContext) {
	this := p
	_ = this

	localctx = NewPostfixExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 8, CParserRULE_postfixExpression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	p.SetState(245)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(231)
			p.PrimaryExpression()
		}

	case 2:
		p.SetState(233)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == CParserT__0 {
			{
				p.SetState(232)
				p.Match(CParserT__0)
			}

		}
		{
			p.SetState(235)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(236)
			p.TypeName()
		}
		{
			p.SetState(237)
			p.Match(CParserRightParen)
		}
		{
			p.SetState(238)
			p.Match(CParserLeftBrace)
		}
		{
			p.SetState(239)
			p.InitializerList()
		}
		p.SetState(241)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == CParserComma {
			{
				p.SetState(240)
				p.Match(CParserComma)
			}

		}
		{
			p.SetState(243)
			p.Match(CParserRightBrace)
		}

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

	for (((_la-59)&-(0x1f+1)) == 0 && ((1<<uint((_la-59)))&((1<<(CParserLeftParen-59))|(1<<(CParserLeftBracket-59))|(1<<(CParserPlusPlus-59))|(1<<(CParserMinusMinus-59)))) != 0) || _la == CParserArrow || _la == CParserDot {
		p.SetState(259)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case CParserLeftBracket:
			{
				p.SetState(247)
				p.Match(CParserLeftBracket)
			}
			{
				p.SetState(248)
				p.Expression()
			}
			{
				p.SetState(249)
				p.Match(CParserRightBracket)
			}

		case CParserLeftParen:
			{
				p.SetState(251)
				p.Match(CParserLeftParen)
			}
			p.SetState(253)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2))) != 0) || (((_la-39)&-(0x1f+1)) == 0 && ((1<<uint((_la-39)))&((1<<(CParserSizeof-39))|(1<<(CParserAlignof-39))|(1<<(CParserGeneric-39))|(1<<(CParserLeftParen-39)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserPlusPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserMinusMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserAndAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71)))) != 0) || (((_la-105)&-(0x1f+1)) == 0 && ((1<<uint((_la-105)))&((1<<(CParserIdentifier-105))|(1<<(CParserConstant-105))|(1<<(CParserDigitSequence-105))|(1<<(CParserStringLiteral-105)))) != 0) {
				{
					p.SetState(252)
					p.ArgumentExpressionList()
				}

			}
			{
				p.SetState(255)
				p.Match(CParserRightParen)
			}

		case CParserArrow, CParserDot:
			{
				p.SetState(256)
				_la = p.GetTokenStream().LA(1)

				if !(_la == CParserArrow || _la == CParserDot) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(257)
				p.Match(CParserIdentifier)
			}

		case CParserPlusPlus, CParserMinusMinus:
			{
				p.SetState(258)
				_la = p.GetTokenStream().LA(1)

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

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

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

	return localctx
}

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

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

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

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

func NewEmptyArgumentExpressionListContext() *ArgumentExpressionListContext {
	var p = new(ArgumentExpressionListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_argumentExpressionList
	return p
}

func (*ArgumentExpressionListContext) IsArgumentExpressionListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_argumentExpressionList

	return p
}

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

func (s *ArgumentExpressionListContext) AllAssignmentExpression() []IAssignmentExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAssignmentExpressionContext)(nil)).Elem())
	var tst = make([]IAssignmentExpressionContext, len(ts))

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

	return tst
}

func (s *ArgumentExpressionListContext) AssignmentExpression(i int) IAssignmentExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAssignmentExpressionContext)
}

func (s *ArgumentExpressionListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(CParserComma)
}

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

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

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

func (s *ArgumentExpressionListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterArgumentExpressionList(s)
	}
}

func (s *ArgumentExpressionListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitArgumentExpressionList(s)
	}
}

func (p *CParser) ArgumentExpressionList() (localctx IArgumentExpressionListContext) {
	this := p
	_ = this

	localctx = NewArgumentExpressionListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 10, CParserRULE_argumentExpressionList)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(264)
		p.AssignmentExpression()
	}
	p.SetState(269)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserComma {
		{
			p.SetState(265)
			p.Match(CParserComma)
		}
		{
			p.SetState(266)
			p.AssignmentExpression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyUnaryExpressionContext() *UnaryExpressionContext {
	var p = new(UnaryExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_unaryExpression
	return p
}

func (*UnaryExpressionContext) IsUnaryExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_unaryExpression

	return p
}

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

func (s *UnaryExpressionContext) PostfixExpression() IPostfixExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPostfixExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPostfixExpressionContext)
}

func (s *UnaryExpressionContext) UnaryOperator() IUnaryOperatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryOperatorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryOperatorContext)
}

func (s *UnaryExpressionContext) CastExpression() ICastExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICastExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICastExpressionContext)
}

func (s *UnaryExpressionContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *UnaryExpressionContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

func (s *UnaryExpressionContext) AndAnd() antlr.TerminalNode {
	return s.GetToken(CParserAndAnd, 0)
}

func (s *UnaryExpressionContext) Identifier() antlr.TerminalNode {
	return s.GetToken(CParserIdentifier, 0)
}

func (s *UnaryExpressionContext) AllSizeof() []antlr.TerminalNode {
	return s.GetTokens(CParserSizeof)
}

func (s *UnaryExpressionContext) Sizeof(i int) antlr.TerminalNode {
	return s.GetToken(CParserSizeof, i)
}

func (s *UnaryExpressionContext) Alignof() antlr.TerminalNode {
	return s.GetToken(CParserAlignof, 0)
}

func (s *UnaryExpressionContext) AllPlusPlus() []antlr.TerminalNode {
	return s.GetTokens(CParserPlusPlus)
}

func (s *UnaryExpressionContext) PlusPlus(i int) antlr.TerminalNode {
	return s.GetToken(CParserPlusPlus, i)
}

func (s *UnaryExpressionContext) AllMinusMinus() []antlr.TerminalNode {
	return s.GetTokens(CParserMinusMinus)
}

func (s *UnaryExpressionContext) MinusMinus(i int) antlr.TerminalNode {
	return s.GetToken(CParserMinusMinus, i)
}

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

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

func (s *UnaryExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterUnaryExpression(s)
	}
}

func (s *UnaryExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitUnaryExpression(s)
	}
}

func (p *CParser) UnaryExpression() (localctx IUnaryExpressionContext) {
	this := p
	_ = this

	localctx = NewUnaryExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 12, CParserRULE_unaryExpression)
	var _la int

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

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

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

				if !(_la == CParserSizeof || _la == CParserPlusPlus || _la == CParserMinusMinus) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}

		}
		p.SetState(277)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 12, p.GetParserRuleContext())
	}
	p.SetState(289)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CParserT__0, CParserT__1, CParserT__2, CParserGeneric, CParserLeftParen, CParserIdentifier, CParserConstant, CParserStringLiteral:
		{
			p.SetState(278)
			p.PostfixExpression()
		}

	case CParserPlus, CParserMinus, CParserStar, CParserAnd, CParserNot, CParserTilde:
		{
			p.SetState(279)
			p.UnaryOperator()
		}
		{
			p.SetState(280)
			p.CastExpression()
		}

	case CParserSizeof, CParserAlignof:
		{
			p.SetState(282)
			_la = p.GetTokenStream().LA(1)

			if !(_la == CParserSizeof || _la == CParserAlignof) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(283)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(284)
			p.TypeName()
		}
		{
			p.SetState(285)
			p.Match(CParserRightParen)
		}

	case CParserAndAnd:
		{
			p.SetState(287)
			p.Match(CParserAndAnd)
		}
		{
			p.SetState(288)
			p.Match(CParserIdentifier)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyUnaryOperatorContext() *UnaryOperatorContext {
	var p = new(UnaryOperatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_unaryOperator
	return p
}

func (*UnaryOperatorContext) IsUnaryOperatorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_unaryOperator

	return p
}

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

func (s *UnaryOperatorContext) And() antlr.TerminalNode {
	return s.GetToken(CParserAnd, 0)
}

func (s *UnaryOperatorContext) Star() antlr.TerminalNode {
	return s.GetToken(CParserStar, 0)
}

func (s *UnaryOperatorContext) Plus() antlr.TerminalNode {
	return s.GetToken(CParserPlus, 0)
}

func (s *UnaryOperatorContext) Minus() antlr.TerminalNode {
	return s.GetToken(CParserMinus, 0)
}

func (s *UnaryOperatorContext) Tilde() antlr.TerminalNode {
	return s.GetToken(CParserTilde, 0)
}

func (s *UnaryOperatorContext) Not() antlr.TerminalNode {
	return s.GetToken(CParserNot, 0)
}

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

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

func (s *UnaryOperatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterUnaryOperator(s)
	}
}

func (s *UnaryOperatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitUnaryOperator(s)
	}
}

func (p *CParser) UnaryOperator() (localctx IUnaryOperatorContext) {
	this := p
	_ = this

	localctx = NewUnaryOperatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 14, CParserRULE_unaryOperator)
	var _la int

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

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

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

		if !(((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

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

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

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

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

func NewEmptyCastExpressionContext() *CastExpressionContext {
	var p = new(CastExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_castExpression
	return p
}

func (*CastExpressionContext) IsCastExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_castExpression

	return p
}

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

func (s *CastExpressionContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *CastExpressionContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

func (s *CastExpressionContext) CastExpression() ICastExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICastExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICastExpressionContext)
}

func (s *CastExpressionContext) UnaryExpression() IUnaryExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryExpressionContext)
}

func (s *CastExpressionContext) DigitSequence() antlr.TerminalNode {
	return s.GetToken(CParserDigitSequence, 0)
}

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

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

func (s *CastExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterCastExpression(s)
	}
}

func (s *CastExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitCastExpression(s)
	}
}

func (p *CParser) CastExpression() (localctx ICastExpressionContext) {
	this := p
	_ = this

	localctx = NewCastExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, CParserRULE_castExpression)
	var _la int

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

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

	p.SetState(303)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 15, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(294)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == CParserT__0 {
			{
				p.SetState(293)
				p.Match(CParserT__0)
			}

		}
		{
			p.SetState(296)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(297)
			p.TypeName()
		}
		{
			p.SetState(298)
			p.Match(CParserRightParen)
		}
		{
			p.SetState(299)
			p.CastExpression()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(301)
			p.UnaryExpression()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(302)
			p.Match(CParserDigitSequence)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyMultiplicativeExpressionContext() *MultiplicativeExpressionContext {
	var p = new(MultiplicativeExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_multiplicativeExpression
	return p
}

func (*MultiplicativeExpressionContext) IsMultiplicativeExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_multiplicativeExpression

	return p
}

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

func (s *MultiplicativeExpressionContext) AllCastExpression() []ICastExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICastExpressionContext)(nil)).Elem())
	var tst = make([]ICastExpressionContext, len(ts))

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

	return tst
}

func (s *MultiplicativeExpressionContext) CastExpression(i int) ICastExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICastExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICastExpressionContext)
}

func (s *MultiplicativeExpressionContext) AllStar() []antlr.TerminalNode {
	return s.GetTokens(CParserStar)
}

func (s *MultiplicativeExpressionContext) Star(i int) antlr.TerminalNode {
	return s.GetToken(CParserStar, i)
}

func (s *MultiplicativeExpressionContext) AllDiv() []antlr.TerminalNode {
	return s.GetTokens(CParserDiv)
}

func (s *MultiplicativeExpressionContext) Div(i int) antlr.TerminalNode {
	return s.GetToken(CParserDiv, i)
}

func (s *MultiplicativeExpressionContext) AllMod() []antlr.TerminalNode {
	return s.GetTokens(CParserMod)
}

func (s *MultiplicativeExpressionContext) Mod(i int) antlr.TerminalNode {
	return s.GetToken(CParserMod, i)
}

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

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

func (s *MultiplicativeExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterMultiplicativeExpression(s)
	}
}

func (s *MultiplicativeExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitMultiplicativeExpression(s)
	}
}

func (p *CParser) MultiplicativeExpression() (localctx IMultiplicativeExpressionContext) {
	this := p
	_ = this

	localctx = NewMultiplicativeExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, CParserRULE_multiplicativeExpression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(305)
		p.CastExpression()
	}
	p.SetState(310)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ((_la-75)&-(0x1f+1)) == 0 && ((1<<uint((_la-75)))&((1<<(CParserStar-75))|(1<<(CParserDiv-75))|(1<<(CParserMod-75)))) != 0 {
		{
			p.SetState(306)
			_la = p.GetTokenStream().LA(1)

			if !(((_la-75)&-(0x1f+1)) == 0 && ((1<<uint((_la-75)))&((1<<(CParserStar-75))|(1<<(CParserDiv-75))|(1<<(CParserMod-75)))) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(307)
			p.CastExpression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAdditiveExpressionContext() *AdditiveExpressionContext {
	var p = new(AdditiveExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_additiveExpression
	return p
}

func (*AdditiveExpressionContext) IsAdditiveExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_additiveExpression

	return p
}

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

func (s *AdditiveExpressionContext) AllMultiplicativeExpression() []IMultiplicativeExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IMultiplicativeExpressionContext)(nil)).Elem())
	var tst = make([]IMultiplicativeExpressionContext, len(ts))

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

	return tst
}

func (s *AdditiveExpressionContext) MultiplicativeExpression(i int) IMultiplicativeExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMultiplicativeExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IMultiplicativeExpressionContext)
}

func (s *AdditiveExpressionContext) AllPlus() []antlr.TerminalNode {
	return s.GetTokens(CParserPlus)
}

func (s *AdditiveExpressionContext) Plus(i int) antlr.TerminalNode {
	return s.GetToken(CParserPlus, i)
}

func (s *AdditiveExpressionContext) AllMinus() []antlr.TerminalNode {
	return s.GetTokens(CParserMinus)
}

func (s *AdditiveExpressionContext) Minus(i int) antlr.TerminalNode {
	return s.GetToken(CParserMinus, i)
}

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

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

func (s *AdditiveExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterAdditiveExpression(s)
	}
}

func (s *AdditiveExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitAdditiveExpression(s)
	}
}

func (p *CParser) AdditiveExpression() (localctx IAdditiveExpressionContext) {
	this := p
	_ = this

	localctx = NewAdditiveExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 20, CParserRULE_additiveExpression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(313)
		p.MultiplicativeExpression()
	}
	p.SetState(318)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserPlus || _la == CParserMinus {
		{
			p.SetState(314)
			_la = p.GetTokenStream().LA(1)

			if !(_la == CParserPlus || _la == CParserMinus) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(315)
			p.MultiplicativeExpression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyShiftExpressionContext() *ShiftExpressionContext {
	var p = new(ShiftExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_shiftExpression
	return p
}

func (*ShiftExpressionContext) IsShiftExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_shiftExpression

	return p
}

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

func (s *ShiftExpressionContext) AllAdditiveExpression() []IAdditiveExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAdditiveExpressionContext)(nil)).Elem())
	var tst = make([]IAdditiveExpressionContext, len(ts))

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

	return tst
}

func (s *ShiftExpressionContext) AdditiveExpression(i int) IAdditiveExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAdditiveExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAdditiveExpressionContext)
}

func (s *ShiftExpressionContext) AllLeftShift() []antlr.TerminalNode {
	return s.GetTokens(CParserLeftShift)
}

func (s *ShiftExpressionContext) LeftShift(i int) antlr.TerminalNode {
	return s.GetToken(CParserLeftShift, i)
}

func (s *ShiftExpressionContext) AllRightShift() []antlr.TerminalNode {
	return s.GetTokens(CParserRightShift)
}

func (s *ShiftExpressionContext) RightShift(i int) antlr.TerminalNode {
	return s.GetToken(CParserRightShift, i)
}

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

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

func (s *ShiftExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterShiftExpression(s)
	}
}

func (s *ShiftExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitShiftExpression(s)
	}
}

func (p *CParser) ShiftExpression() (localctx IShiftExpressionContext) {
	this := p
	_ = this

	localctx = NewShiftExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 22, CParserRULE_shiftExpression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(321)
		p.AdditiveExpression()
	}
	p.SetState(326)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserLeftShift || _la == CParserRightShift {
		{
			p.SetState(322)
			_la = p.GetTokenStream().LA(1)

			if !(_la == CParserLeftShift || _la == CParserRightShift) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(323)
			p.AdditiveExpression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyRelationalExpressionContext() *RelationalExpressionContext {
	var p = new(RelationalExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_relationalExpression
	return p
}

func (*RelationalExpressionContext) IsRelationalExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_relationalExpression

	return p
}

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

func (s *RelationalExpressionContext) AllShiftExpression() []IShiftExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IShiftExpressionContext)(nil)).Elem())
	var tst = make([]IShiftExpressionContext, len(ts))

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

	return tst
}

func (s *RelationalExpressionContext) ShiftExpression(i int) IShiftExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IShiftExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IShiftExpressionContext)
}

func (s *RelationalExpressionContext) AllLess() []antlr.TerminalNode {
	return s.GetTokens(CParserLess)
}

func (s *RelationalExpressionContext) Less(i int) antlr.TerminalNode {
	return s.GetToken(CParserLess, i)
}

func (s *RelationalExpressionContext) AllGreater() []antlr.TerminalNode {
	return s.GetTokens(CParserGreater)
}

func (s *RelationalExpressionContext) Greater(i int) antlr.TerminalNode {
	return s.GetToken(CParserGreater, i)
}

func (s *RelationalExpressionContext) AllLessEqual() []antlr.TerminalNode {
	return s.GetTokens(CParserLessEqual)
}

func (s *RelationalExpressionContext) LessEqual(i int) antlr.TerminalNode {
	return s.GetToken(CParserLessEqual, i)
}

func (s *RelationalExpressionContext) AllGreaterEqual() []antlr.TerminalNode {
	return s.GetTokens(CParserGreaterEqual)
}

func (s *RelationalExpressionContext) GreaterEqual(i int) antlr.TerminalNode {
	return s.GetToken(CParserGreaterEqual, i)
}

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

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

func (s *RelationalExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterRelationalExpression(s)
	}
}

func (s *RelationalExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitRelationalExpression(s)
	}
}

func (p *CParser) RelationalExpression() (localctx IRelationalExpressionContext) {
	this := p
	_ = this

	localctx = NewRelationalExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, CParserRULE_relationalExpression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(329)
		p.ShiftExpression()
	}
	p.SetState(334)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(CParserLess-65))|(1<<(CParserLessEqual-65))|(1<<(CParserGreater-65))|(1<<(CParserGreaterEqual-65)))) != 0 {
		{
			p.SetState(330)
			_la = p.GetTokenStream().LA(1)

			if !(((_la-65)&-(0x1f+1)) == 0 && ((1<<uint((_la-65)))&((1<<(CParserLess-65))|(1<<(CParserLessEqual-65))|(1<<(CParserGreater-65))|(1<<(CParserGreaterEqual-65)))) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(331)
			p.ShiftExpression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyEqualityExpressionContext() *EqualityExpressionContext {
	var p = new(EqualityExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_equalityExpression
	return p
}

func (*EqualityExpressionContext) IsEqualityExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_equalityExpression

	return p
}

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

func (s *EqualityExpressionContext) AllRelationalExpression() []IRelationalExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IRelationalExpressionContext)(nil)).Elem())
	var tst = make([]IRelationalExpressionContext, len(ts))

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

	return tst
}

func (s *EqualityExpressionContext) RelationalExpression(i int) IRelationalExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRelationalExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IRelationalExpressionContext)
}

func (s *EqualityExpressionContext) AllEqual() []antlr.TerminalNode {
	return s.GetTokens(CParserEqual)
}

func (s *EqualityExpressionContext) Equal(i int) antlr.TerminalNode {
	return s.GetToken(CParserEqual, i)
}

func (s *EqualityExpressionContext) AllNotEqual() []antlr.TerminalNode {
	return s.GetTokens(CParserNotEqual)
}

func (s *EqualityExpressionContext) NotEqual(i int) antlr.TerminalNode {
	return s.GetToken(CParserNotEqual, i)
}

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

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

func (s *EqualityExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterEqualityExpression(s)
	}
}

func (s *EqualityExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitEqualityExpression(s)
	}
}

func (p *CParser) EqualityExpression() (localctx IEqualityExpressionContext) {
	this := p
	_ = this

	localctx = NewEqualityExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 26, CParserRULE_equalityExpression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(337)
		p.RelationalExpression()
	}
	p.SetState(342)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserEqual || _la == CParserNotEqual {
		{
			p.SetState(338)
			_la = p.GetTokenStream().LA(1)

			if !(_la == CParserEqual || _la == CParserNotEqual) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(339)
			p.RelationalExpression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAndExpressionContext() *AndExpressionContext {
	var p = new(AndExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_andExpression
	return p
}

func (*AndExpressionContext) IsAndExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_andExpression

	return p
}

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

func (s *AndExpressionContext) AllEqualityExpression() []IEqualityExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEqualityExpressionContext)(nil)).Elem())
	var tst = make([]IEqualityExpressionContext, len(ts))

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

	return tst
}

func (s *AndExpressionContext) EqualityExpression(i int) IEqualityExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEqualityExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEqualityExpressionContext)
}

func (s *AndExpressionContext) AllAnd() []antlr.TerminalNode {
	return s.GetTokens(CParserAnd)
}

func (s *AndExpressionContext) And(i int) antlr.TerminalNode {
	return s.GetToken(CParserAnd, i)
}

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

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

func (s *AndExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterAndExpression(s)
	}
}

func (s *AndExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitAndExpression(s)
	}
}

func (p *CParser) AndExpression() (localctx IAndExpressionContext) {
	this := p
	_ = this

	localctx = NewAndExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, CParserRULE_andExpression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(345)
		p.EqualityExpression()
	}
	p.SetState(350)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserAnd {
		{
			p.SetState(346)
			p.Match(CParserAnd)
		}
		{
			p.SetState(347)
			p.EqualityExpression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyExclusiveOrExpressionContext() *ExclusiveOrExpressionContext {
	var p = new(ExclusiveOrExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_exclusiveOrExpression
	return p
}

func (*ExclusiveOrExpressionContext) IsExclusiveOrExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_exclusiveOrExpression

	return p
}

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

func (s *ExclusiveOrExpressionContext) AllAndExpression() []IAndExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAndExpressionContext)(nil)).Elem())
	var tst = make([]IAndExpressionContext, len(ts))

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

	return tst
}

func (s *ExclusiveOrExpressionContext) AndExpression(i int) IAndExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAndExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAndExpressionContext)
}

func (s *ExclusiveOrExpressionContext) AllCaret() []antlr.TerminalNode {
	return s.GetTokens(CParserCaret)
}

func (s *ExclusiveOrExpressionContext) Caret(i int) antlr.TerminalNode {
	return s.GetToken(CParserCaret, i)
}

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

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

func (s *ExclusiveOrExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterExclusiveOrExpression(s)
	}
}

func (s *ExclusiveOrExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitExclusiveOrExpression(s)
	}
}

func (p *CParser) ExclusiveOrExpression() (localctx IExclusiveOrExpressionContext) {
	this := p
	_ = this

	localctx = NewExclusiveOrExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, CParserRULE_exclusiveOrExpression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(353)
		p.AndExpression()
	}
	p.SetState(358)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserCaret {
		{
			p.SetState(354)
			p.Match(CParserCaret)
		}
		{
			p.SetState(355)
			p.AndExpression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyInclusiveOrExpressionContext() *InclusiveOrExpressionContext {
	var p = new(InclusiveOrExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_inclusiveOrExpression
	return p
}

func (*InclusiveOrExpressionContext) IsInclusiveOrExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_inclusiveOrExpression

	return p
}

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

func (s *InclusiveOrExpressionContext) AllExclusiveOrExpression() []IExclusiveOrExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExclusiveOrExpressionContext)(nil)).Elem())
	var tst = make([]IExclusiveOrExpressionContext, len(ts))

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

	return tst
}

func (s *InclusiveOrExpressionContext) ExclusiveOrExpression(i int) IExclusiveOrExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExclusiveOrExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExclusiveOrExpressionContext)
}

func (s *InclusiveOrExpressionContext) AllOr() []antlr.TerminalNode {
	return s.GetTokens(CParserOr)
}

func (s *InclusiveOrExpressionContext) Or(i int) antlr.TerminalNode {
	return s.GetToken(CParserOr, i)
}

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

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

func (s *InclusiveOrExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterInclusiveOrExpression(s)
	}
}

func (s *InclusiveOrExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitInclusiveOrExpression(s)
	}
}

func (p *CParser) InclusiveOrExpression() (localctx IInclusiveOrExpressionContext) {
	this := p
	_ = this

	localctx = NewInclusiveOrExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, CParserRULE_inclusiveOrExpression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(361)
		p.ExclusiveOrExpression()
	}
	p.SetState(366)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserOr {
		{
			p.SetState(362)
			p.Match(CParserOr)
		}
		{
			p.SetState(363)
			p.ExclusiveOrExpression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyLogicalAndExpressionContext() *LogicalAndExpressionContext {
	var p = new(LogicalAndExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_logicalAndExpression
	return p
}

func (*LogicalAndExpressionContext) IsLogicalAndExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_logicalAndExpression

	return p
}

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

func (s *LogicalAndExpressionContext) AllInclusiveOrExpression() []IInclusiveOrExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInclusiveOrExpressionContext)(nil)).Elem())
	var tst = make([]IInclusiveOrExpressionContext, len(ts))

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

	return tst
}

func (s *LogicalAndExpressionContext) InclusiveOrExpression(i int) IInclusiveOrExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInclusiveOrExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInclusiveOrExpressionContext)
}

func (s *LogicalAndExpressionContext) AllAndAnd() []antlr.TerminalNode {
	return s.GetTokens(CParserAndAnd)
}

func (s *LogicalAndExpressionContext) AndAnd(i int) antlr.TerminalNode {
	return s.GetToken(CParserAndAnd, i)
}

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

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

func (s *LogicalAndExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterLogicalAndExpression(s)
	}
}

func (s *LogicalAndExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitLogicalAndExpression(s)
	}
}

func (p *CParser) LogicalAndExpression() (localctx ILogicalAndExpressionContext) {
	this := p
	_ = this

	localctx = NewLogicalAndExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 34, CParserRULE_logicalAndExpression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(369)
		p.InclusiveOrExpression()
	}
	p.SetState(374)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserAndAnd {
		{
			p.SetState(370)
			p.Match(CParserAndAnd)
		}
		{
			p.SetState(371)
			p.InclusiveOrExpression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyLogicalOrExpressionContext() *LogicalOrExpressionContext {
	var p = new(LogicalOrExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_logicalOrExpression
	return p
}

func (*LogicalOrExpressionContext) IsLogicalOrExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_logicalOrExpression

	return p
}

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

func (s *LogicalOrExpressionContext) AllLogicalAndExpression() []ILogicalAndExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ILogicalAndExpressionContext)(nil)).Elem())
	var tst = make([]ILogicalAndExpressionContext, len(ts))

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

	return tst
}

func (s *LogicalOrExpressionContext) LogicalAndExpression(i int) ILogicalAndExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILogicalAndExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ILogicalAndExpressionContext)
}

func (s *LogicalOrExpressionContext) AllOrOr() []antlr.TerminalNode {
	return s.GetTokens(CParserOrOr)
}

func (s *LogicalOrExpressionContext) OrOr(i int) antlr.TerminalNode {
	return s.GetToken(CParserOrOr, i)
}

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

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

func (s *LogicalOrExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterLogicalOrExpression(s)
	}
}

func (s *LogicalOrExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitLogicalOrExpression(s)
	}
}

func (p *CParser) LogicalOrExpression() (localctx ILogicalOrExpressionContext) {
	this := p
	_ = this

	localctx = NewLogicalOrExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, CParserRULE_logicalOrExpression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(377)
		p.LogicalAndExpression()
	}
	p.SetState(382)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserOrOr {
		{
			p.SetState(378)
			p.Match(CParserOrOr)
		}
		{
			p.SetState(379)
			p.LogicalAndExpression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyConditionalExpressionContext() *ConditionalExpressionContext {
	var p = new(ConditionalExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_conditionalExpression
	return p
}

func (*ConditionalExpressionContext) IsConditionalExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_conditionalExpression

	return p
}

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

func (s *ConditionalExpressionContext) LogicalOrExpression() ILogicalOrExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILogicalOrExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILogicalOrExpressionContext)
}

func (s *ConditionalExpressionContext) Question() antlr.TerminalNode {
	return s.GetToken(CParserQuestion, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ConditionalExpressionContext) Colon() antlr.TerminalNode {
	return s.GetToken(CParserColon, 0)
}

func (s *ConditionalExpressionContext) ConditionalExpression() IConditionalExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConditionalExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConditionalExpressionContext)
}

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

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

func (s *ConditionalExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterConditionalExpression(s)
	}
}

func (s *ConditionalExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitConditionalExpression(s)
	}
}

func (p *CParser) ConditionalExpression() (localctx IConditionalExpressionContext) {
	this := p
	_ = this

	localctx = NewConditionalExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, CParserRULE_conditionalExpression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(385)
		p.LogicalOrExpression()
	}
	p.SetState(391)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CParserQuestion {
		{
			p.SetState(386)
			p.Match(CParserQuestion)
		}
		{
			p.SetState(387)
			p.Expression()
		}
		{
			p.SetState(388)
			p.Match(CParserColon)
		}
		{
			p.SetState(389)
			p.ConditionalExpression()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyAssignmentExpressionContext() *AssignmentExpressionContext {
	var p = new(AssignmentExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_assignmentExpression
	return p
}

func (*AssignmentExpressionContext) IsAssignmentExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_assignmentExpression

	return p
}

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

func (s *AssignmentExpressionContext) ConditionalExpression() IConditionalExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConditionalExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConditionalExpressionContext)
}

func (s *AssignmentExpressionContext) UnaryExpression() IUnaryExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryExpressionContext)
}

func (s *AssignmentExpressionContext) AssignmentOperator() IAssignmentOperatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentOperatorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentOperatorContext)
}

func (s *AssignmentExpressionContext) AssignmentExpression() IAssignmentExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentExpressionContext)
}

func (s *AssignmentExpressionContext) DigitSequence() antlr.TerminalNode {
	return s.GetToken(CParserDigitSequence, 0)
}

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

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

func (s *AssignmentExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterAssignmentExpression(s)
	}
}

func (s *AssignmentExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitAssignmentExpression(s)
	}
}

func (p *CParser) AssignmentExpression() (localctx IAssignmentExpressionContext) {
	this := p
	_ = this

	localctx = NewAssignmentExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, CParserRULE_assignmentExpression)

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

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

	p.SetState(399)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 27, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(393)
			p.ConditionalExpression()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(394)
			p.UnaryExpression()
		}
		{
			p.SetState(395)
			p.AssignmentOperator()
		}
		{
			p.SetState(396)
			p.AssignmentExpression()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(398)
			p.Match(CParserDigitSequence)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyAssignmentOperatorContext() *AssignmentOperatorContext {
	var p = new(AssignmentOperatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_assignmentOperator
	return p
}

func (*AssignmentOperatorContext) IsAssignmentOperatorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_assignmentOperator

	return p
}

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

func (s *AssignmentOperatorContext) Assign() antlr.TerminalNode {
	return s.GetToken(CParserAssign, 0)
}

func (s *AssignmentOperatorContext) StarAssign() antlr.TerminalNode {
	return s.GetToken(CParserStarAssign, 0)
}

func (s *AssignmentOperatorContext) DivAssign() antlr.TerminalNode {
	return s.GetToken(CParserDivAssign, 0)
}

func (s *AssignmentOperatorContext) ModAssign() antlr.TerminalNode {
	return s.GetToken(CParserModAssign, 0)
}

func (s *AssignmentOperatorContext) PlusAssign() antlr.TerminalNode {
	return s.GetToken(CParserPlusAssign, 0)
}

func (s *AssignmentOperatorContext) MinusAssign() antlr.TerminalNode {
	return s.GetToken(CParserMinusAssign, 0)
}

func (s *AssignmentOperatorContext) LeftShiftAssign() antlr.TerminalNode {
	return s.GetToken(CParserLeftShiftAssign, 0)
}

func (s *AssignmentOperatorContext) RightShiftAssign() antlr.TerminalNode {
	return s.GetToken(CParserRightShiftAssign, 0)
}

func (s *AssignmentOperatorContext) AndAssign() antlr.TerminalNode {
	return s.GetToken(CParserAndAssign, 0)
}

func (s *AssignmentOperatorContext) XorAssign() antlr.TerminalNode {
	return s.GetToken(CParserXorAssign, 0)
}

func (s *AssignmentOperatorContext) OrAssign() antlr.TerminalNode {
	return s.GetToken(CParserOrAssign, 0)
}

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

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

func (s *AssignmentOperatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterAssignmentOperator(s)
	}
}

func (s *AssignmentOperatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitAssignmentOperator(s)
	}
}

func (p *CParser) AssignmentOperator() (localctx IAssignmentOperatorContext) {
	this := p
	_ = this

	localctx = NewAssignmentOperatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, CParserRULE_assignmentOperator)
	var _la int

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

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

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

		if !(((_la-89)&-(0x1f+1)) == 0 && ((1<<uint((_la-89)))&((1<<(CParserAssign-89))|(1<<(CParserStarAssign-89))|(1<<(CParserDivAssign-89))|(1<<(CParserModAssign-89))|(1<<(CParserPlusAssign-89))|(1<<(CParserMinusAssign-89))|(1<<(CParserLeftShiftAssign-89))|(1<<(CParserRightShiftAssign-89))|(1<<(CParserAndAssign-89))|(1<<(CParserXorAssign-89))|(1<<(CParserOrAssign-89)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

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

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

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

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

func NewEmptyExpressionContext() *ExpressionContext {
	var p = new(ExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_expression
	return p
}

func (*ExpressionContext) IsExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_expression

	return p
}

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

func (s *ExpressionContext) AllAssignmentExpression() []IAssignmentExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAssignmentExpressionContext)(nil)).Elem())
	var tst = make([]IAssignmentExpressionContext, len(ts))

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

	return tst
}

func (s *ExpressionContext) AssignmentExpression(i int) IAssignmentExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAssignmentExpressionContext)
}

func (s *ExpressionContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(CParserComma)
}

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

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

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

func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterExpression(s)
	}
}

func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitExpression(s)
	}
}

func (p *CParser) Expression() (localctx IExpressionContext) {
	this := p
	_ = this

	localctx = NewExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, CParserRULE_expression)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(403)
		p.AssignmentExpression()
	}
	p.SetState(408)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserComma {
		{
			p.SetState(404)
			p.Match(CParserComma)
		}
		{
			p.SetState(405)
			p.AssignmentExpression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyConstantExpressionContext() *ConstantExpressionContext {
	var p = new(ConstantExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_constantExpression
	return p
}

func (*ConstantExpressionContext) IsConstantExpressionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_constantExpression

	return p
}

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

func (s *ConstantExpressionContext) ConditionalExpression() IConditionalExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConditionalExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConditionalExpressionContext)
}

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

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

func (s *ConstantExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterConstantExpression(s)
	}
}

func (s *ConstantExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitConstantExpression(s)
	}
}

func (p *CParser) ConstantExpression() (localctx IConstantExpressionContext) {
	this := p
	_ = this

	localctx = NewConstantExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, CParserRULE_constantExpression)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(411)
		p.ConditionalExpression()
	}

	return localctx
}

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

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

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

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

func NewEmptyDeclarationContext() *DeclarationContext {
	var p = new(DeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_declaration
	return p
}

func (*DeclarationContext) IsDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_declaration

	return p
}

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

func (s *DeclarationContext) DeclarationSpecifiers() IDeclarationSpecifiersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclarationSpecifiersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclarationSpecifiersContext)
}

func (s *DeclarationContext) Semi() antlr.TerminalNode {
	return s.GetToken(CParserSemi, 0)
}

func (s *DeclarationContext) InitDeclaratorList() IInitDeclaratorListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitDeclaratorListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInitDeclaratorListContext)
}

func (s *DeclarationContext) StaticAssertDeclaration() IStaticAssertDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStaticAssertDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStaticAssertDeclarationContext)
}

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

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

func (s *DeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterDeclaration(s)
	}
}

func (s *DeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitDeclaration(s)
	}
}

func (p *CParser) Declaration() (localctx IDeclarationContext) {
	this := p
	_ = this

	localctx = NewDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, CParserRULE_declaration)
	var _la int

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

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

	switch p.GetTokenStream().LA(1) {
	case CParserT__0, CParserT__3, CParserT__4, CParserT__5, CParserT__6, CParserT__7, CParserT__8, CParserT__9, CParserT__11, CParserAuto, CParserChar, CParserConst, CParserDouble, CParserEnum, CParserExtern, CParserFloat, CParserInline, CParserInt, CParserLong, CParserRegister, CParserRestrict, CParserShort, CParserSigned, CParserStatic, CParserStruct, CParserTypedef, CParserUnion, CParserUnsigned, CParserVoid, CParserVolatile, CParserAlignas, CParserAtomic, CParserBool, CParserComplex, CParserNoreturn, CParserThreadLocal, CParserIdentifier:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(413)
			p.DeclarationSpecifiers()
		}
		p.SetState(415)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la-59)&-(0x1f+1)) == 0 && ((1<<uint((_la-59)))&((1<<(CParserLeftParen-59))|(1<<(CParserStar-59))|(1<<(CParserCaret-59)))) != 0) || _la == CParserIdentifier {
			{
				p.SetState(414)
				p.InitDeclaratorList()
			}

		}
		{
			p.SetState(417)
			p.Match(CParserSemi)
		}

	case CParserStaticAssert:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(419)
			p.StaticAssertDeclaration()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyDeclarationSpecifiersContext() *DeclarationSpecifiersContext {
	var p = new(DeclarationSpecifiersContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_declarationSpecifiers
	return p
}

func (*DeclarationSpecifiersContext) IsDeclarationSpecifiersContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_declarationSpecifiers

	return p
}

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

func (s *DeclarationSpecifiersContext) AllDeclarationSpecifier() []IDeclarationSpecifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDeclarationSpecifierContext)(nil)).Elem())
	var tst = make([]IDeclarationSpecifierContext, len(ts))

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

	return tst
}

func (s *DeclarationSpecifiersContext) DeclarationSpecifier(i int) IDeclarationSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclarationSpecifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDeclarationSpecifierContext)
}

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

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

func (s *DeclarationSpecifiersContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterDeclarationSpecifiers(s)
	}
}

func (s *DeclarationSpecifiersContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitDeclarationSpecifiers(s)
	}
}

func (p *CParser) DeclarationSpecifiers() (localctx IDeclarationSpecifiersContext) {
	this := p
	_ = this

	localctx = NewDeclarationSpecifiersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 50, CParserRULE_declarationSpecifiers)

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

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

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

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

	return localctx
}

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

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

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

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

func NewEmptyDeclarationSpecifiers2Context() *DeclarationSpecifiers2Context {
	var p = new(DeclarationSpecifiers2Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_declarationSpecifiers2
	return p
}

func (*DeclarationSpecifiers2Context) IsDeclarationSpecifiers2Context() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_declarationSpecifiers2

	return p
}

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

func (s *DeclarationSpecifiers2Context) AllDeclarationSpecifier() []IDeclarationSpecifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDeclarationSpecifierContext)(nil)).Elem())
	var tst = make([]IDeclarationSpecifierContext, len(ts))

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

	return tst
}

func (s *DeclarationSpecifiers2Context) DeclarationSpecifier(i int) IDeclarationSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclarationSpecifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDeclarationSpecifierContext)
}

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

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

func (s *DeclarationSpecifiers2Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterDeclarationSpecifiers2(s)
	}
}

func (s *DeclarationSpecifiers2Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitDeclarationSpecifiers2(s)
	}
}

func (p *CParser) DeclarationSpecifiers2() (localctx IDeclarationSpecifiers2Context) {
	this := p
	_ = this

	localctx = NewDeclarationSpecifiers2Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, CParserRULE_declarationSpecifiers2)
	var _la int

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

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

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

	for ok := true; ok; ok = (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserT__6)|(1<<CParserT__7)|(1<<CParserT__8)|(1<<CParserT__9)|(1<<CParserT__11)|(1<<CParserAuto)|(1<<CParserChar)|(1<<CParserConst)|(1<<CParserDouble)|(1<<CParserEnum)|(1<<CParserExtern)|(1<<CParserFloat)|(1<<CParserInline))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserRegister-32))|(1<<(CParserRestrict-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserStatic-32))|(1<<(CParserStruct-32))|(1<<(CParserTypedef-32))|(1<<(CParserUnion-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserVolatile-32))|(1<<(CParserAlignas-32))|(1<<(CParserAtomic-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32))|(1<<(CParserNoreturn-32))|(1<<(CParserThreadLocal-32)))) != 0) || _la == CParserIdentifier {
		{
			p.SetState(427)
			p.DeclarationSpecifier()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyDeclarationSpecifierContext() *DeclarationSpecifierContext {
	var p = new(DeclarationSpecifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_declarationSpecifier
	return p
}

func (*DeclarationSpecifierContext) IsDeclarationSpecifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_declarationSpecifier

	return p
}

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

func (s *DeclarationSpecifierContext) StorageClassSpecifier() IStorageClassSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStorageClassSpecifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStorageClassSpecifierContext)
}

func (s *DeclarationSpecifierContext) TypeSpecifier() ITypeSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeSpecifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeSpecifierContext)
}

func (s *DeclarationSpecifierContext) TypeQualifier() ITypeQualifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeQualifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeQualifierContext)
}

func (s *DeclarationSpecifierContext) FunctionSpecifier() IFunctionSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionSpecifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionSpecifierContext)
}

func (s *DeclarationSpecifierContext) AlignmentSpecifier() IAlignmentSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlignmentSpecifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlignmentSpecifierContext)
}

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

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

func (s *DeclarationSpecifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterDeclarationSpecifier(s)
	}
}

func (s *DeclarationSpecifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitDeclarationSpecifier(s)
	}
}

func (p *CParser) DeclarationSpecifier() (localctx IDeclarationSpecifierContext) {
	this := p
	_ = this

	localctx = NewDeclarationSpecifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 54, CParserRULE_declarationSpecifier)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(433)
			p.typeSpecifier(0)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(434)
			p.TypeQualifier()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(435)
			p.FunctionSpecifier()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(436)
			p.AlignmentSpecifier()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyInitDeclaratorListContext() *InitDeclaratorListContext {
	var p = new(InitDeclaratorListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_initDeclaratorList
	return p
}

func (*InitDeclaratorListContext) IsInitDeclaratorListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_initDeclaratorList

	return p
}

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

func (s *InitDeclaratorListContext) AllInitDeclarator() []IInitDeclaratorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInitDeclaratorContext)(nil)).Elem())
	var tst = make([]IInitDeclaratorContext, len(ts))

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

	return tst
}

func (s *InitDeclaratorListContext) InitDeclarator(i int) IInitDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitDeclaratorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInitDeclaratorContext)
}

func (s *InitDeclaratorListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(CParserComma)
}

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

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

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

func (s *InitDeclaratorListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterInitDeclaratorList(s)
	}
}

func (s *InitDeclaratorListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitInitDeclaratorList(s)
	}
}

func (p *CParser) InitDeclaratorList() (localctx IInitDeclaratorListContext) {
	this := p
	_ = this

	localctx = NewInitDeclaratorListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, CParserRULE_initDeclaratorList)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(439)
		p.InitDeclarator()
	}
	p.SetState(444)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserComma {
		{
			p.SetState(440)
			p.Match(CParserComma)
		}
		{
			p.SetState(441)
			p.InitDeclarator()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyInitDeclaratorContext() *InitDeclaratorContext {
	var p = new(InitDeclaratorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_initDeclarator
	return p
}

func (*InitDeclaratorContext) IsInitDeclaratorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_initDeclarator

	return p
}

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

func (s *InitDeclaratorContext) Declarator() IDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclaratorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclaratorContext)
}

func (s *InitDeclaratorContext) Assign() antlr.TerminalNode {
	return s.GetToken(CParserAssign, 0)
}

func (s *InitDeclaratorContext) Initializer() IInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitializerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInitializerContext)
}

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

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

func (s *InitDeclaratorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterInitDeclarator(s)
	}
}

func (s *InitDeclaratorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitInitDeclarator(s)
	}
}

func (p *CParser) InitDeclarator() (localctx IInitDeclaratorContext) {
	this := p
	_ = this

	localctx = NewInitDeclaratorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, CParserRULE_initDeclarator)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(447)
		p.Declarator()
	}
	p.SetState(450)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CParserAssign {
		{
			p.SetState(448)
			p.Match(CParserAssign)
		}
		{
			p.SetState(449)
			p.Initializer()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyStorageClassSpecifierContext() *StorageClassSpecifierContext {
	var p = new(StorageClassSpecifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_storageClassSpecifier
	return p
}

func (*StorageClassSpecifierContext) IsStorageClassSpecifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_storageClassSpecifier

	return p
}

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

func (s *StorageClassSpecifierContext) Typedef() antlr.TerminalNode {
	return s.GetToken(CParserTypedef, 0)
}

func (s *StorageClassSpecifierContext) Extern() antlr.TerminalNode {
	return s.GetToken(CParserExtern, 0)
}

func (s *StorageClassSpecifierContext) Static() antlr.TerminalNode {
	return s.GetToken(CParserStatic, 0)
}

func (s *StorageClassSpecifierContext) ThreadLocal() antlr.TerminalNode {
	return s.GetToken(CParserThreadLocal, 0)
}

func (s *StorageClassSpecifierContext) Auto() antlr.TerminalNode {
	return s.GetToken(CParserAuto, 0)
}

func (s *StorageClassSpecifierContext) Register() antlr.TerminalNode {
	return s.GetToken(CParserRegister, 0)
}

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

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

func (s *StorageClassSpecifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterStorageClassSpecifier(s)
	}
}

func (s *StorageClassSpecifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitStorageClassSpecifier(s)
	}
}

func (p *CParser) StorageClassSpecifier() (localctx IStorageClassSpecifierContext) {
	this := p
	_ = this

	localctx = NewStorageClassSpecifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 60, CParserRULE_storageClassSpecifier)
	var _la int

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

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

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

		if !(_la == CParserAuto || _la == CParserExtern || (((_la-34)&-(0x1f+1)) == 0 && ((1<<uint((_la-34)))&((1<<(CParserRegister-34))|(1<<(CParserStatic-34))|(1<<(CParserTypedef-34))|(1<<(CParserThreadLocal-34)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeSpecifierContext() *TypeSpecifierContext {
	var p = new(TypeSpecifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_typeSpecifier
	return p
}

func (*TypeSpecifierContext) IsTypeSpecifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_typeSpecifier

	return p
}

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

func (s *TypeSpecifierContext) Void() antlr.TerminalNode {
	return s.GetToken(CParserVoid, 0)
}

func (s *TypeSpecifierContext) Char() antlr.TerminalNode {
	return s.GetToken(CParserChar, 0)
}

func (s *TypeSpecifierContext) Short() antlr.TerminalNode {
	return s.GetToken(CParserShort, 0)
}

func (s *TypeSpecifierContext) Int() antlr.TerminalNode {
	return s.GetToken(CParserInt, 0)
}

func (s *TypeSpecifierContext) Long() antlr.TerminalNode {
	return s.GetToken(CParserLong, 0)
}

func (s *TypeSpecifierContext) Float() antlr.TerminalNode {
	return s.GetToken(CParserFloat, 0)
}

func (s *TypeSpecifierContext) Double() antlr.TerminalNode {
	return s.GetToken(CParserDouble, 0)
}

func (s *TypeSpecifierContext) Signed() antlr.TerminalNode {
	return s.GetToken(CParserSigned, 0)
}

func (s *TypeSpecifierContext) Unsigned() antlr.TerminalNode {
	return s.GetToken(CParserUnsigned, 0)
}

func (s *TypeSpecifierContext) Bool() antlr.TerminalNode {
	return s.GetToken(CParserBool, 0)
}

func (s *TypeSpecifierContext) Complex() antlr.TerminalNode {
	return s.GetToken(CParserComplex, 0)
}

func (s *TypeSpecifierContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

func (s *TypeSpecifierContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

func (s *TypeSpecifierContext) AtomicTypeSpecifier() IAtomicTypeSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAtomicTypeSpecifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAtomicTypeSpecifierContext)
}

func (s *TypeSpecifierContext) StructOrUnionSpecifier() IStructOrUnionSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStructOrUnionSpecifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStructOrUnionSpecifierContext)
}

func (s *TypeSpecifierContext) EnumSpecifier() IEnumSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumSpecifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumSpecifierContext)
}

func (s *TypeSpecifierContext) TypedefName() ITypedefNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypedefNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypedefNameContext)
}

func (s *TypeSpecifierContext) ConstantExpression() IConstantExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantExpressionContext)
}

func (s *TypeSpecifierContext) TypeSpecifier() ITypeSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeSpecifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeSpecifierContext)
}

func (s *TypeSpecifierContext) Pointer() IPointerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPointerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPointerContext)
}

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

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

func (s *TypeSpecifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterTypeSpecifier(s)
	}
}

func (s *TypeSpecifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitTypeSpecifier(s)
	}
}

func (p *CParser) TypeSpecifier() (localctx ITypeSpecifierContext) {
	return p.typeSpecifier(0)
}

func (p *CParser) typeSpecifier(_p int) (localctx ITypeSpecifierContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewTypeSpecifierContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx ITypeSpecifierContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 62
	p.EnterRecursionRule(localctx, 62, CParserRULE_typeSpecifier, _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(469)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CParserT__3, CParserT__4, CParserT__5, CParserChar, CParserDouble, CParserFloat, CParserInt, CParserLong, CParserShort, CParserSigned, CParserUnsigned, CParserVoid, CParserBool, CParserComplex:
		{
			p.SetState(455)
			_la = p.GetTokenStream().LA(1)

			if !((((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserChar)|(1<<CParserDouble)|(1<<CParserFloat))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32)))) != 0)) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	case CParserT__0:
		{
			p.SetState(456)
			p.Match(CParserT__0)
		}
		{
			p.SetState(457)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(458)
			_la = p.GetTokenStream().LA(1)

			if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5))) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(459)
			p.Match(CParserRightParen)
		}

	case CParserAtomic:
		{
			p.SetState(460)
			p.AtomicTypeSpecifier()
		}

	case CParserStruct, CParserUnion:
		{
			p.SetState(461)
			p.StructOrUnionSpecifier()
		}

	case CParserEnum:
		{
			p.SetState(462)
			p.EnumSpecifier()
		}

	case CParserIdentifier:
		{
			p.SetState(463)
			p.TypedefName()
		}

	case CParserT__6:
		{
			p.SetState(464)
			p.Match(CParserT__6)
		}
		{
			p.SetState(465)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(466)
			p.ConstantExpression()
		}
		{
			p.SetState(467)
			p.Match(CParserRightParen)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(475)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 37, p.GetParserRuleContext())

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

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

		}
		p.SetState(477)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 37, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyStructOrUnionSpecifierContext() *StructOrUnionSpecifierContext {
	var p = new(StructOrUnionSpecifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_structOrUnionSpecifier
	return p
}

func (*StructOrUnionSpecifierContext) IsStructOrUnionSpecifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_structOrUnionSpecifier

	return p
}

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

func (s *StructOrUnionSpecifierContext) StructOrUnion() IStructOrUnionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStructOrUnionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStructOrUnionContext)
}

func (s *StructOrUnionSpecifierContext) LeftBrace() antlr.TerminalNode {
	return s.GetToken(CParserLeftBrace, 0)
}

func (s *StructOrUnionSpecifierContext) StructDeclarationList() IStructDeclarationListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStructDeclarationListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStructDeclarationListContext)
}

func (s *StructOrUnionSpecifierContext) RightBrace() antlr.TerminalNode {
	return s.GetToken(CParserRightBrace, 0)
}

func (s *StructOrUnionSpecifierContext) Identifier() antlr.TerminalNode {
	return s.GetToken(CParserIdentifier, 0)
}

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

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

func (s *StructOrUnionSpecifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterStructOrUnionSpecifier(s)
	}
}

func (s *StructOrUnionSpecifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitStructOrUnionSpecifier(s)
	}
}

func (p *CParser) StructOrUnionSpecifier() (localctx IStructOrUnionSpecifierContext) {
	this := p
	_ = this

	localctx = NewStructOrUnionSpecifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 64, CParserRULE_structOrUnionSpecifier)
	var _la int

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

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

		if _la == CParserIdentifier {
			{
				p.SetState(479)
				p.Match(CParserIdentifier)
			}

		}
		{
			p.SetState(482)
			p.Match(CParserLeftBrace)
		}
		{
			p.SetState(483)
			p.StructDeclarationList()
		}
		{
			p.SetState(484)
			p.Match(CParserRightBrace)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(486)
			p.StructOrUnion()
		}
		{
			p.SetState(487)
			p.Match(CParserIdentifier)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyStructOrUnionContext() *StructOrUnionContext {
	var p = new(StructOrUnionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_structOrUnion
	return p
}

func (*StructOrUnionContext) IsStructOrUnionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_structOrUnion

	return p
}

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

func (s *StructOrUnionContext) Struct() antlr.TerminalNode {
	return s.GetToken(CParserStruct, 0)
}

func (s *StructOrUnionContext) Union() antlr.TerminalNode {
	return s.GetToken(CParserUnion, 0)
}

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

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

func (s *StructOrUnionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterStructOrUnion(s)
	}
}

func (s *StructOrUnionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitStructOrUnion(s)
	}
}

func (p *CParser) StructOrUnion() (localctx IStructOrUnionContext) {
	this := p
	_ = this

	localctx = NewStructOrUnionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, CParserRULE_structOrUnion)
	var _la int

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

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

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

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

	return localctx
}

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

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

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

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

func NewEmptyStructDeclarationListContext() *StructDeclarationListContext {
	var p = new(StructDeclarationListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_structDeclarationList
	return p
}

func (*StructDeclarationListContext) IsStructDeclarationListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_structDeclarationList

	return p
}

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

func (s *StructDeclarationListContext) AllStructDeclaration() []IStructDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IStructDeclarationContext)(nil)).Elem())
	var tst = make([]IStructDeclarationContext, len(ts))

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

	return tst
}

func (s *StructDeclarationListContext) StructDeclaration(i int) IStructDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStructDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IStructDeclarationContext)
}

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

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

func (s *StructDeclarationListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterStructDeclarationList(s)
	}
}

func (s *StructDeclarationListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitStructDeclarationList(s)
	}
}

func (p *CParser) StructDeclarationList() (localctx IStructDeclarationListContext) {
	this := p
	_ = this

	localctx = NewStructDeclarationListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, CParserRULE_structDeclarationList)
	var _la int

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

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

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

	for ok := true; ok; ok = (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserT__6)|(1<<CParserChar)|(1<<CParserConst)|(1<<CParserDouble)|(1<<CParserEnum)|(1<<CParserFloat))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserRestrict-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserStruct-32))|(1<<(CParserUnion-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserVolatile-32))|(1<<(CParserAtomic-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32))|(1<<(CParserStaticAssert-32)))) != 0) || _la == CParserIdentifier {
		{
			p.SetState(493)
			p.StructDeclaration()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyStructDeclarationContext() *StructDeclarationContext {
	var p = new(StructDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_structDeclaration
	return p
}

func (*StructDeclarationContext) IsStructDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_structDeclaration

	return p
}

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

func (s *StructDeclarationContext) SpecifierQualifierList() ISpecifierQualifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISpecifierQualifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISpecifierQualifierListContext)
}

func (s *StructDeclarationContext) Semi() antlr.TerminalNode {
	return s.GetToken(CParserSemi, 0)
}

func (s *StructDeclarationContext) StructDeclaratorList() IStructDeclaratorListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStructDeclaratorListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStructDeclaratorListContext)
}

func (s *StructDeclarationContext) StaticAssertDeclaration() IStaticAssertDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStaticAssertDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStaticAssertDeclarationContext)
}

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

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

func (s *StructDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterStructDeclaration(s)
	}
}

func (s *StructDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitStructDeclaration(s)
	}
}

func (p *CParser) StructDeclaration() (localctx IStructDeclarationContext) {
	this := p
	_ = this

	localctx = NewStructDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, CParserRULE_structDeclaration)
	var _la int

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

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

	switch p.GetTokenStream().LA(1) {
	case CParserT__0, CParserT__3, CParserT__4, CParserT__5, CParserT__6, CParserChar, CParserConst, CParserDouble, CParserEnum, CParserFloat, CParserInt, CParserLong, CParserRestrict, CParserShort, CParserSigned, CParserStruct, CParserUnion, CParserUnsigned, CParserVoid, CParserVolatile, CParserAtomic, CParserBool, CParserComplex, CParserIdentifier:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(498)
			p.SpecifierQualifierList()
		}
		p.SetState(500)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la-59)&-(0x1f+1)) == 0 && ((1<<uint((_la-59)))&((1<<(CParserLeftParen-59))|(1<<(CParserStar-59))|(1<<(CParserCaret-59))|(1<<(CParserColon-59)))) != 0) || _la == CParserIdentifier {
			{
				p.SetState(499)
				p.StructDeclaratorList()
			}

		}
		{
			p.SetState(502)
			p.Match(CParserSemi)
		}

	case CParserStaticAssert:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(504)
			p.StaticAssertDeclaration()
		}

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

	return localctx
}

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

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

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

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

func NewEmptySpecifierQualifierListContext() *SpecifierQualifierListContext {
	var p = new(SpecifierQualifierListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_specifierQualifierList
	return p
}

func (*SpecifierQualifierListContext) IsSpecifierQualifierListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_specifierQualifierList

	return p
}

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

func (s *SpecifierQualifierListContext) TypeSpecifier() ITypeSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeSpecifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeSpecifierContext)
}

func (s *SpecifierQualifierListContext) TypeQualifier() ITypeQualifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeQualifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeQualifierContext)
}

func (s *SpecifierQualifierListContext) SpecifierQualifierList() ISpecifierQualifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISpecifierQualifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISpecifierQualifierListContext)
}

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

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

func (s *SpecifierQualifierListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterSpecifierQualifierList(s)
	}
}

func (s *SpecifierQualifierListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitSpecifierQualifierList(s)
	}
}

func (p *CParser) SpecifierQualifierList() (localctx ISpecifierQualifierListContext) {
	this := p
	_ = this

	localctx = NewSpecifierQualifierListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, CParserRULE_specifierQualifierList)

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

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

	p.EnterOuterAlt(localctx, 1)
	p.SetState(509)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 43, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(507)
			p.typeSpecifier(0)
		}

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

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 44, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(511)
			p.SpecifierQualifierList()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyStructDeclaratorListContext() *StructDeclaratorListContext {
	var p = new(StructDeclaratorListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_structDeclaratorList
	return p
}

func (*StructDeclaratorListContext) IsStructDeclaratorListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_structDeclaratorList

	return p
}

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

func (s *StructDeclaratorListContext) AllStructDeclarator() []IStructDeclaratorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IStructDeclaratorContext)(nil)).Elem())
	var tst = make([]IStructDeclaratorContext, len(ts))

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

	return tst
}

func (s *StructDeclaratorListContext) StructDeclarator(i int) IStructDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStructDeclaratorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IStructDeclaratorContext)
}

func (s *StructDeclaratorListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(CParserComma)
}

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

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

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

func (s *StructDeclaratorListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterStructDeclaratorList(s)
	}
}

func (s *StructDeclaratorListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitStructDeclaratorList(s)
	}
}

func (p *CParser) StructDeclaratorList() (localctx IStructDeclaratorListContext) {
	this := p
	_ = this

	localctx = NewStructDeclaratorListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, CParserRULE_structDeclaratorList)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(514)
		p.StructDeclarator()
	}
	p.SetState(519)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserComma {
		{
			p.SetState(515)
			p.Match(CParserComma)
		}
		{
			p.SetState(516)
			p.StructDeclarator()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyStructDeclaratorContext() *StructDeclaratorContext {
	var p = new(StructDeclaratorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_structDeclarator
	return p
}

func (*StructDeclaratorContext) IsStructDeclaratorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_structDeclarator

	return p
}

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

func (s *StructDeclaratorContext) Declarator() IDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclaratorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclaratorContext)
}

func (s *StructDeclaratorContext) Colon() antlr.TerminalNode {
	return s.GetToken(CParserColon, 0)
}

func (s *StructDeclaratorContext) ConstantExpression() IConstantExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantExpressionContext)
}

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

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

func (s *StructDeclaratorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterStructDeclarator(s)
	}
}

func (s *StructDeclaratorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitStructDeclarator(s)
	}
}

func (p *CParser) StructDeclarator() (localctx IStructDeclaratorContext) {
	this := p
	_ = this

	localctx = NewStructDeclaratorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 76, CParserRULE_structDeclarator)
	var _la int

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

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

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

		if (((_la-59)&-(0x1f+1)) == 0 && ((1<<uint((_la-59)))&((1<<(CParserLeftParen-59))|(1<<(CParserStar-59))|(1<<(CParserCaret-59)))) != 0) || _la == CParserIdentifier {
			{
				p.SetState(523)
				p.Declarator()
			}

		}
		{
			p.SetState(526)
			p.Match(CParserColon)
		}
		{
			p.SetState(527)
			p.ConstantExpression()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyEnumSpecifierContext() *EnumSpecifierContext {
	var p = new(EnumSpecifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_enumSpecifier
	return p
}

func (*EnumSpecifierContext) IsEnumSpecifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_enumSpecifier

	return p
}

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

func (s *EnumSpecifierContext) Enum() antlr.TerminalNode {
	return s.GetToken(CParserEnum, 0)
}

func (s *EnumSpecifierContext) LeftBrace() antlr.TerminalNode {
	return s.GetToken(CParserLeftBrace, 0)
}

func (s *EnumSpecifierContext) EnumeratorList() IEnumeratorListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumeratorListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumeratorListContext)
}

func (s *EnumSpecifierContext) RightBrace() antlr.TerminalNode {
	return s.GetToken(CParserRightBrace, 0)
}

func (s *EnumSpecifierContext) Identifier() antlr.TerminalNode {
	return s.GetToken(CParserIdentifier, 0)
}

func (s *EnumSpecifierContext) Comma() antlr.TerminalNode {
	return s.GetToken(CParserComma, 0)
}

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

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

func (s *EnumSpecifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterEnumSpecifier(s)
	}
}

func (s *EnumSpecifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitEnumSpecifier(s)
	}
}

func (p *CParser) EnumSpecifier() (localctx IEnumSpecifierContext) {
	this := p
	_ = this

	localctx = NewEnumSpecifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, CParserRULE_enumSpecifier)
	var _la int

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

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

		if _la == CParserIdentifier {
			{
				p.SetState(531)
				p.Match(CParserIdentifier)
			}

		}
		{
			p.SetState(534)
			p.Match(CParserLeftBrace)
		}
		{
			p.SetState(535)
			p.EnumeratorList()
		}
		p.SetState(537)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == CParserComma {
			{
				p.SetState(536)
				p.Match(CParserComma)
			}

		}
		{
			p.SetState(539)
			p.Match(CParserRightBrace)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(541)
			p.Match(CParserEnum)
		}
		{
			p.SetState(542)
			p.Match(CParserIdentifier)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyEnumeratorListContext() *EnumeratorListContext {
	var p = new(EnumeratorListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_enumeratorList
	return p
}

func (*EnumeratorListContext) IsEnumeratorListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_enumeratorList

	return p
}

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

func (s *EnumeratorListContext) AllEnumerator() []IEnumeratorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEnumeratorContext)(nil)).Elem())
	var tst = make([]IEnumeratorContext, len(ts))

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

	return tst
}

func (s *EnumeratorListContext) Enumerator(i int) IEnumeratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumeratorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEnumeratorContext)
}

func (s *EnumeratorListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(CParserComma)
}

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

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

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

func (s *EnumeratorListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterEnumeratorList(s)
	}
}

func (s *EnumeratorListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitEnumeratorList(s)
	}
}

func (p *CParser) EnumeratorList() (localctx IEnumeratorListContext) {
	this := p
	_ = this

	localctx = NewEnumeratorListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, CParserRULE_enumeratorList)

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

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

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(546)
				p.Match(CParserComma)
			}
			{
				p.SetState(547)
				p.Enumerator()
			}

		}
		p.SetState(552)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 51, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyEnumeratorContext() *EnumeratorContext {
	var p = new(EnumeratorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_enumerator
	return p
}

func (*EnumeratorContext) IsEnumeratorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_enumerator

	return p
}

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

func (s *EnumeratorContext) EnumerationConstant() IEnumerationConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEnumerationConstantContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEnumerationConstantContext)
}

func (s *EnumeratorContext) Assign() antlr.TerminalNode {
	return s.GetToken(CParserAssign, 0)
}

func (s *EnumeratorContext) ConstantExpression() IConstantExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantExpressionContext)
}

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

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

func (s *EnumeratorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterEnumerator(s)
	}
}

func (s *EnumeratorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitEnumerator(s)
	}
}

func (p *CParser) Enumerator() (localctx IEnumeratorContext) {
	this := p
	_ = this

	localctx = NewEnumeratorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, CParserRULE_enumerator)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(553)
		p.EnumerationConstant()
	}
	p.SetState(556)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CParserAssign {
		{
			p.SetState(554)
			p.Match(CParserAssign)
		}
		{
			p.SetState(555)
			p.ConstantExpression()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyEnumerationConstantContext() *EnumerationConstantContext {
	var p = new(EnumerationConstantContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_enumerationConstant
	return p
}

func (*EnumerationConstantContext) IsEnumerationConstantContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_enumerationConstant

	return p
}

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

func (s *EnumerationConstantContext) Identifier() antlr.TerminalNode {
	return s.GetToken(CParserIdentifier, 0)
}

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

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

func (s *EnumerationConstantContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterEnumerationConstant(s)
	}
}

func (s *EnumerationConstantContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitEnumerationConstant(s)
	}
}

func (p *CParser) EnumerationConstant() (localctx IEnumerationConstantContext) {
	this := p
	_ = this

	localctx = NewEnumerationConstantContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 84, CParserRULE_enumerationConstant)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(558)
		p.Match(CParserIdentifier)
	}

	return localctx
}

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

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

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

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

func NewEmptyAtomicTypeSpecifierContext() *AtomicTypeSpecifierContext {
	var p = new(AtomicTypeSpecifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_atomicTypeSpecifier
	return p
}

func (*AtomicTypeSpecifierContext) IsAtomicTypeSpecifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_atomicTypeSpecifier

	return p
}

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

func (s *AtomicTypeSpecifierContext) Atomic() antlr.TerminalNode {
	return s.GetToken(CParserAtomic, 0)
}

func (s *AtomicTypeSpecifierContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *AtomicTypeSpecifierContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

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

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

func (s *AtomicTypeSpecifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterAtomicTypeSpecifier(s)
	}
}

func (s *AtomicTypeSpecifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitAtomicTypeSpecifier(s)
	}
}

func (p *CParser) AtomicTypeSpecifier() (localctx IAtomicTypeSpecifierContext) {
	this := p
	_ = this

	localctx = NewAtomicTypeSpecifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, CParserRULE_atomicTypeSpecifier)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(560)
		p.Match(CParserAtomic)
	}
	{
		p.SetState(561)
		p.Match(CParserLeftParen)
	}
	{
		p.SetState(562)
		p.TypeName()
	}
	{
		p.SetState(563)
		p.Match(CParserRightParen)
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeQualifierContext() *TypeQualifierContext {
	var p = new(TypeQualifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_typeQualifier
	return p
}

func (*TypeQualifierContext) IsTypeQualifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_typeQualifier

	return p
}

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

func (s *TypeQualifierContext) Const() antlr.TerminalNode {
	return s.GetToken(CParserConst, 0)
}

func (s *TypeQualifierContext) Restrict() antlr.TerminalNode {
	return s.GetToken(CParserRestrict, 0)
}

func (s *TypeQualifierContext) Volatile() antlr.TerminalNode {
	return s.GetToken(CParserVolatile, 0)
}

func (s *TypeQualifierContext) Atomic() antlr.TerminalNode {
	return s.GetToken(CParserAtomic, 0)
}

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

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

func (s *TypeQualifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterTypeQualifier(s)
	}
}

func (s *TypeQualifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitTypeQualifier(s)
	}
}

func (p *CParser) TypeQualifier() (localctx ITypeQualifierContext) {
	this := p
	_ = this

	localctx = NewTypeQualifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, CParserRULE_typeQualifier)
	var _la int

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

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

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

		if !(_la == CParserConst || (((_la-35)&-(0x1f+1)) == 0 && ((1<<uint((_la-35)))&((1<<(CParserRestrict-35))|(1<<(CParserVolatile-35))|(1<<(CParserAtomic-35)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

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

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

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

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

func NewEmptyFunctionSpecifierContext() *FunctionSpecifierContext {
	var p = new(FunctionSpecifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_functionSpecifier
	return p
}

func (*FunctionSpecifierContext) IsFunctionSpecifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_functionSpecifier

	return p
}

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

func (s *FunctionSpecifierContext) Inline() antlr.TerminalNode {
	return s.GetToken(CParserInline, 0)
}

func (s *FunctionSpecifierContext) Noreturn() antlr.TerminalNode {
	return s.GetToken(CParserNoreturn, 0)
}

func (s *FunctionSpecifierContext) GccAttributeSpecifier() IGccAttributeSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGccAttributeSpecifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGccAttributeSpecifierContext)
}

func (s *FunctionSpecifierContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

func (s *FunctionSpecifierContext) Identifier() antlr.TerminalNode {
	return s.GetToken(CParserIdentifier, 0)
}

func (s *FunctionSpecifierContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

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

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

func (s *FunctionSpecifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterFunctionSpecifier(s)
	}
}

func (s *FunctionSpecifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitFunctionSpecifier(s)
	}
}

func (p *CParser) FunctionSpecifier() (localctx IFunctionSpecifierContext) {
	this := p
	_ = this

	localctx = NewFunctionSpecifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, CParserRULE_functionSpecifier)
	var _la int

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

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

	switch p.GetTokenStream().LA(1) {
	case CParserT__7, CParserT__8, CParserInline, CParserNoreturn:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(567)
			_la = p.GetTokenStream().LA(1)

			if !((((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__7)|(1<<CParserT__8)|(1<<CParserInline))) != 0) || _la == CParserNoreturn) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	case CParserT__11:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(568)
			p.GccAttributeSpecifier()
		}

	case CParserT__9:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(569)
			p.Match(CParserT__9)
		}
		{
			p.SetState(570)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(571)
			p.Match(CParserIdentifier)
		}
		{
			p.SetState(572)
			p.Match(CParserRightParen)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAlignmentSpecifierContext() *AlignmentSpecifierContext {
	var p = new(AlignmentSpecifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_alignmentSpecifier
	return p
}

func (*AlignmentSpecifierContext) IsAlignmentSpecifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_alignmentSpecifier

	return p
}

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

func (s *AlignmentSpecifierContext) Alignas() antlr.TerminalNode {
	return s.GetToken(CParserAlignas, 0)
}

func (s *AlignmentSpecifierContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

func (s *AlignmentSpecifierContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITypeNameContext)
}

func (s *AlignmentSpecifierContext) ConstantExpression() IConstantExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantExpressionContext)
}

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

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

func (s *AlignmentSpecifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterAlignmentSpecifier(s)
	}
}

func (s *AlignmentSpecifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitAlignmentSpecifier(s)
	}
}

func (p *CParser) AlignmentSpecifier() (localctx IAlignmentSpecifierContext) {
	this := p
	_ = this

	localctx = NewAlignmentSpecifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, CParserRULE_alignmentSpecifier)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(575)
		p.Match(CParserAlignas)
	}
	{
		p.SetState(576)
		p.Match(CParserLeftParen)
	}
	p.SetState(579)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 54, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(577)
			p.TypeName()
		}

	case 2:
		{
			p.SetState(578)
			p.ConstantExpression()
		}

	}
	{
		p.SetState(581)
		p.Match(CParserRightParen)
	}

	return localctx
}

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

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

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

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

func NewEmptyDeclaratorContext() *DeclaratorContext {
	var p = new(DeclaratorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_declarator
	return p
}

func (*DeclaratorContext) IsDeclaratorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_declarator

	return p
}

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

func (s *DeclaratorContext) DirectDeclarator() IDirectDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDirectDeclaratorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDirectDeclaratorContext)
}

func (s *DeclaratorContext) Pointer() IPointerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPointerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPointerContext)
}

func (s *DeclaratorContext) AllGccDeclaratorExtension() []IGccDeclaratorExtensionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IGccDeclaratorExtensionContext)(nil)).Elem())
	var tst = make([]IGccDeclaratorExtensionContext, len(ts))

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

	return tst
}

func (s *DeclaratorContext) GccDeclaratorExtension(i int) IGccDeclaratorExtensionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGccDeclaratorExtensionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IGccDeclaratorExtensionContext)
}

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

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

func (s *DeclaratorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterDeclarator(s)
	}
}

func (s *DeclaratorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitDeclarator(s)
	}
}

func (p *CParser) Declarator() (localctx IDeclaratorContext) {
	this := p
	_ = this

	localctx = NewDeclaratorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, CParserRULE_declarator)
	var _la int

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

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

	if _la == CParserStar || _la == CParserCaret {
		{
			p.SetState(583)
			p.Pointer()
		}

	}
	{
		p.SetState(586)
		p.directDeclarator(0)
	}
	p.SetState(590)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 56, p.GetParserRuleContext())

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

		}
		p.SetState(592)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 56, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyDirectDeclaratorContext() *DirectDeclaratorContext {
	var p = new(DirectDeclaratorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_directDeclarator
	return p
}

func (*DirectDeclaratorContext) IsDirectDeclaratorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_directDeclarator

	return p
}

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

func (s *DirectDeclaratorContext) Identifier() antlr.TerminalNode {
	return s.GetToken(CParserIdentifier, 0)
}

func (s *DirectDeclaratorContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

func (s *DirectDeclaratorContext) Declarator() IDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclaratorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclaratorContext)
}

func (s *DirectDeclaratorContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

func (s *DirectDeclaratorContext) Colon() antlr.TerminalNode {
	return s.GetToken(CParserColon, 0)
}

func (s *DirectDeclaratorContext) DigitSequence() antlr.TerminalNode {
	return s.GetToken(CParserDigitSequence, 0)
}

func (s *DirectDeclaratorContext) Pointer() IPointerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPointerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPointerContext)
}

func (s *DirectDeclaratorContext) DirectDeclarator() IDirectDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDirectDeclaratorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDirectDeclaratorContext)
}

func (s *DirectDeclaratorContext) TypeSpecifier() ITypeSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeSpecifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeSpecifierContext)
}

func (s *DirectDeclaratorContext) LeftBracket() antlr.TerminalNode {
	return s.GetToken(CParserLeftBracket, 0)
}

func (s *DirectDeclaratorContext) RightBracket() antlr.TerminalNode {
	return s.GetToken(CParserRightBracket, 0)
}

func (s *DirectDeclaratorContext) TypeQualifierList() ITypeQualifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeQualifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeQualifierListContext)
}

func (s *DirectDeclaratorContext) AssignmentExpression() IAssignmentExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentExpressionContext)
}

func (s *DirectDeclaratorContext) Static() antlr.TerminalNode {
	return s.GetToken(CParserStatic, 0)
}

func (s *DirectDeclaratorContext) Star() antlr.TerminalNode {
	return s.GetToken(CParserStar, 0)
}

func (s *DirectDeclaratorContext) ParameterTypeList() IParameterTypeListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParameterTypeListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParameterTypeListContext)
}

func (s *DirectDeclaratorContext) IdentifierList() IIdentifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIdentifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIdentifierListContext)
}

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

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

func (s *DirectDeclaratorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterDirectDeclarator(s)
	}
}

func (s *DirectDeclaratorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitDirectDeclarator(s)
	}
}

func (p *CParser) DirectDeclarator() (localctx IDirectDeclaratorContext) {
	return p.directDeclarator(0)
}

func (p *CParser) directDeclarator(_p int) (localctx IDirectDeclaratorContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewDirectDeclaratorContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IDirectDeclaratorContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 96
	p.EnterRecursionRule(localctx, 96, CParserRULE_directDeclarator, _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(610)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 58, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(594)
			p.Match(CParserIdentifier)
		}

	case 2:
		{
			p.SetState(595)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(596)
			p.Declarator()
		}
		{
			p.SetState(597)
			p.Match(CParserRightParen)
		}

	case 3:
		{
			p.SetState(599)
			p.Match(CParserIdentifier)
		}
		{
			p.SetState(600)
			p.Match(CParserColon)
		}
		{
			p.SetState(601)
			p.Match(CParserDigitSequence)
		}

	case 4:
		{
			p.SetState(602)
			p.Match(CParserLeftParen)
		}
		p.SetState(604)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserT__6)|(1<<CParserChar)|(1<<CParserDouble)|(1<<CParserEnum)|(1<<CParserFloat))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserStruct-32))|(1<<(CParserUnion-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserAtomic-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32)))) != 0) || _la == CParserIdentifier {
			{
				p.SetState(603)
				p.typeSpecifier(0)
			}

		}
		{
			p.SetState(606)
			p.Pointer()
		}
		{
			p.SetState(607)
			p.directDeclarator(0)
		}
		{
			p.SetState(608)
			p.Match(CParserRightParen)
		}

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

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(655)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 64, p.GetParserRuleContext()) {
			case 1:
				localctx = NewDirectDeclaratorContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, CParserRULE_directDeclarator)
				p.SetState(612)

				if !(p.Precpred(p.GetParserRuleContext(), 8)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", ""))
				}
				{
					p.SetState(613)
					p.Match(CParserLeftBracket)
				}
				p.SetState(615)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == CParserConst || (((_la-35)&-(0x1f+1)) == 0 && ((1<<uint((_la-35)))&((1<<(CParserRestrict-35))|(1<<(CParserVolatile-35))|(1<<(CParserAtomic-35)))) != 0) {
					{
						p.SetState(614)
						p.TypeQualifierList()
					}

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

				if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2))) != 0) || (((_la-39)&-(0x1f+1)) == 0 && ((1<<uint((_la-39)))&((1<<(CParserSizeof-39))|(1<<(CParserAlignof-39))|(1<<(CParserGeneric-39))|(1<<(CParserLeftParen-39)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserPlusPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserMinusMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserAndAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71)))) != 0) || (((_la-105)&-(0x1f+1)) == 0 && ((1<<uint((_la-105)))&((1<<(CParserIdentifier-105))|(1<<(CParserConstant-105))|(1<<(CParserDigitSequence-105))|(1<<(CParserStringLiteral-105)))) != 0) {
					{
						p.SetState(617)
						p.AssignmentExpression()
					}

				}
				{
					p.SetState(620)
					p.Match(CParserRightBracket)
				}

			case 2:
				localctx = NewDirectDeclaratorContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, CParserRULE_directDeclarator)
				p.SetState(621)

				if !(p.Precpred(p.GetParserRuleContext(), 7)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", ""))
				}
				{
					p.SetState(622)
					p.Match(CParserLeftBracket)
				}
				{
					p.SetState(623)
					p.Match(CParserStatic)
				}
				p.SetState(625)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == CParserConst || (((_la-35)&-(0x1f+1)) == 0 && ((1<<uint((_la-35)))&((1<<(CParserRestrict-35))|(1<<(CParserVolatile-35))|(1<<(CParserAtomic-35)))) != 0) {
					{
						p.SetState(624)
						p.TypeQualifierList()
					}

				}
				{
					p.SetState(627)
					p.AssignmentExpression()
				}
				{
					p.SetState(628)
					p.Match(CParserRightBracket)
				}

			case 3:
				localctx = NewDirectDeclaratorContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, CParserRULE_directDeclarator)
				p.SetState(630)

				if !(p.Precpred(p.GetParserRuleContext(), 6)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", ""))
				}
				{
					p.SetState(631)
					p.Match(CParserLeftBracket)
				}
				{
					p.SetState(632)
					p.TypeQualifierList()
				}
				{
					p.SetState(633)
					p.Match(CParserStatic)
				}
				{
					p.SetState(634)
					p.AssignmentExpression()
				}
				{
					p.SetState(635)
					p.Match(CParserRightBracket)
				}

			case 4:
				localctx = NewDirectDeclaratorContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, CParserRULE_directDeclarator)
				p.SetState(637)

				if !(p.Precpred(p.GetParserRuleContext(), 5)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
				}
				{
					p.SetState(638)
					p.Match(CParserLeftBracket)
				}
				p.SetState(640)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == CParserConst || (((_la-35)&-(0x1f+1)) == 0 && ((1<<uint((_la-35)))&((1<<(CParserRestrict-35))|(1<<(CParserVolatile-35))|(1<<(CParserAtomic-35)))) != 0) {
					{
						p.SetState(639)
						p.TypeQualifierList()
					}

				}
				{
					p.SetState(642)
					p.Match(CParserStar)
				}
				{
					p.SetState(643)
					p.Match(CParserRightBracket)
				}

			case 5:
				localctx = NewDirectDeclaratorContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, CParserRULE_directDeclarator)
				p.SetState(644)

				if !(p.Precpred(p.GetParserRuleContext(), 4)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
				}
				{
					p.SetState(645)
					p.Match(CParserLeftParen)
				}
				{
					p.SetState(646)
					p.ParameterTypeList()
				}
				{
					p.SetState(647)
					p.Match(CParserRightParen)
				}

			case 6:
				localctx = NewDirectDeclaratorContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, CParserRULE_directDeclarator)
				p.SetState(649)

				if !(p.Precpred(p.GetParserRuleContext(), 3)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
				}
				{
					p.SetState(650)
					p.Match(CParserLeftParen)
				}
				p.SetState(652)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == CParserIdentifier {
					{
						p.SetState(651)
						p.IdentifierList()
					}

				}
				{
					p.SetState(654)
					p.Match(CParserRightParen)
				}

			}

		}
		p.SetState(659)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 65, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyGccDeclaratorExtensionContext() *GccDeclaratorExtensionContext {
	var p = new(GccDeclaratorExtensionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_gccDeclaratorExtension
	return p
}

func (*GccDeclaratorExtensionContext) IsGccDeclaratorExtensionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_gccDeclaratorExtension

	return p
}

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

func (s *GccDeclaratorExtensionContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

func (s *GccDeclaratorExtensionContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

func (s *GccDeclaratorExtensionContext) AllStringLiteral() []antlr.TerminalNode {
	return s.GetTokens(CParserStringLiteral)
}

func (s *GccDeclaratorExtensionContext) StringLiteral(i int) antlr.TerminalNode {
	return s.GetToken(CParserStringLiteral, i)
}

func (s *GccDeclaratorExtensionContext) GccAttributeSpecifier() IGccAttributeSpecifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGccAttributeSpecifierContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGccAttributeSpecifierContext)
}

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

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

func (s *GccDeclaratorExtensionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterGccDeclaratorExtension(s)
	}
}

func (s *GccDeclaratorExtensionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitGccDeclaratorExtension(s)
	}
}

func (p *CParser) GccDeclaratorExtension() (localctx IGccDeclaratorExtensionContext) {
	this := p
	_ = this

	localctx = NewGccDeclaratorExtensionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 98, CParserRULE_gccDeclaratorExtension)
	var _la int

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

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

	switch p.GetTokenStream().LA(1) {
	case CParserT__10:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(660)
			p.Match(CParserT__10)
		}
		{
			p.SetState(661)
			p.Match(CParserLeftParen)
		}
		p.SetState(663)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for ok := true; ok; ok = _la == CParserStringLiteral {
			{
				p.SetState(662)
				p.Match(CParserStringLiteral)
			}

			p.SetState(665)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(667)
			p.Match(CParserRightParen)
		}

	case CParserT__11:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(668)
			p.GccAttributeSpecifier()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyGccAttributeSpecifierContext() *GccAttributeSpecifierContext {
	var p = new(GccAttributeSpecifierContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_gccAttributeSpecifier
	return p
}

func (*GccAttributeSpecifierContext) IsGccAttributeSpecifierContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_gccAttributeSpecifier

	return p
}

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

func (s *GccAttributeSpecifierContext) AllLeftParen() []antlr.TerminalNode {
	return s.GetTokens(CParserLeftParen)
}

func (s *GccAttributeSpecifierContext) LeftParen(i int) antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, i)
}

func (s *GccAttributeSpecifierContext) GccAttributeList() IGccAttributeListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGccAttributeListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGccAttributeListContext)
}

func (s *GccAttributeSpecifierContext) AllRightParen() []antlr.TerminalNode {
	return s.GetTokens(CParserRightParen)
}

func (s *GccAttributeSpecifierContext) RightParen(i int) antlr.TerminalNode {
	return s.GetToken(CParserRightParen, i)
}

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

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

func (s *GccAttributeSpecifierContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterGccAttributeSpecifier(s)
	}
}

func (s *GccAttributeSpecifierContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitGccAttributeSpecifier(s)
	}
}

func (p *CParser) GccAttributeSpecifier() (localctx IGccAttributeSpecifierContext) {
	this := p
	_ = this

	localctx = NewGccAttributeSpecifierContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, CParserRULE_gccAttributeSpecifier)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(671)
		p.Match(CParserT__11)
	}
	{
		p.SetState(672)
		p.Match(CParserLeftParen)
	}
	{
		p.SetState(673)
		p.Match(CParserLeftParen)
	}
	{
		p.SetState(674)
		p.GccAttributeList()
	}
	{
		p.SetState(675)
		p.Match(CParserRightParen)
	}
	{
		p.SetState(676)
		p.Match(CParserRightParen)
	}

	return localctx
}

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

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

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

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

func NewEmptyGccAttributeListContext() *GccAttributeListContext {
	var p = new(GccAttributeListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_gccAttributeList
	return p
}

func (*GccAttributeListContext) IsGccAttributeListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_gccAttributeList

	return p
}

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

func (s *GccAttributeListContext) AllGccAttribute() []IGccAttributeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IGccAttributeContext)(nil)).Elem())
	var tst = make([]IGccAttributeContext, len(ts))

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

	return tst
}

func (s *GccAttributeListContext) GccAttribute(i int) IGccAttributeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGccAttributeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IGccAttributeContext)
}

func (s *GccAttributeListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(CParserComma)
}

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

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

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

func (s *GccAttributeListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterGccAttributeList(s)
	}
}

func (s *GccAttributeListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitGccAttributeList(s)
	}
}

func (p *CParser) GccAttributeList() (localctx IGccAttributeListContext) {
	this := p
	_ = this

	localctx = NewGccAttributeListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, CParserRULE_gccAttributeList)
	var _la int

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

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

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

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2)|(1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserT__6)|(1<<CParserT__7)|(1<<CParserT__8)|(1<<CParserT__9)|(1<<CParserT__10)|(1<<CParserT__11)|(1<<CParserT__12)|(1<<CParserT__13)|(1<<CParserAuto)|(1<<CParserBreak)|(1<<CParserCase)|(1<<CParserChar)|(1<<CParserConst)|(1<<CParserContinue)|(1<<CParserDefault)|(1<<CParserDo)|(1<<CParserDouble)|(1<<CParserElse)|(1<<CParserEnum)|(1<<CParserExtern)|(1<<CParserFloat)|(1<<CParserFor)|(1<<CParserGoto)|(1<<CParserIf)|(1<<CParserInline))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserRegister-32))|(1<<(CParserRestrict-32))|(1<<(CParserReturn-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserSizeof-32))|(1<<(CParserStatic-32))|(1<<(CParserStruct-32))|(1<<(CParserSwitch-32))|(1<<(CParserTypedef-32))|(1<<(CParserUnion-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserVolatile-32))|(1<<(CParserWhile-32))|(1<<(CParserAlignas-32))|(1<<(CParserAlignof-32))|(1<<(CParserAtomic-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32))|(1<<(CParserGeneric-32))|(1<<(CParserImaginary-32))|(1<<(CParserNoreturn-32))|(1<<(CParserStaticAssert-32))|(1<<(CParserThreadLocal-32))|(1<<(CParserLeftBracket-32))|(1<<(CParserRightBracket-32))|(1<<(CParserLeftBrace-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(CParserRightBrace-64))|(1<<(CParserLess-64))|(1<<(CParserLessEqual-64))|(1<<(CParserGreater-64))|(1<<(CParserGreaterEqual-64))|(1<<(CParserLeftShift-64))|(1<<(CParserRightShift-64))|(1<<(CParserPlus-64))|(1<<(CParserPlusPlus-64))|(1<<(CParserMinus-64))|(1<<(CParserMinusMinus-64))|(1<<(CParserStar-64))|(1<<(CParserDiv-64))|(1<<(CParserMod-64))|(1<<(CParserAnd-64))|(1<<(CParserOr-64))|(1<<(CParserAndAnd-64))|(1<<(CParserOrOr-64))|(1<<(CParserCaret-64))|(1<<(CParserNot-64))|(1<<(CParserTilde-64))|(1<<(CParserQuestion-64))|(1<<(CParserColon-64))|(1<<(CParserSemi-64))|(1<<(CParserAssign-64))|(1<<(CParserStarAssign-64))|(1<<(CParserDivAssign-64))|(1<<(CParserModAssign-64))|(1<<(CParserPlusAssign-64))|(1<<(CParserMinusAssign-64))|(1<<(CParserLeftShiftAssign-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(CParserRightShiftAssign-96))|(1<<(CParserAndAssign-96))|(1<<(CParserXorAssign-96))|(1<<(CParserOrAssign-96))|(1<<(CParserEqual-96))|(1<<(CParserNotEqual-96))|(1<<(CParserArrow-96))|(1<<(CParserDot-96))|(1<<(CParserEllipsis-96))|(1<<(CParserIdentifier-96))|(1<<(CParserConstant-96))|(1<<(CParserDigitSequence-96))|(1<<(CParserStringLiteral-96))|(1<<(CParserComplexDefine-96))|(1<<(CParserIncludeDirective-96))|(1<<(CParserAsmBlock-96))|(1<<(CParserLineAfterPreprocessing-96))|(1<<(CParserLineDirective-96))|(1<<(CParserPragmaDirective-96))|(1<<(CParserWhitespace-96))|(1<<(CParserNewline-96))|(1<<(CParserBlockComment-96))|(1<<(CParserLineComment-96)))) != 0) {
		{
			p.SetState(678)
			p.GccAttribute()
		}

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

	for _la == CParserComma {
		{
			p.SetState(681)
			p.Match(CParserComma)
		}
		p.SetState(683)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2)|(1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserT__6)|(1<<CParserT__7)|(1<<CParserT__8)|(1<<CParserT__9)|(1<<CParserT__10)|(1<<CParserT__11)|(1<<CParserT__12)|(1<<CParserT__13)|(1<<CParserAuto)|(1<<CParserBreak)|(1<<CParserCase)|(1<<CParserChar)|(1<<CParserConst)|(1<<CParserContinue)|(1<<CParserDefault)|(1<<CParserDo)|(1<<CParserDouble)|(1<<CParserElse)|(1<<CParserEnum)|(1<<CParserExtern)|(1<<CParserFloat)|(1<<CParserFor)|(1<<CParserGoto)|(1<<CParserIf)|(1<<CParserInline))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserRegister-32))|(1<<(CParserRestrict-32))|(1<<(CParserReturn-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserSizeof-32))|(1<<(CParserStatic-32))|(1<<(CParserStruct-32))|(1<<(CParserSwitch-32))|(1<<(CParserTypedef-32))|(1<<(CParserUnion-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserVolatile-32))|(1<<(CParserWhile-32))|(1<<(CParserAlignas-32))|(1<<(CParserAlignof-32))|(1<<(CParserAtomic-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32))|(1<<(CParserGeneric-32))|(1<<(CParserImaginary-32))|(1<<(CParserNoreturn-32))|(1<<(CParserStaticAssert-32))|(1<<(CParserThreadLocal-32))|(1<<(CParserLeftBracket-32))|(1<<(CParserRightBracket-32))|(1<<(CParserLeftBrace-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(CParserRightBrace-64))|(1<<(CParserLess-64))|(1<<(CParserLessEqual-64))|(1<<(CParserGreater-64))|(1<<(CParserGreaterEqual-64))|(1<<(CParserLeftShift-64))|(1<<(CParserRightShift-64))|(1<<(CParserPlus-64))|(1<<(CParserPlusPlus-64))|(1<<(CParserMinus-64))|(1<<(CParserMinusMinus-64))|(1<<(CParserStar-64))|(1<<(CParserDiv-64))|(1<<(CParserMod-64))|(1<<(CParserAnd-64))|(1<<(CParserOr-64))|(1<<(CParserAndAnd-64))|(1<<(CParserOrOr-64))|(1<<(CParserCaret-64))|(1<<(CParserNot-64))|(1<<(CParserTilde-64))|(1<<(CParserQuestion-64))|(1<<(CParserColon-64))|(1<<(CParserSemi-64))|(1<<(CParserAssign-64))|(1<<(CParserStarAssign-64))|(1<<(CParserDivAssign-64))|(1<<(CParserModAssign-64))|(1<<(CParserPlusAssign-64))|(1<<(CParserMinusAssign-64))|(1<<(CParserLeftShiftAssign-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(CParserRightShiftAssign-96))|(1<<(CParserAndAssign-96))|(1<<(CParserXorAssign-96))|(1<<(CParserOrAssign-96))|(1<<(CParserEqual-96))|(1<<(CParserNotEqual-96))|(1<<(CParserArrow-96))|(1<<(CParserDot-96))|(1<<(CParserEllipsis-96))|(1<<(CParserIdentifier-96))|(1<<(CParserConstant-96))|(1<<(CParserDigitSequence-96))|(1<<(CParserStringLiteral-96))|(1<<(CParserComplexDefine-96))|(1<<(CParserIncludeDirective-96))|(1<<(CParserAsmBlock-96))|(1<<(CParserLineAfterPreprocessing-96))|(1<<(CParserLineDirective-96))|(1<<(CParserPragmaDirective-96))|(1<<(CParserWhitespace-96))|(1<<(CParserNewline-96))|(1<<(CParserBlockComment-96))|(1<<(CParserLineComment-96)))) != 0) {
			{
				p.SetState(682)
				p.GccAttribute()
			}

		}

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

	return localctx
}

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

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

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

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

func NewEmptyGccAttributeContext() *GccAttributeContext {
	var p = new(GccAttributeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_gccAttribute
	return p
}

func (*GccAttributeContext) IsGccAttributeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_gccAttribute

	return p
}

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

func (s *GccAttributeContext) Comma() antlr.TerminalNode {
	return s.GetToken(CParserComma, 0)
}

func (s *GccAttributeContext) AllLeftParen() []antlr.TerminalNode {
	return s.GetTokens(CParserLeftParen)
}

func (s *GccAttributeContext) LeftParen(i int) antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, i)
}

func (s *GccAttributeContext) AllRightParen() []antlr.TerminalNode {
	return s.GetTokens(CParserRightParen)
}

func (s *GccAttributeContext) RightParen(i int) antlr.TerminalNode {
	return s.GetToken(CParserRightParen, i)
}

func (s *GccAttributeContext) ArgumentExpressionList() IArgumentExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArgumentExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IArgumentExpressionListContext)
}

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

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

func (s *GccAttributeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterGccAttribute(s)
	}
}

func (s *GccAttributeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitGccAttribute(s)
	}
}

func (p *CParser) GccAttribute() (localctx IGccAttributeContext) {
	this := p
	_ = this

	localctx = NewGccAttributeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 104, CParserRULE_gccAttribute)
	var _la int

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

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

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

		if _la <= 0 || (((_la-59)&-(0x1f+1)) == 0 && ((1<<uint((_la-59)))&((1<<(CParserLeftParen-59))|(1<<(CParserRightParen-59))|(1<<(CParserComma-59)))) != 0) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(696)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CParserLeftParen {
		{
			p.SetState(691)
			p.Match(CParserLeftParen)
		}
		p.SetState(693)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2))) != 0) || (((_la-39)&-(0x1f+1)) == 0 && ((1<<uint((_la-39)))&((1<<(CParserSizeof-39))|(1<<(CParserAlignof-39))|(1<<(CParserGeneric-39))|(1<<(CParserLeftParen-39)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserPlusPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserMinusMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserAndAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71)))) != 0) || (((_la-105)&-(0x1f+1)) == 0 && ((1<<uint((_la-105)))&((1<<(CParserIdentifier-105))|(1<<(CParserConstant-105))|(1<<(CParserDigitSequence-105))|(1<<(CParserStringLiteral-105)))) != 0) {
			{
				p.SetState(692)
				p.ArgumentExpressionList()
			}

		}
		{
			p.SetState(695)
			p.Match(CParserRightParen)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyNestedParenthesesBlockContext() *NestedParenthesesBlockContext {
	var p = new(NestedParenthesesBlockContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_nestedParenthesesBlock
	return p
}

func (*NestedParenthesesBlockContext) IsNestedParenthesesBlockContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_nestedParenthesesBlock

	return p
}

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

func (s *NestedParenthesesBlockContext) AllLeftParen() []antlr.TerminalNode {
	return s.GetTokens(CParserLeftParen)
}

func (s *NestedParenthesesBlockContext) LeftParen(i int) antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, i)
}

func (s *NestedParenthesesBlockContext) AllNestedParenthesesBlock() []INestedParenthesesBlockContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*INestedParenthesesBlockContext)(nil)).Elem())
	var tst = make([]INestedParenthesesBlockContext, len(ts))

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

	return tst
}

func (s *NestedParenthesesBlockContext) NestedParenthesesBlock(i int) INestedParenthesesBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INestedParenthesesBlockContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(INestedParenthesesBlockContext)
}

func (s *NestedParenthesesBlockContext) AllRightParen() []antlr.TerminalNode {
	return s.GetTokens(CParserRightParen)
}

func (s *NestedParenthesesBlockContext) RightParen(i int) antlr.TerminalNode {
	return s.GetToken(CParserRightParen, i)
}

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

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

func (s *NestedParenthesesBlockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterNestedParenthesesBlock(s)
	}
}

func (s *NestedParenthesesBlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitNestedParenthesesBlock(s)
	}
}

func (p *CParser) NestedParenthesesBlock() (localctx INestedParenthesesBlockContext) {
	this := p
	_ = this

	localctx = NewNestedParenthesesBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, CParserRULE_nestedParenthesesBlock)
	var _la int

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

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

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

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2)|(1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserT__6)|(1<<CParserT__7)|(1<<CParserT__8)|(1<<CParserT__9)|(1<<CParserT__10)|(1<<CParserT__11)|(1<<CParserT__12)|(1<<CParserT__13)|(1<<CParserAuto)|(1<<CParserBreak)|(1<<CParserCase)|(1<<CParserChar)|(1<<CParserConst)|(1<<CParserContinue)|(1<<CParserDefault)|(1<<CParserDo)|(1<<CParserDouble)|(1<<CParserElse)|(1<<CParserEnum)|(1<<CParserExtern)|(1<<CParserFloat)|(1<<CParserFor)|(1<<CParserGoto)|(1<<CParserIf)|(1<<CParserInline))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserRegister-32))|(1<<(CParserRestrict-32))|(1<<(CParserReturn-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserSizeof-32))|(1<<(CParserStatic-32))|(1<<(CParserStruct-32))|(1<<(CParserSwitch-32))|(1<<(CParserTypedef-32))|(1<<(CParserUnion-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserVolatile-32))|(1<<(CParserWhile-32))|(1<<(CParserAlignas-32))|(1<<(CParserAlignof-32))|(1<<(CParserAtomic-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32))|(1<<(CParserGeneric-32))|(1<<(CParserImaginary-32))|(1<<(CParserNoreturn-32))|(1<<(CParserStaticAssert-32))|(1<<(CParserThreadLocal-32))|(1<<(CParserLeftParen-32))|(1<<(CParserLeftBracket-32))|(1<<(CParserRightBracket-32))|(1<<(CParserLeftBrace-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(CParserRightBrace-64))|(1<<(CParserLess-64))|(1<<(CParserLessEqual-64))|(1<<(CParserGreater-64))|(1<<(CParserGreaterEqual-64))|(1<<(CParserLeftShift-64))|(1<<(CParserRightShift-64))|(1<<(CParserPlus-64))|(1<<(CParserPlusPlus-64))|(1<<(CParserMinus-64))|(1<<(CParserMinusMinus-64))|(1<<(CParserStar-64))|(1<<(CParserDiv-64))|(1<<(CParserMod-64))|(1<<(CParserAnd-64))|(1<<(CParserOr-64))|(1<<(CParserAndAnd-64))|(1<<(CParserOrOr-64))|(1<<(CParserCaret-64))|(1<<(CParserNot-64))|(1<<(CParserTilde-64))|(1<<(CParserQuestion-64))|(1<<(CParserColon-64))|(1<<(CParserSemi-64))|(1<<(CParserComma-64))|(1<<(CParserAssign-64))|(1<<(CParserStarAssign-64))|(1<<(CParserDivAssign-64))|(1<<(CParserModAssign-64))|(1<<(CParserPlusAssign-64))|(1<<(CParserMinusAssign-64))|(1<<(CParserLeftShiftAssign-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(CParserRightShiftAssign-96))|(1<<(CParserAndAssign-96))|(1<<(CParserXorAssign-96))|(1<<(CParserOrAssign-96))|(1<<(CParserEqual-96))|(1<<(CParserNotEqual-96))|(1<<(CParserArrow-96))|(1<<(CParserDot-96))|(1<<(CParserEllipsis-96))|(1<<(CParserIdentifier-96))|(1<<(CParserConstant-96))|(1<<(CParserDigitSequence-96))|(1<<(CParserStringLiteral-96))|(1<<(CParserComplexDefine-96))|(1<<(CParserIncludeDirective-96))|(1<<(CParserAsmBlock-96))|(1<<(CParserLineAfterPreprocessing-96))|(1<<(CParserLineDirective-96))|(1<<(CParserPragmaDirective-96))|(1<<(CParserWhitespace-96))|(1<<(CParserNewline-96))|(1<<(CParserBlockComment-96))|(1<<(CParserLineComment-96)))) != 0) {
		p.SetState(703)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case CParserT__0, CParserT__1, CParserT__2, CParserT__3, CParserT__4, CParserT__5, CParserT__6, CParserT__7, CParserT__8, CParserT__9, CParserT__10, CParserT__11, CParserT__12, CParserT__13, CParserAuto, CParserBreak, CParserCase, CParserChar, CParserConst, CParserContinue, CParserDefault, CParserDo, CParserDouble, CParserElse, CParserEnum, CParserExtern, CParserFloat, CParserFor, CParserGoto, CParserIf, CParserInline, CParserInt, CParserLong, CParserRegister, CParserRestrict, CParserReturn, CParserShort, CParserSigned, CParserSizeof, CParserStatic, CParserStruct, CParserSwitch, CParserTypedef, CParserUnion, CParserUnsigned, CParserVoid, CParserVolatile, CParserWhile, CParserAlignas, CParserAlignof, CParserAtomic, CParserBool, CParserComplex, CParserGeneric, CParserImaginary, CParserNoreturn, CParserStaticAssert, CParserThreadLocal, CParserLeftBracket, CParserRightBracket, CParserLeftBrace, CParserRightBrace, CParserLess, CParserLessEqual, CParserGreater, CParserGreaterEqual, CParserLeftShift, CParserRightShift, CParserPlus, CParserPlusPlus, CParserMinus, CParserMinusMinus, CParserStar, CParserDiv, CParserMod, CParserAnd, CParserOr, CParserAndAnd, CParserOrOr, CParserCaret, CParserNot, CParserTilde, CParserQuestion, CParserColon, CParserSemi, CParserComma, CParserAssign, CParserStarAssign, CParserDivAssign, CParserModAssign, CParserPlusAssign, CParserMinusAssign, CParserLeftShiftAssign, CParserRightShiftAssign, CParserAndAssign, CParserXorAssign, CParserOrAssign, CParserEqual, CParserNotEqual, CParserArrow, CParserDot, CParserEllipsis, CParserIdentifier, CParserConstant, CParserDigitSequence, CParserStringLiteral, CParserComplexDefine, CParserIncludeDirective, CParserAsmBlock, CParserLineAfterPreprocessing, CParserLineDirective, CParserPragmaDirective, CParserWhitespace, CParserNewline, CParserBlockComment, CParserLineComment:
			{
				p.SetState(698)
				_la = p.GetTokenStream().LA(1)

				if _la <= 0 || _la == CParserLeftParen || _la == CParserRightParen {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}

		case CParserLeftParen:
			{
				p.SetState(699)
				p.Match(CParserLeftParen)
			}
			{
				p.SetState(700)
				p.NestedParenthesesBlock()
			}
			{
				p.SetState(701)
				p.Match(CParserRightParen)
			}

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

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

	return localctx
}

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

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

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

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

func NewEmptyPointerContext() *PointerContext {
	var p = new(PointerContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_pointer
	return p
}

func (*PointerContext) IsPointerContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_pointer

	return p
}

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

func (s *PointerContext) AllStar() []antlr.TerminalNode {
	return s.GetTokens(CParserStar)
}

func (s *PointerContext) Star(i int) antlr.TerminalNode {
	return s.GetToken(CParserStar, i)
}

func (s *PointerContext) AllCaret() []antlr.TerminalNode {
	return s.GetTokens(CParserCaret)
}

func (s *PointerContext) Caret(i int) antlr.TerminalNode {
	return s.GetToken(CParserCaret, i)
}

func (s *PointerContext) AllTypeQualifierList() []ITypeQualifierListContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeQualifierListContext)(nil)).Elem())
	var tst = make([]ITypeQualifierListContext, len(ts))

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

	return tst
}

func (s *PointerContext) TypeQualifierList(i int) ITypeQualifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeQualifierListContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeQualifierListContext)
}

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

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

func (s *PointerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterPointer(s)
	}
}

func (s *PointerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitPointer(s)
	}
}

func (p *CParser) Pointer() (localctx IPointerContext) {
	this := p
	_ = this

	localctx = NewPointerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, CParserRULE_pointer)
	var _la int

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

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

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(712)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(708)
				_la = p.GetTokenStream().LA(1)

				if !(_la == CParserStar || _la == CParserCaret) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			p.SetState(710)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 75, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(709)
					p.TypeQualifierList()
				}

			}

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

		p.SetState(714)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 76, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeQualifierListContext() *TypeQualifierListContext {
	var p = new(TypeQualifierListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_typeQualifierList
	return p
}

func (*TypeQualifierListContext) IsTypeQualifierListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_typeQualifierList

	return p
}

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

func (s *TypeQualifierListContext) AllTypeQualifier() []ITypeQualifierContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeQualifierContext)(nil)).Elem())
	var tst = make([]ITypeQualifierContext, len(ts))

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

	return tst
}

func (s *TypeQualifierListContext) TypeQualifier(i int) ITypeQualifierContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeQualifierContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITypeQualifierContext)
}

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

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

func (s *TypeQualifierListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterTypeQualifierList(s)
	}
}

func (s *TypeQualifierListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitTypeQualifierList(s)
	}
}

func (p *CParser) TypeQualifierList() (localctx ITypeQualifierListContext) {
	this := p
	_ = this

	localctx = NewTypeQualifierListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, CParserRULE_typeQualifierList)

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

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

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

		p.SetState(719)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 77, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyParameterTypeListContext() *ParameterTypeListContext {
	var p = new(ParameterTypeListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_parameterTypeList
	return p
}

func (*ParameterTypeListContext) IsParameterTypeListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_parameterTypeList

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IParameterListContext)
}

func (s *ParameterTypeListContext) Comma() antlr.TerminalNode {
	return s.GetToken(CParserComma, 0)
}

func (s *ParameterTypeListContext) Ellipsis() antlr.TerminalNode {
	return s.GetToken(CParserEllipsis, 0)
}

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

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

func (s *ParameterTypeListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterParameterTypeList(s)
	}
}

func (s *ParameterTypeListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitParameterTypeList(s)
	}
}

func (p *CParser) ParameterTypeList() (localctx IParameterTypeListContext) {
	this := p
	_ = this

	localctx = NewParameterTypeListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 112, CParserRULE_parameterTypeList)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(721)
		p.ParameterList()
	}
	p.SetState(724)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CParserComma {
		{
			p.SetState(722)
			p.Match(CParserComma)
		}
		{
			p.SetState(723)
			p.Match(CParserEllipsis)
		}

	}

	return localctx
}

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

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

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

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

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

func (*ParameterListContext) IsParameterListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_parameterList

	return p
}

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

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IParameterDeclarationContext)
}

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

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

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

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

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

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

func (p *CParser) ParameterList() (localctx IParameterListContext) {
	this := p
	_ = this

	localctx = NewParameterListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 114, CParserRULE_parameterList)

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

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

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(727)
				p.Match(CParserComma)
			}
			{
				p.SetState(728)
				p.ParameterDeclaration()
			}

		}
		p.SetState(733)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 79, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyParameterDeclarationContext() *ParameterDeclarationContext {
	var p = new(ParameterDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_parameterDeclaration
	return p
}

func (*ParameterDeclarationContext) IsParameterDeclarationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_parameterDeclaration

	return p
}

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

func (s *ParameterDeclarationContext) DeclarationSpecifiers() IDeclarationSpecifiersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclarationSpecifiersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclarationSpecifiersContext)
}

func (s *ParameterDeclarationContext) Declarator() IDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclaratorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclaratorContext)
}

func (s *ParameterDeclarationContext) DeclarationSpecifiers2() IDeclarationSpecifiers2Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclarationSpecifiers2Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclarationSpecifiers2Context)
}

func (s *ParameterDeclarationContext) AbstractDeclarator() IAbstractDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAbstractDeclaratorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAbstractDeclaratorContext)
}

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

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

func (s *ParameterDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterParameterDeclaration(s)
	}
}

func (s *ParameterDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitParameterDeclaration(s)
	}
}

func (p *CParser) ParameterDeclaration() (localctx IParameterDeclarationContext) {
	this := p
	_ = this

	localctx = NewParameterDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, CParserRULE_parameterDeclaration)
	var _la int

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

	defer func() {
		if err := recover(); err != nil {
			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(741)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 81, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(734)
			p.DeclarationSpecifiers()
		}
		{
			p.SetState(735)
			p.Declarator()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(737)
			p.DeclarationSpecifiers2()
		}
		p.SetState(739)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if ((_la-59)&-(0x1f+1)) == 0 && ((1<<uint((_la-59)))&((1<<(CParserLeftParen-59))|(1<<(CParserLeftBracket-59))|(1<<(CParserStar-59))|(1<<(CParserCaret-59)))) != 0 {
			{
				p.SetState(738)
				p.AbstractDeclarator()
			}

		}

	}

	return localctx
}

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

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

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

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

func NewEmptyIdentifierListContext() *IdentifierListContext {
	var p = new(IdentifierListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_identifierList
	return p
}

func (*IdentifierListContext) IsIdentifierListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_identifierList

	return p
}

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

func (s *IdentifierListContext) AllIdentifier() []antlr.TerminalNode {
	return s.GetTokens(CParserIdentifier)
}

func (s *IdentifierListContext) Identifier(i int) antlr.TerminalNode {
	return s.GetToken(CParserIdentifier, i)
}

func (s *IdentifierListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(CParserComma)
}

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

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

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

func (s *IdentifierListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterIdentifierList(s)
	}
}

func (s *IdentifierListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitIdentifierList(s)
	}
}

func (p *CParser) IdentifierList() (localctx IIdentifierListContext) {
	this := p
	_ = this

	localctx = NewIdentifierListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, CParserRULE_identifierList)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(743)
		p.Match(CParserIdentifier)
	}
	p.SetState(748)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserComma {
		{
			p.SetState(744)
			p.Match(CParserComma)
		}
		{
			p.SetState(745)
			p.Match(CParserIdentifier)
		}

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

	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 = CParserRULE_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 = CParserRULE_typeName

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(ISpecifierQualifierListContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IAbstractDeclaratorContext)
}

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

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

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

	localctx = NewTypeNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, CParserRULE_typeName)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(751)
		p.SpecifierQualifierList()
	}
	p.SetState(753)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-59)&-(0x1f+1)) == 0 && ((1<<uint((_la-59)))&((1<<(CParserLeftParen-59))|(1<<(CParserLeftBracket-59))|(1<<(CParserStar-59))|(1<<(CParserCaret-59)))) != 0 {
		{
			p.SetState(752)
			p.AbstractDeclarator()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyAbstractDeclaratorContext() *AbstractDeclaratorContext {
	var p = new(AbstractDeclaratorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_abstractDeclarator
	return p
}

func (*AbstractDeclaratorContext) IsAbstractDeclaratorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_abstractDeclarator

	return p
}

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

func (s *AbstractDeclaratorContext) Pointer() IPointerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPointerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPointerContext)
}

func (s *AbstractDeclaratorContext) DirectAbstractDeclarator() IDirectAbstractDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDirectAbstractDeclaratorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDirectAbstractDeclaratorContext)
}

func (s *AbstractDeclaratorContext) AllGccDeclaratorExtension() []IGccDeclaratorExtensionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IGccDeclaratorExtensionContext)(nil)).Elem())
	var tst = make([]IGccDeclaratorExtensionContext, len(ts))

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

	return tst
}

func (s *AbstractDeclaratorContext) GccDeclaratorExtension(i int) IGccDeclaratorExtensionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGccDeclaratorExtensionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IGccDeclaratorExtensionContext)
}

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

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

func (s *AbstractDeclaratorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterAbstractDeclarator(s)
	}
}

func (s *AbstractDeclaratorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitAbstractDeclarator(s)
	}
}

func (p *CParser) AbstractDeclarator() (localctx IAbstractDeclaratorContext) {
	this := p
	_ = this

	localctx = NewAbstractDeclaratorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 122, CParserRULE_abstractDeclarator)
	var _la int

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

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

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

		if _la == CParserStar || _la == CParserCaret {
			{
				p.SetState(756)
				p.Pointer()
			}

		}
		{
			p.SetState(759)
			p.directAbstractDeclarator(0)
		}
		p.SetState(763)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == CParserT__10 || _la == CParserT__11 {
			{
				p.SetState(760)
				p.GccDeclaratorExtension()
			}

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

	}

	return localctx
}

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

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

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

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

func NewEmptyDirectAbstractDeclaratorContext() *DirectAbstractDeclaratorContext {
	var p = new(DirectAbstractDeclaratorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_directAbstractDeclarator
	return p
}

func (*DirectAbstractDeclaratorContext) IsDirectAbstractDeclaratorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CParserRULE_directAbstractDeclarator

	return p
}

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

func (s *DirectAbstractDeclaratorContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

func (s *DirectAbstractDeclaratorContext) AbstractDeclarator() IAbstractDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAbstractDeclaratorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAbstractDeclaratorContext)
}

func (s *DirectAbstractDeclaratorContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

func (s *DirectAbstractDeclaratorContext) AllGccDeclaratorExtension() []IGccDeclaratorExtensionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IGccDeclaratorExtensionContext)(nil)).Elem())
	var tst = make([]IGccDeclaratorExtensionContext, len(ts))

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

	return tst
}

func (s *DirectAbstractDeclaratorContext) GccDeclaratorExtension(i int) IGccDeclaratorExtensionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGccDeclaratorExtensionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IGccDeclaratorExtensionContext)
}

func (s *DirectAbstractDeclaratorContext) LeftBracket() antlr.TerminalNode {
	return s.GetToken(CParserLeftBracket, 0)
}

func (s *DirectAbstractDeclaratorContext) RightBracket() antlr.TerminalNode {
	return s.GetToken(CParserRightBracket, 0)
}

func (s *DirectAbstractDeclaratorContext) TypeQualifierList() ITypeQualifierListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeQualifierListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeQualifierListContext)
}

func (s *DirectAbstractDeclaratorContext) AssignmentExpression() IAssignmentExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentExpressionContext)
}

func (s *DirectAbstractDeclaratorContext) Static() antlr.TerminalNode {
	return s.GetToken(CParserStatic, 0)
}

func (s *DirectAbstractDeclaratorContext) Star() antlr.TerminalNode {
	return s.GetToken(CParserStar, 0)
}

func (s *DirectAbstractDeclaratorContext) ParameterTypeList() IParameterTypeListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParameterTypeListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParameterTypeListContext)
}

func (s *DirectAbstractDeclaratorContext) DirectAbstractDeclarator() IDirectAbstractDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDirectAbstractDeclaratorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDirectAbstractDeclaratorContext)
}

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

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

func (s *DirectAbstractDeclaratorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterDirectAbstractDeclarator(s)
	}
}

func (s *DirectAbstractDeclaratorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitDirectAbstractDeclarator(s)
	}
}

func (p *CParser) DirectAbstractDeclarator() (localctx IDirectAbstractDeclaratorContext) {
	return p.directAbstractDeclarator(0)
}

func (p *CParser) directAbstractDeclarator(_p int) (localctx IDirectAbstractDeclaratorContext) {
	this := p
	_ = this

	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewDirectAbstractDeclaratorContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IDirectAbstractDeclaratorContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 124
	p.EnterRecursionRule(localctx, 124, CParserRULE_directAbstractDeclarator, _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(814)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 93, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(769)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(770)
			p.AbstractDeclarator()
		}
		{
			p.SetState(771)
			p.Match(CParserRightParen)
		}
		p.SetState(775)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 87, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(772)
					p.GccDeclaratorExtension()
				}

			}
			p.SetState(777)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 87, p.GetParserRuleContext())
		}

	case 2:
		{
			p.SetState(778)
			p.Match(CParserLeftBracket)
		}
		p.SetState(780)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == CParserConst || (((_la-35)&-(0x1f+1)) == 0 && ((1<<uint((_la-35)))&((1<<(CParserRestrict-35))|(1<<(CParserVolatile-35))|(1<<(CParserAtomic-35)))) != 0) {
			{
				p.SetState(779)
				p.TypeQualifierList()
			}

		}
		p.SetState(783)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2))) != 0) || (((_la-39)&-(0x1f+1)) == 0 && ((1<<uint((_la-39)))&((1<<(CParserSizeof-39))|(1<<(CParserAlignof-39))|(1<<(CParserGeneric-39))|(1<<(CParserLeftParen-39)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserPlusPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserMinusMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserAndAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71)))) != 0) || (((_la-105)&-(0x1f+1)) == 0 && ((1<<uint((_la-105)))&((1<<(CParserIdentifier-105))|(1<<(CParserConstant-105))|(1<<(CParserDigitSequence-105))|(1<<(CParserStringLiteral-105)))) != 0) {
			{
				p.SetState(782)
				p.AssignmentExpression()
			}

		}
		{
			p.SetState(785)
			p.Match(CParserRightBracket)
		}

	case 3:
		{
			p.SetState(786)
			p.Match(CParserLeftBracket)
		}
		{
			p.SetState(787)
			p.Match(CParserStatic)
		}
		p.SetState(789)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == CParserConst || (((_la-35)&-(0x1f+1)) == 0 && ((1<<uint((_la-35)))&((1<<(CParserRestrict-35))|(1<<(CParserVolatile-35))|(1<<(CParserAtomic-35)))) != 0) {
			{
				p.SetState(788)
				p.TypeQualifierList()
			}

		}
		{
			p.SetState(791)
			p.AssignmentExpression()
		}
		{
			p.SetState(792)
			p.Match(CParserRightBracket)
		}

	case 4:
		{
			p.SetState(794)
			p.Match(CParserLeftBracket)
		}
		{
			p.SetState(795)
			p.TypeQualifierList()
		}
		{
			p.SetState(796)
			p.Match(CParserStatic)
		}
		{
			p.SetState(797)
			p.AssignmentExpression()
		}
		{
			p.SetState(798)
			p.Match(CParserRightBracket)
		}

	case 5:
		{
			p.SetState(800)
			p.Match(CParserLeftBracket)
		}
		{
			p.SetState(801)
			p.Match(CParserStar)
		}
		{
			p.SetState(802)
			p.Match(CParserRightBracket)
		}

	case 6:
		{
			p.SetState(803)
			p.Match(CParserLeftParen)
		}
		p.SetState(805)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserT__6)|(1<<CParserT__7)|(1<<CParserT__8)|(1<<CParserT__9)|(1<<CParserT__11)|(1<<CParserAuto)|(1<<CParserChar)|(1<<CParserConst)|(1<<CParserDouble)|(1<<CParserEnum)|(1<<CParserExtern)|(1<<CParserFloat)|(1<<CParserInline))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserRegister-32))|(1<<(CParserRestrict-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserStatic-32))|(1<<(CParserStruct-32))|(1<<(CParserTypedef-32))|(1<<(CParserUnion-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserVolatile-32))|(1<<(CParserAlignas-32))|(1<<(CParserAtomic-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32))|(1<<(CParserNoreturn-32))|(1<<(CParserThreadLocal-32)))) != 0) || _la == CParserIdentifier {
			{
				p.SetState(804)
				p.ParameterTypeList()
			}

		}
		{
			p.SetState(807)
			p.Match(CParserRightParen)
		}
		p.SetState(811)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 92, p.GetParserRuleContext())

		for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1 {
				{
					p.SetState(808)
					p.GccDeclaratorExtension()
				}

			}
			p.SetState(813)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 92, p.GetParserRuleContext())
		}

	}
	p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
	p.SetState(859)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 100, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(857)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 99, p.GetParserRuleContext()) {
			case 1:
				localctx = NewDirectAbstractDeclaratorContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, CParserRULE_directAbstractDeclarator)
				p.SetState(816)

				if !(p.Precpred(p.GetParserRuleContext(), 5)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
				}
				{
					p.SetState(817)
					p.Match(CParserLeftBracket)
				}
				p.SetState(819)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == CParserConst || (((_la-35)&-(0x1f+1)) == 0 && ((1<<uint((_la-35)))&((1<<(CParserRestrict-35))|(1<<(CParserVolatile-35))|(1<<(CParserAtomic-35)))) != 0) {
					{
						p.SetState(818)
						p.TypeQualifierList()
					}

				}
				p.SetState(822)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2))) != 0) || (((_la-39)&-(0x1f+1)) == 0 && ((1<<uint((_la-39)))&((1<<(CParserSizeof-39))|(1<<(CParserAlignof-39))|(1<<(CParserGeneric-39))|(1<<(CParserLeftParen-39)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserPlusPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserMinusMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserAndAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71)))) != 0) || (((_la-105)&-(0x1f+1)) == 0 && ((1<<uint((_la-105)))&((1<<(CParserIdentifier-105))|(1<<(CParserConstant-105))|(1<<(CParserDigitSequence-105))|(1<<(CParserStringLiteral-105)))) != 0) {
					{
						p.SetState(821)
						p.AssignmentExpression()
					}

				}
				{
					p.SetState(824)
					p.Match(CParserRightBracket)
				}

			case 2:
				localctx = NewDirectAbstractDeclaratorContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, CParserRULE_directAbstractDeclarator)
				p.SetState(825)

				if !(p.Precpred(p.GetParserRuleContext(), 4)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
				}
				{
					p.SetState(826)
					p.Match(CParserLeftBracket)
				}
				{
					p.SetState(827)
					p.Match(CParserStatic)
				}
				p.SetState(829)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == CParserConst || (((_la-35)&-(0x1f+1)) == 0 && ((1<<uint((_la-35)))&((1<<(CParserRestrict-35))|(1<<(CParserVolatile-35))|(1<<(CParserAtomic-35)))) != 0) {
					{
						p.SetState(828)
						p.TypeQualifierList()
					}

				}
				{
					p.SetState(831)
					p.AssignmentExpression()
				}
				{
					p.SetState(832)
					p.Match(CParserRightBracket)
				}

			case 3:
				localctx = NewDirectAbstractDeclaratorContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, CParserRULE_directAbstractDeclarator)
				p.SetState(834)

				if !(p.Precpred(p.GetParserRuleContext(), 3)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
				}
				{
					p.SetState(835)
					p.Match(CParserLeftBracket)
				}
				{
					p.SetState(836)
					p.TypeQualifierList()
				}
				{
					p.SetState(837)
					p.Match(CParserStatic)
				}
				{
					p.SetState(838)
					p.AssignmentExpression()
				}
				{
					p.SetState(839)
					p.Match(CParserRightBracket)
				}

			case 4:
				localctx = NewDirectAbstractDeclaratorContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, CParserRULE_directAbstractDeclarator)
				p.SetState(841)

				if !(p.Precpred(p.GetParserRuleContext(), 2)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
				}
				{
					p.SetState(842)
					p.Match(CParserLeftBracket)
				}
				{
					p.SetState(843)
					p.Match(CParserStar)
				}
				{
					p.SetState(844)
					p.Match(CParserRightBracket)
				}

			case 5:
				localctx = NewDirectAbstractDeclaratorContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, CParserRULE_directAbstractDeclarator)
				p.SetState(845)

				if !(p.Precpred(p.GetParserRuleContext(), 1)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
				}
				{
					p.SetState(846)
					p.Match(CParserLeftParen)
				}
				p.SetState(848)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserT__6)|(1<<CParserT__7)|(1<<CParserT__8)|(1<<CParserT__9)|(1<<CParserT__11)|(1<<CParserAuto)|(1<<CParserChar)|(1<<CParserConst)|(1<<CParserDouble)|(1<<CParserEnum)|(1<<CParserExtern)|(1<<CParserFloat)|(1<<CParserInline))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserRegister-32))|(1<<(CParserRestrict-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserStatic-32))|(1<<(CParserStruct-32))|(1<<(CParserTypedef-32))|(1<<(CParserUnion-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserVolatile-32))|(1<<(CParserAlignas-32))|(1<<(CParserAtomic-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32))|(1<<(CParserNoreturn-32))|(1<<(CParserThreadLocal-32)))) != 0) || _la == CParserIdentifier {
					{
						p.SetState(847)
						p.ParameterTypeList()
					}

				}
				{
					p.SetState(850)
					p.Match(CParserRightParen)
				}
				p.SetState(854)
				p.GetErrorHandler().Sync(p)
				_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 98, p.GetParserRuleContext())

				for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
					if _alt == 1 {
						{
							p.SetState(851)
							p.GccDeclaratorExtension()
						}

					}
					p.SetState(856)
					p.GetErrorHandler().Sync(p)
					_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 98, p.GetParserRuleContext())
				}

			}

		}
		p.SetState(861)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 100, p.GetParserRuleContext())
	}

	return localctx
}

// ITypedefNameContext is an interface to support dynamic dispatch.
type ITypedefNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypedefNameContext differentiates from other interfaces.
	IsTypedefNameContext()
}

type TypedefNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTypedefNameContext() *TypedefNameContext {
	var p = new(TypedefNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_typedefName
	return p
}

func (*TypedefNameContext) IsTypedefNameContext() {}

func NewTypedefNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypedefNameContext {
	var p = new(TypedefNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_typedefName

	return p
}

func (s *TypedefNameContext) GetParser() antlr.Parser { return s.parser }

func (s *TypedefNameContext) Identifier() antlr.TerminalNode {
	return s.GetToken(CParserIdentifier, 0)
}

func (s *TypedefNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TypedefNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TypedefNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterTypedefName(s)
	}
}

func (s *TypedefNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitTypedefName(s)
	}
}

func (p *CParser) TypedefName() (localctx ITypedefNameContext) {
	this := p
	_ = this

	localctx = NewTypedefNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 126, CParserRULE_typedefName)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.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.Match(CParserIdentifier)
	}

	return localctx
}

// IInitializerContext is an interface to support dynamic dispatch.
type IInitializerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInitializerContext differentiates from other interfaces.
	IsInitializerContext()
}

type InitializerContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInitializerContext() *InitializerContext {
	var p = new(InitializerContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_initializer
	return p
}

func (*InitializerContext) IsInitializerContext() {}

func NewInitializerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InitializerContext {
	var p = new(InitializerContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_initializer

	return p
}

func (s *InitializerContext) GetParser() antlr.Parser { return s.parser }

func (s *InitializerContext) AssignmentExpression() IAssignmentExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentExpressionContext)
}

func (s *InitializerContext) LeftBrace() antlr.TerminalNode {
	return s.GetToken(CParserLeftBrace, 0)
}

func (s *InitializerContext) InitializerList() IInitializerListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitializerListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInitializerListContext)
}

func (s *InitializerContext) RightBrace() antlr.TerminalNode {
	return s.GetToken(CParserRightBrace, 0)
}

func (s *InitializerContext) Comma() antlr.TerminalNode {
	return s.GetToken(CParserComma, 0)
}

func (s *InitializerContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InitializerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InitializerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterInitializer(s)
	}
}

func (s *InitializerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitInitializer(s)
	}
}

func (p *CParser) Initializer() (localctx IInitializerContext) {
	this := p
	_ = this

	localctx = NewInitializerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 128, CParserRULE_initializer)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(872)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CParserT__0, CParserT__1, CParserT__2, CParserSizeof, CParserAlignof, CParserGeneric, CParserLeftParen, CParserPlus, CParserPlusPlus, CParserMinus, CParserMinusMinus, CParserStar, CParserAnd, CParserAndAnd, CParserNot, CParserTilde, CParserIdentifier, CParserConstant, CParserDigitSequence, CParserStringLiteral:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(864)
			p.AssignmentExpression()
		}

	case CParserLeftBrace:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(865)
			p.Match(CParserLeftBrace)
		}
		{
			p.SetState(866)
			p.InitializerList()
		}
		p.SetState(868)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == CParserComma {
			{
				p.SetState(867)
				p.Match(CParserComma)
			}

		}
		{
			p.SetState(870)
			p.Match(CParserRightBrace)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IInitializerListContext is an interface to support dynamic dispatch.
type IInitializerListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInitializerListContext differentiates from other interfaces.
	IsInitializerListContext()
}

type InitializerListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInitializerListContext() *InitializerListContext {
	var p = new(InitializerListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_initializerList
	return p
}

func (*InitializerListContext) IsInitializerListContext() {}

func NewInitializerListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InitializerListContext {
	var p = new(InitializerListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_initializerList

	return p
}

func (s *InitializerListContext) GetParser() antlr.Parser { return s.parser }

func (s *InitializerListContext) AllInitializer() []IInitializerContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInitializerContext)(nil)).Elem())
	var tst = make([]IInitializerContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IInitializerContext)
		}
	}

	return tst
}

func (s *InitializerListContext) Initializer(i int) IInitializerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitializerContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInitializerContext)
}

func (s *InitializerListContext) AllDesignation() []IDesignationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDesignationContext)(nil)).Elem())
	var tst = make([]IDesignationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IDesignationContext)
		}
	}

	return tst
}

func (s *InitializerListContext) Designation(i int) IDesignationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDesignationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDesignationContext)
}

func (s *InitializerListContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(CParserComma)
}

func (s *InitializerListContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(CParserComma, i)
}

func (s *InitializerListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InitializerListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InitializerListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterInitializerList(s)
	}
}

func (s *InitializerListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitInitializerList(s)
	}
}

func (p *CParser) InitializerList() (localctx IInitializerListContext) {
	this := p
	_ = this

	localctx = NewInitializerListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 130, CParserRULE_initializerList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != 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(875)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CParserLeftBracket || _la == CParserDot {
		{
			p.SetState(874)
			p.Designation()
		}

	}
	{
		p.SetState(877)
		p.Initializer()
	}
	p.SetState(885)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 105, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(878)
				p.Match(CParserComma)
			}
			p.SetState(880)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == CParserLeftBracket || _la == CParserDot {
				{
					p.SetState(879)
					p.Designation()
				}

			}
			{
				p.SetState(882)
				p.Initializer()
			}

		}
		p.SetState(887)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 105, p.GetParserRuleContext())
	}

	return localctx
}

// IDesignationContext is an interface to support dynamic dispatch.
type IDesignationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDesignationContext differentiates from other interfaces.
	IsDesignationContext()
}

type DesignationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDesignationContext() *DesignationContext {
	var p = new(DesignationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_designation
	return p
}

func (*DesignationContext) IsDesignationContext() {}

func NewDesignationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DesignationContext {
	var p = new(DesignationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_designation

	return p
}

func (s *DesignationContext) GetParser() antlr.Parser { return s.parser }

func (s *DesignationContext) DesignatorList() IDesignatorListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDesignatorListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDesignatorListContext)
}

func (s *DesignationContext) Assign() antlr.TerminalNode {
	return s.GetToken(CParserAssign, 0)
}

func (s *DesignationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DesignationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DesignationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterDesignation(s)
	}
}

func (s *DesignationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitDesignation(s)
	}
}

func (p *CParser) Designation() (localctx IDesignationContext) {
	this := p
	_ = this

	localctx = NewDesignationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 132, CParserRULE_designation)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(888)
		p.DesignatorList()
	}
	{
		p.SetState(889)
		p.Match(CParserAssign)
	}

	return localctx
}

// IDesignatorListContext is an interface to support dynamic dispatch.
type IDesignatorListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDesignatorListContext differentiates from other interfaces.
	IsDesignatorListContext()
}

type DesignatorListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDesignatorListContext() *DesignatorListContext {
	var p = new(DesignatorListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_designatorList
	return p
}

func (*DesignatorListContext) IsDesignatorListContext() {}

func NewDesignatorListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DesignatorListContext {
	var p = new(DesignatorListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_designatorList

	return p
}

func (s *DesignatorListContext) GetParser() antlr.Parser { return s.parser }

func (s *DesignatorListContext) AllDesignator() []IDesignatorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDesignatorContext)(nil)).Elem())
	var tst = make([]IDesignatorContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IDesignatorContext)
		}
	}

	return tst
}

func (s *DesignatorListContext) Designator(i int) IDesignatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDesignatorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDesignatorContext)
}

func (s *DesignatorListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DesignatorListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DesignatorListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterDesignatorList(s)
	}
}

func (s *DesignatorListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitDesignatorList(s)
	}
}

func (p *CParser) DesignatorList() (localctx IDesignatorListContext) {
	this := p
	_ = this

	localctx = NewDesignatorListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 134, CParserRULE_designatorList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(892)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == CParserLeftBracket || _la == CParserDot {
		{
			p.SetState(891)
			p.Designator()
		}

		p.SetState(894)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IDesignatorContext is an interface to support dynamic dispatch.
type IDesignatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDesignatorContext differentiates from other interfaces.
	IsDesignatorContext()
}

type DesignatorContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDesignatorContext() *DesignatorContext {
	var p = new(DesignatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_designator
	return p
}

func (*DesignatorContext) IsDesignatorContext() {}

func NewDesignatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DesignatorContext {
	var p = new(DesignatorContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_designator

	return p
}

func (s *DesignatorContext) GetParser() antlr.Parser { return s.parser }

func (s *DesignatorContext) LeftBracket() antlr.TerminalNode {
	return s.GetToken(CParserLeftBracket, 0)
}

func (s *DesignatorContext) ConstantExpression() IConstantExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantExpressionContext)
}

func (s *DesignatorContext) RightBracket() antlr.TerminalNode {
	return s.GetToken(CParserRightBracket, 0)
}

func (s *DesignatorContext) Dot() antlr.TerminalNode {
	return s.GetToken(CParserDot, 0)
}

func (s *DesignatorContext) Identifier() antlr.TerminalNode {
	return s.GetToken(CParserIdentifier, 0)
}

func (s *DesignatorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DesignatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DesignatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterDesignator(s)
	}
}

func (s *DesignatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitDesignator(s)
	}
}

func (p *CParser) Designator() (localctx IDesignatorContext) {
	this := p
	_ = this

	localctx = NewDesignatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 136, CParserRULE_designator)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(902)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CParserLeftBracket:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(896)
			p.Match(CParserLeftBracket)
		}
		{
			p.SetState(897)
			p.ConstantExpression()
		}
		{
			p.SetState(898)
			p.Match(CParserRightBracket)
		}

	case CParserDot:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(900)
			p.Match(CParserDot)
		}
		{
			p.SetState(901)
			p.Match(CParserIdentifier)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IStaticAssertDeclarationContext is an interface to support dynamic dispatch.
type IStaticAssertDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStaticAssertDeclarationContext differentiates from other interfaces.
	IsStaticAssertDeclarationContext()
}

type StaticAssertDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStaticAssertDeclarationContext() *StaticAssertDeclarationContext {
	var p = new(StaticAssertDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_staticAssertDeclaration
	return p
}

func (*StaticAssertDeclarationContext) IsStaticAssertDeclarationContext() {}

func NewStaticAssertDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StaticAssertDeclarationContext {
	var p = new(StaticAssertDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_staticAssertDeclaration

	return p
}

func (s *StaticAssertDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *StaticAssertDeclarationContext) StaticAssert() antlr.TerminalNode {
	return s.GetToken(CParserStaticAssert, 0)
}

func (s *StaticAssertDeclarationContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

func (s *StaticAssertDeclarationContext) ConstantExpression() IConstantExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantExpressionContext)
}

func (s *StaticAssertDeclarationContext) Comma() antlr.TerminalNode {
	return s.GetToken(CParserComma, 0)
}

func (s *StaticAssertDeclarationContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

func (s *StaticAssertDeclarationContext) Semi() antlr.TerminalNode {
	return s.GetToken(CParserSemi, 0)
}

func (s *StaticAssertDeclarationContext) AllStringLiteral() []antlr.TerminalNode {
	return s.GetTokens(CParserStringLiteral)
}

func (s *StaticAssertDeclarationContext) StringLiteral(i int) antlr.TerminalNode {
	return s.GetToken(CParserStringLiteral, i)
}

func (s *StaticAssertDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StaticAssertDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StaticAssertDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterStaticAssertDeclaration(s)
	}
}

func (s *StaticAssertDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitStaticAssertDeclaration(s)
	}
}

func (p *CParser) StaticAssertDeclaration() (localctx IStaticAssertDeclarationContext) {
	this := p
	_ = this

	localctx = NewStaticAssertDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 138, CParserRULE_staticAssertDeclaration)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(904)
		p.Match(CParserStaticAssert)
	}
	{
		p.SetState(905)
		p.Match(CParserLeftParen)
	}
	{
		p.SetState(906)
		p.ConstantExpression()
	}
	{
		p.SetState(907)
		p.Match(CParserComma)
	}
	p.SetState(909)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == CParserStringLiteral {
		{
			p.SetState(908)
			p.Match(CParserStringLiteral)
		}

		p.SetState(911)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(913)
		p.Match(CParserRightParen)
	}
	{
		p.SetState(914)
		p.Match(CParserSemi)
	}

	return localctx
}

// IStatementContext is an interface to support dynamic dispatch.
type IStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStatementContext differentiates from other interfaces.
	IsStatementContext()
}

type StatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStatementContext() *StatementContext {
	var p = new(StatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_statement
	return p
}

func (*StatementContext) IsStatementContext() {}

func NewStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementContext {
	var p = new(StatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_statement

	return p
}

func (s *StatementContext) GetParser() antlr.Parser { return s.parser }

func (s *StatementContext) LabeledStatement() ILabeledStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILabeledStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILabeledStatementContext)
}

func (s *StatementContext) CompoundStatement() ICompoundStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompoundStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICompoundStatementContext)
}

func (s *StatementContext) ExpressionStatement() IExpressionStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionStatementContext)
}

func (s *StatementContext) SelectionStatement() ISelectionStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelectionStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelectionStatementContext)
}

func (s *StatementContext) IterationStatement() IIterationStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIterationStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIterationStatementContext)
}

func (s *StatementContext) JumpStatement() IJumpStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IJumpStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IJumpStatementContext)
}

func (s *StatementContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

func (s *StatementContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

func (s *StatementContext) Semi() antlr.TerminalNode {
	return s.GetToken(CParserSemi, 0)
}

func (s *StatementContext) Volatile() antlr.TerminalNode {
	return s.GetToken(CParserVolatile, 0)
}

func (s *StatementContext) AllLogicalOrExpression() []ILogicalOrExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ILogicalOrExpressionContext)(nil)).Elem())
	var tst = make([]ILogicalOrExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ILogicalOrExpressionContext)
		}
	}

	return tst
}

func (s *StatementContext) LogicalOrExpression(i int) ILogicalOrExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILogicalOrExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ILogicalOrExpressionContext)
}

func (s *StatementContext) AllColon() []antlr.TerminalNode {
	return s.GetTokens(CParserColon)
}

func (s *StatementContext) Colon(i int) antlr.TerminalNode {
	return s.GetToken(CParserColon, i)
}

func (s *StatementContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(CParserComma)
}

func (s *StatementContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(CParserComma, i)
}

func (s *StatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterStatement(s)
	}
}

func (s *StatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitStatement(s)
	}
}

func (p *CParser) Statement() (localctx IStatementContext) {
	this := p
	_ = this

	localctx = NewStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 140, CParserRULE_statement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(953)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 114, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(916)
			p.LabeledStatement()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(917)
			p.CompoundStatement()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(918)
			p.ExpressionStatement()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(919)
			p.SelectionStatement()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(920)
			p.IterationStatement()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(921)
			p.JumpStatement()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(922)
			_la = p.GetTokenStream().LA(1)

			if !(_la == CParserT__10 || _la == CParserT__12) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(923)
			_la = p.GetTokenStream().LA(1)

			if !(_la == CParserT__13 || _la == CParserVolatile) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(924)
			p.Match(CParserLeftParen)
		}
		p.SetState(933)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2))) != 0) || (((_la-39)&-(0x1f+1)) == 0 && ((1<<uint((_la-39)))&((1<<(CParserSizeof-39))|(1<<(CParserAlignof-39))|(1<<(CParserGeneric-39))|(1<<(CParserLeftParen-39)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserPlusPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserMinusMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserAndAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71)))) != 0) || (((_la-105)&-(0x1f+1)) == 0 && ((1<<uint((_la-105)))&((1<<(CParserIdentifier-105))|(1<<(CParserConstant-105))|(1<<(CParserDigitSequence-105))|(1<<(CParserStringLiteral-105)))) != 0) {
			{
				p.SetState(925)
				p.LogicalOrExpression()
			}
			p.SetState(930)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == CParserComma {
				{
					p.SetState(926)
					p.Match(CParserComma)
				}
				{
					p.SetState(927)
					p.LogicalOrExpression()
				}

				p.SetState(932)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}

		}
		p.SetState(948)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == CParserColon {
			{
				p.SetState(935)
				p.Match(CParserColon)
			}
			p.SetState(944)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2))) != 0) || (((_la-39)&-(0x1f+1)) == 0 && ((1<<uint((_la-39)))&((1<<(CParserSizeof-39))|(1<<(CParserAlignof-39))|(1<<(CParserGeneric-39))|(1<<(CParserLeftParen-39)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserPlusPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserMinusMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserAndAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71)))) != 0) || (((_la-105)&-(0x1f+1)) == 0 && ((1<<uint((_la-105)))&((1<<(CParserIdentifier-105))|(1<<(CParserConstant-105))|(1<<(CParserDigitSequence-105))|(1<<(CParserStringLiteral-105)))) != 0) {
				{
					p.SetState(936)
					p.LogicalOrExpression()
				}
				p.SetState(941)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				for _la == CParserComma {
					{
						p.SetState(937)
						p.Match(CParserComma)
					}
					{
						p.SetState(938)
						p.LogicalOrExpression()
					}

					p.SetState(943)
					p.GetErrorHandler().Sync(p)
					_la = p.GetTokenStream().LA(1)
				}

			}

			p.SetState(950)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(951)
			p.Match(CParserRightParen)
		}
		{
			p.SetState(952)
			p.Match(CParserSemi)
		}

	}

	return localctx
}

// ILabeledStatementContext is an interface to support dynamic dispatch.
type ILabeledStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLabeledStatementContext differentiates from other interfaces.
	IsLabeledStatementContext()
}

type LabeledStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLabeledStatementContext() *LabeledStatementContext {
	var p = new(LabeledStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_labeledStatement
	return p
}

func (*LabeledStatementContext) IsLabeledStatementContext() {}

func NewLabeledStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LabeledStatementContext {
	var p = new(LabeledStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_labeledStatement

	return p
}

func (s *LabeledStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *LabeledStatementContext) Identifier() antlr.TerminalNode {
	return s.GetToken(CParserIdentifier, 0)
}

func (s *LabeledStatementContext) Colon() antlr.TerminalNode {
	return s.GetToken(CParserColon, 0)
}

func (s *LabeledStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *LabeledStatementContext) Case() antlr.TerminalNode {
	return s.GetToken(CParserCase, 0)
}

func (s *LabeledStatementContext) ConstantExpression() IConstantExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantExpressionContext)
}

func (s *LabeledStatementContext) Default() antlr.TerminalNode {
	return s.GetToken(CParserDefault, 0)
}

func (s *LabeledStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LabeledStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LabeledStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterLabeledStatement(s)
	}
}

func (s *LabeledStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitLabeledStatement(s)
	}
}

func (p *CParser) LabeledStatement() (localctx ILabeledStatementContext) {
	this := p
	_ = this

	localctx = NewLabeledStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 142, CParserRULE_labeledStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(966)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CParserIdentifier:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(955)
			p.Match(CParserIdentifier)
		}
		{
			p.SetState(956)
			p.Match(CParserColon)
		}
		{
			p.SetState(957)
			p.Statement()
		}

	case CParserCase:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(958)
			p.Match(CParserCase)
		}
		{
			p.SetState(959)
			p.ConstantExpression()
		}
		{
			p.SetState(960)
			p.Match(CParserColon)
		}
		{
			p.SetState(961)
			p.Statement()
		}

	case CParserDefault:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(963)
			p.Match(CParserDefault)
		}
		{
			p.SetState(964)
			p.Match(CParserColon)
		}
		{
			p.SetState(965)
			p.Statement()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// ICompoundStatementContext is an interface to support dynamic dispatch.
type ICompoundStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCompoundStatementContext differentiates from other interfaces.
	IsCompoundStatementContext()
}

type CompoundStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCompoundStatementContext() *CompoundStatementContext {
	var p = new(CompoundStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_compoundStatement
	return p
}

func (*CompoundStatementContext) IsCompoundStatementContext() {}

func NewCompoundStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompoundStatementContext {
	var p = new(CompoundStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_compoundStatement

	return p
}

func (s *CompoundStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *CompoundStatementContext) LeftBrace() antlr.TerminalNode {
	return s.GetToken(CParserLeftBrace, 0)
}

func (s *CompoundStatementContext) RightBrace() antlr.TerminalNode {
	return s.GetToken(CParserRightBrace, 0)
}

func (s *CompoundStatementContext) BlockItemList() IBlockItemListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockItemListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBlockItemListContext)
}

func (s *CompoundStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CompoundStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CompoundStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterCompoundStatement(s)
	}
}

func (s *CompoundStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitCompoundStatement(s)
	}
}

func (p *CParser) CompoundStatement() (localctx ICompoundStatementContext) {
	this := p
	_ = this

	localctx = NewCompoundStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 144, CParserRULE_compoundStatement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(968)
		p.Match(CParserLeftBrace)
	}
	p.SetState(970)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2)|(1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserT__6)|(1<<CParserT__7)|(1<<CParserT__8)|(1<<CParserT__9)|(1<<CParserT__10)|(1<<CParserT__11)|(1<<CParserT__12)|(1<<CParserAuto)|(1<<CParserBreak)|(1<<CParserCase)|(1<<CParserChar)|(1<<CParserConst)|(1<<CParserContinue)|(1<<CParserDefault)|(1<<CParserDo)|(1<<CParserDouble)|(1<<CParserEnum)|(1<<CParserExtern)|(1<<CParserFloat)|(1<<CParserFor)|(1<<CParserGoto)|(1<<CParserIf)|(1<<CParserInline))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserRegister-32))|(1<<(CParserRestrict-32))|(1<<(CParserReturn-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserSizeof-32))|(1<<(CParserStatic-32))|(1<<(CParserStruct-32))|(1<<(CParserSwitch-32))|(1<<(CParserTypedef-32))|(1<<(CParserUnion-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserVolatile-32))|(1<<(CParserWhile-32))|(1<<(CParserAlignas-32))|(1<<(CParserAlignof-32))|(1<<(CParserAtomic-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32))|(1<<(CParserGeneric-32))|(1<<(CParserNoreturn-32))|(1<<(CParserStaticAssert-32))|(1<<(CParserThreadLocal-32))|(1<<(CParserLeftParen-32))|(1<<(CParserLeftBrace-32)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserPlusPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserMinusMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserAndAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71))|(1<<(CParserSemi-71)))) != 0) || (((_la-105)&-(0x1f+1)) == 0 && ((1<<uint((_la-105)))&((1<<(CParserIdentifier-105))|(1<<(CParserConstant-105))|(1<<(CParserDigitSequence-105))|(1<<(CParserStringLiteral-105)))) != 0) {
		{
			p.SetState(969)
			p.BlockItemList()
		}

	}
	{
		p.SetState(972)
		p.Match(CParserRightBrace)
	}

	return localctx
}

// IBlockItemListContext is an interface to support dynamic dispatch.
type IBlockItemListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBlockItemListContext differentiates from other interfaces.
	IsBlockItemListContext()
}

type BlockItemListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBlockItemListContext() *BlockItemListContext {
	var p = new(BlockItemListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_blockItemList
	return p
}

func (*BlockItemListContext) IsBlockItemListContext() {}

func NewBlockItemListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockItemListContext {
	var p = new(BlockItemListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_blockItemList

	return p
}

func (s *BlockItemListContext) GetParser() antlr.Parser { return s.parser }

func (s *BlockItemListContext) AllBlockItem() []IBlockItemContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IBlockItemContext)(nil)).Elem())
	var tst = make([]IBlockItemContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IBlockItemContext)
		}
	}

	return tst
}

func (s *BlockItemListContext) BlockItem(i int) IBlockItemContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBlockItemContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IBlockItemContext)
}

func (s *BlockItemListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BlockItemListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BlockItemListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterBlockItemList(s)
	}
}

func (s *BlockItemListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitBlockItemList(s)
	}
}

func (p *CParser) BlockItemList() (localctx IBlockItemListContext) {
	this := p
	_ = this

	localctx = NewBlockItemListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 146, CParserRULE_blockItemList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(975)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2)|(1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserT__6)|(1<<CParserT__7)|(1<<CParserT__8)|(1<<CParserT__9)|(1<<CParserT__10)|(1<<CParserT__11)|(1<<CParserT__12)|(1<<CParserAuto)|(1<<CParserBreak)|(1<<CParserCase)|(1<<CParserChar)|(1<<CParserConst)|(1<<CParserContinue)|(1<<CParserDefault)|(1<<CParserDo)|(1<<CParserDouble)|(1<<CParserEnum)|(1<<CParserExtern)|(1<<CParserFloat)|(1<<CParserFor)|(1<<CParserGoto)|(1<<CParserIf)|(1<<CParserInline))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserRegister-32))|(1<<(CParserRestrict-32))|(1<<(CParserReturn-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserSizeof-32))|(1<<(CParserStatic-32))|(1<<(CParserStruct-32))|(1<<(CParserSwitch-32))|(1<<(CParserTypedef-32))|(1<<(CParserUnion-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserVolatile-32))|(1<<(CParserWhile-32))|(1<<(CParserAlignas-32))|(1<<(CParserAlignof-32))|(1<<(CParserAtomic-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32))|(1<<(CParserGeneric-32))|(1<<(CParserNoreturn-32))|(1<<(CParserStaticAssert-32))|(1<<(CParserThreadLocal-32))|(1<<(CParserLeftParen-32))|(1<<(CParserLeftBrace-32)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserPlusPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserMinusMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserAndAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71))|(1<<(CParserSemi-71)))) != 0) || (((_la-105)&-(0x1f+1)) == 0 && ((1<<uint((_la-105)))&((1<<(CParserIdentifier-105))|(1<<(CParserConstant-105))|(1<<(CParserDigitSequence-105))|(1<<(CParserStringLiteral-105)))) != 0) {
		{
			p.SetState(974)
			p.BlockItem()
		}

		p.SetState(977)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IBlockItemContext is an interface to support dynamic dispatch.
type IBlockItemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBlockItemContext differentiates from other interfaces.
	IsBlockItemContext()
}

type BlockItemContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBlockItemContext() *BlockItemContext {
	var p = new(BlockItemContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_blockItem
	return p
}

func (*BlockItemContext) IsBlockItemContext() {}

func NewBlockItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockItemContext {
	var p = new(BlockItemContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_blockItem

	return p
}

func (s *BlockItemContext) GetParser() antlr.Parser { return s.parser }

func (s *BlockItemContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *BlockItemContext) Declaration() IDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclarationContext)
}

func (s *BlockItemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BlockItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BlockItemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterBlockItem(s)
	}
}

func (s *BlockItemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitBlockItem(s)
	}
}

func (p *CParser) BlockItem() (localctx IBlockItemContext) {
	this := p
	_ = this

	localctx = NewBlockItemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 148, CParserRULE_blockItem)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(981)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 118, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(979)
			p.Statement()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(980)
			p.Declaration()
		}

	}

	return localctx
}

// IExpressionStatementContext is an interface to support dynamic dispatch.
type IExpressionStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExpressionStatementContext differentiates from other interfaces.
	IsExpressionStatementContext()
}

type ExpressionStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExpressionStatementContext() *ExpressionStatementContext {
	var p = new(ExpressionStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_expressionStatement
	return p
}

func (*ExpressionStatementContext) IsExpressionStatementContext() {}

func NewExpressionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionStatementContext {
	var p = new(ExpressionStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_expressionStatement

	return p
}

func (s *ExpressionStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *ExpressionStatementContext) Semi() antlr.TerminalNode {
	return s.GetToken(CParserSemi, 0)
}

func (s *ExpressionStatementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ExpressionStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExpressionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExpressionStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterExpressionStatement(s)
	}
}

func (s *ExpressionStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitExpressionStatement(s)
	}
}

func (p *CParser) ExpressionStatement() (localctx IExpressionStatementContext) {
	this := p
	_ = this

	localctx = NewExpressionStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 150, CParserRULE_expressionStatement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(984)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2))) != 0) || (((_la-39)&-(0x1f+1)) == 0 && ((1<<uint((_la-39)))&((1<<(CParserSizeof-39))|(1<<(CParserAlignof-39))|(1<<(CParserGeneric-39))|(1<<(CParserLeftParen-39)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserPlusPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserMinusMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserAndAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71)))) != 0) || (((_la-105)&-(0x1f+1)) == 0 && ((1<<uint((_la-105)))&((1<<(CParserIdentifier-105))|(1<<(CParserConstant-105))|(1<<(CParserDigitSequence-105))|(1<<(CParserStringLiteral-105)))) != 0) {
		{
			p.SetState(983)
			p.Expression()
		}

	}
	{
		p.SetState(986)
		p.Match(CParserSemi)
	}

	return localctx
}

// ISelectionStatementContext is an interface to support dynamic dispatch.
type ISelectionStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSelectionStatementContext differentiates from other interfaces.
	IsSelectionStatementContext()
}

type SelectionStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySelectionStatementContext() *SelectionStatementContext {
	var p = new(SelectionStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_selectionStatement
	return p
}

func (*SelectionStatementContext) IsSelectionStatementContext() {}

func NewSelectionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectionStatementContext {
	var p = new(SelectionStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_selectionStatement

	return p
}

func (s *SelectionStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *SelectionStatementContext) If() antlr.TerminalNode {
	return s.GetToken(CParserIf, 0)
}

func (s *SelectionStatementContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

func (s *SelectionStatementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *SelectionStatementContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

func (s *SelectionStatementContext) AllStatement() []IStatementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IStatementContext)(nil)).Elem())
	var tst = make([]IStatementContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IStatementContext)
		}
	}

	return tst
}

func (s *SelectionStatementContext) Statement(i int) IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *SelectionStatementContext) Else() antlr.TerminalNode {
	return s.GetToken(CParserElse, 0)
}

func (s *SelectionStatementContext) Switch() antlr.TerminalNode {
	return s.GetToken(CParserSwitch, 0)
}

func (s *SelectionStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SelectionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SelectionStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterSelectionStatement(s)
	}
}

func (s *SelectionStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitSelectionStatement(s)
	}
}

func (p *CParser) SelectionStatement() (localctx ISelectionStatementContext) {
	this := p
	_ = this

	localctx = NewSelectionStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 152, CParserRULE_selectionStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1003)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CParserIf:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(988)
			p.Match(CParserIf)
		}
		{
			p.SetState(989)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(990)
			p.Expression()
		}
		{
			p.SetState(991)
			p.Match(CParserRightParen)
		}
		{
			p.SetState(992)
			p.Statement()
		}
		p.SetState(995)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 120, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(993)
				p.Match(CParserElse)
			}
			{
				p.SetState(994)
				p.Statement()
			}

		}

	case CParserSwitch:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(997)
			p.Match(CParserSwitch)
		}
		{
			p.SetState(998)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(999)
			p.Expression()
		}
		{
			p.SetState(1000)
			p.Match(CParserRightParen)
		}
		{
			p.SetState(1001)
			p.Statement()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IIterationStatementContext is an interface to support dynamic dispatch.
type IIterationStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIterationStatementContext differentiates from other interfaces.
	IsIterationStatementContext()
}

type IterationStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIterationStatementContext() *IterationStatementContext {
	var p = new(IterationStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_iterationStatement
	return p
}

func (*IterationStatementContext) IsIterationStatementContext() {}

func NewIterationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IterationStatementContext {
	var p = new(IterationStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_iterationStatement

	return p
}

func (s *IterationStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *IterationStatementContext) While() antlr.TerminalNode {
	return s.GetToken(CParserWhile, 0)
}

func (s *IterationStatementContext) LeftParen() antlr.TerminalNode {
	return s.GetToken(CParserLeftParen, 0)
}

func (s *IterationStatementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *IterationStatementContext) RightParen() antlr.TerminalNode {
	return s.GetToken(CParserRightParen, 0)
}

func (s *IterationStatementContext) Statement() IStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementContext)
}

func (s *IterationStatementContext) Do() antlr.TerminalNode {
	return s.GetToken(CParserDo, 0)
}

func (s *IterationStatementContext) Semi() antlr.TerminalNode {
	return s.GetToken(CParserSemi, 0)
}

func (s *IterationStatementContext) For() antlr.TerminalNode {
	return s.GetToken(CParserFor, 0)
}

func (s *IterationStatementContext) ForCondition() IForConditionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForConditionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForConditionContext)
}

func (s *IterationStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IterationStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IterationStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterIterationStatement(s)
	}
}

func (s *IterationStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitIterationStatement(s)
	}
}

func (p *CParser) IterationStatement() (localctx IIterationStatementContext) {
	this := p
	_ = this

	localctx = NewIterationStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 154, CParserRULE_iterationStatement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1025)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CParserWhile:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1005)
			p.Match(CParserWhile)
		}
		{
			p.SetState(1006)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(1007)
			p.Expression()
		}
		{
			p.SetState(1008)
			p.Match(CParserRightParen)
		}
		{
			p.SetState(1009)
			p.Statement()
		}

	case CParserDo:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1011)
			p.Match(CParserDo)
		}
		{
			p.SetState(1012)
			p.Statement()
		}
		{
			p.SetState(1013)
			p.Match(CParserWhile)
		}
		{
			p.SetState(1014)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(1015)
			p.Expression()
		}
		{
			p.SetState(1016)
			p.Match(CParserRightParen)
		}
		{
			p.SetState(1017)
			p.Match(CParserSemi)
		}

	case CParserFor:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1019)
			p.Match(CParserFor)
		}
		{
			p.SetState(1020)
			p.Match(CParserLeftParen)
		}
		{
			p.SetState(1021)
			p.ForCondition()
		}
		{
			p.SetState(1022)
			p.Match(CParserRightParen)
		}
		{
			p.SetState(1023)
			p.Statement()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IForConditionContext is an interface to support dynamic dispatch.
type IForConditionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForConditionContext differentiates from other interfaces.
	IsForConditionContext()
}

type ForConditionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyForConditionContext() *ForConditionContext {
	var p = new(ForConditionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_forCondition
	return p
}

func (*ForConditionContext) IsForConditionContext() {}

func NewForConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForConditionContext {
	var p = new(ForConditionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_forCondition

	return p
}

func (s *ForConditionContext) GetParser() antlr.Parser { return s.parser }

func (s *ForConditionContext) AllSemi() []antlr.TerminalNode {
	return s.GetTokens(CParserSemi)
}

func (s *ForConditionContext) Semi(i int) antlr.TerminalNode {
	return s.GetToken(CParserSemi, i)
}

func (s *ForConditionContext) ForDeclaration() IForDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForDeclarationContext)
}

func (s *ForConditionContext) AllForExpression() []IForExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IForExpressionContext)(nil)).Elem())
	var tst = make([]IForExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IForExpressionContext)
		}
	}

	return tst
}

func (s *ForConditionContext) ForExpression(i int) IForExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IForExpressionContext)
}

func (s *ForConditionContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ForConditionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ForConditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ForConditionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterForCondition(s)
	}
}

func (s *ForConditionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitForCondition(s)
	}
}

func (p *CParser) ForCondition() (localctx IForConditionContext) {
	this := p
	_ = this

	localctx = NewForConditionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 156, CParserRULE_forCondition)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1031)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 124, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1027)
			p.ForDeclaration()
		}

	case 2:
		p.SetState(1029)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2))) != 0) || (((_la-39)&-(0x1f+1)) == 0 && ((1<<uint((_la-39)))&((1<<(CParserSizeof-39))|(1<<(CParserAlignof-39))|(1<<(CParserGeneric-39))|(1<<(CParserLeftParen-39)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserPlusPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserMinusMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserAndAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71)))) != 0) || (((_la-105)&-(0x1f+1)) == 0 && ((1<<uint((_la-105)))&((1<<(CParserIdentifier-105))|(1<<(CParserConstant-105))|(1<<(CParserDigitSequence-105))|(1<<(CParserStringLiteral-105)))) != 0) {
			{
				p.SetState(1028)
				p.Expression()
			}

		}

	}
	{
		p.SetState(1033)
		p.Match(CParserSemi)
	}
	p.SetState(1035)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2))) != 0) || (((_la-39)&-(0x1f+1)) == 0 && ((1<<uint((_la-39)))&((1<<(CParserSizeof-39))|(1<<(CParserAlignof-39))|(1<<(CParserGeneric-39))|(1<<(CParserLeftParen-39)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserPlusPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserMinusMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserAndAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71)))) != 0) || (((_la-105)&-(0x1f+1)) == 0 && ((1<<uint((_la-105)))&((1<<(CParserIdentifier-105))|(1<<(CParserConstant-105))|(1<<(CParserDigitSequence-105))|(1<<(CParserStringLiteral-105)))) != 0) {
		{
			p.SetState(1034)
			p.ForExpression()
		}

	}
	{
		p.SetState(1037)
		p.Match(CParserSemi)
	}
	p.SetState(1039)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2))) != 0) || (((_la-39)&-(0x1f+1)) == 0 && ((1<<uint((_la-39)))&((1<<(CParserSizeof-39))|(1<<(CParserAlignof-39))|(1<<(CParserGeneric-39))|(1<<(CParserLeftParen-39)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserPlusPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserMinusMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserAndAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71)))) != 0) || (((_la-105)&-(0x1f+1)) == 0 && ((1<<uint((_la-105)))&((1<<(CParserIdentifier-105))|(1<<(CParserConstant-105))|(1<<(CParserDigitSequence-105))|(1<<(CParserStringLiteral-105)))) != 0) {
		{
			p.SetState(1038)
			p.ForExpression()
		}

	}

	return localctx
}

// IForDeclarationContext is an interface to support dynamic dispatch.
type IForDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForDeclarationContext differentiates from other interfaces.
	IsForDeclarationContext()
}

type ForDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyForDeclarationContext() *ForDeclarationContext {
	var p = new(ForDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_forDeclaration
	return p
}

func (*ForDeclarationContext) IsForDeclarationContext() {}

func NewForDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForDeclarationContext {
	var p = new(ForDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_forDeclaration

	return p
}

func (s *ForDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *ForDeclarationContext) DeclarationSpecifiers() IDeclarationSpecifiersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclarationSpecifiersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclarationSpecifiersContext)
}

func (s *ForDeclarationContext) InitDeclaratorList() IInitDeclaratorListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitDeclaratorListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInitDeclaratorListContext)
}

func (s *ForDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ForDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ForDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterForDeclaration(s)
	}
}

func (s *ForDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitForDeclaration(s)
	}
}

func (p *CParser) ForDeclaration() (localctx IForDeclarationContext) {
	this := p
	_ = this

	localctx = NewForDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 158, CParserRULE_forDeclaration)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1041)
		p.DeclarationSpecifiers()
	}
	p.SetState(1043)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la-59)&-(0x1f+1)) == 0 && ((1<<uint((_la-59)))&((1<<(CParserLeftParen-59))|(1<<(CParserStar-59))|(1<<(CParserCaret-59)))) != 0) || _la == CParserIdentifier {
		{
			p.SetState(1042)
			p.InitDeclaratorList()
		}

	}

	return localctx
}

// IForExpressionContext is an interface to support dynamic dispatch.
type IForExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForExpressionContext differentiates from other interfaces.
	IsForExpressionContext()
}

type ForExpressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyForExpressionContext() *ForExpressionContext {
	var p = new(ForExpressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_forExpression
	return p
}

func (*ForExpressionContext) IsForExpressionContext() {}

func NewForExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionContext {
	var p = new(ForExpressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_forExpression

	return p
}

func (s *ForExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *ForExpressionContext) AllAssignmentExpression() []IAssignmentExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAssignmentExpressionContext)(nil)).Elem())
	var tst = make([]IAssignmentExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAssignmentExpressionContext)
		}
	}

	return tst
}

func (s *ForExpressionContext) AssignmentExpression(i int) IAssignmentExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAssignmentExpressionContext)
}

func (s *ForExpressionContext) AllComma() []antlr.TerminalNode {
	return s.GetTokens(CParserComma)
}

func (s *ForExpressionContext) Comma(i int) antlr.TerminalNode {
	return s.GetToken(CParserComma, i)
}

func (s *ForExpressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ForExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ForExpressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterForExpression(s)
	}
}

func (s *ForExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitForExpression(s)
	}
}

func (p *CParser) ForExpression() (localctx IForExpressionContext) {
	this := p
	_ = this

	localctx = NewForExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 160, CParserRULE_forExpression)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1045)
		p.AssignmentExpression()
	}
	p.SetState(1050)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CParserComma {
		{
			p.SetState(1046)
			p.Match(CParserComma)
		}
		{
			p.SetState(1047)
			p.AssignmentExpression()
		}

		p.SetState(1052)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IJumpStatementContext is an interface to support dynamic dispatch.
type IJumpStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsJumpStatementContext differentiates from other interfaces.
	IsJumpStatementContext()
}

type JumpStatementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyJumpStatementContext() *JumpStatementContext {
	var p = new(JumpStatementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_jumpStatement
	return p
}

func (*JumpStatementContext) IsJumpStatementContext() {}

func NewJumpStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JumpStatementContext {
	var p = new(JumpStatementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_jumpStatement

	return p
}

func (s *JumpStatementContext) GetParser() antlr.Parser { return s.parser }

func (s *JumpStatementContext) Semi() antlr.TerminalNode {
	return s.GetToken(CParserSemi, 0)
}

func (s *JumpStatementContext) Goto() antlr.TerminalNode {
	return s.GetToken(CParserGoto, 0)
}

func (s *JumpStatementContext) Identifier() antlr.TerminalNode {
	return s.GetToken(CParserIdentifier, 0)
}

func (s *JumpStatementContext) Return() antlr.TerminalNode {
	return s.GetToken(CParserReturn, 0)
}

func (s *JumpStatementContext) UnaryExpression() IUnaryExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnaryExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnaryExpressionContext)
}

func (s *JumpStatementContext) Continue() antlr.TerminalNode {
	return s.GetToken(CParserContinue, 0)
}

func (s *JumpStatementContext) Break() antlr.TerminalNode {
	return s.GetToken(CParserBreak, 0)
}

func (s *JumpStatementContext) Expression() IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *JumpStatementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *JumpStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *JumpStatementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterJumpStatement(s)
	}
}

func (s *JumpStatementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitJumpStatement(s)
	}
}

func (p *CParser) JumpStatement() (localctx IJumpStatementContext) {
	this := p
	_ = this

	localctx = NewJumpStatementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 162, CParserRULE_jumpStatement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1062)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 130, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1053)
			p.Match(CParserGoto)
		}
		{
			p.SetState(1054)
			p.Match(CParserIdentifier)
		}

	case 2:
		{
			p.SetState(1055)
			_la = p.GetTokenStream().LA(1)

			if !(_la == CParserBreak || _la == CParserContinue) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	case 3:
		{
			p.SetState(1056)
			p.Match(CParserReturn)
		}
		p.SetState(1058)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__1)|(1<<CParserT__2))) != 0) || (((_la-39)&-(0x1f+1)) == 0 && ((1<<uint((_la-39)))&((1<<(CParserSizeof-39))|(1<<(CParserAlignof-39))|(1<<(CParserGeneric-39))|(1<<(CParserLeftParen-39)))) != 0) || (((_la-71)&-(0x1f+1)) == 0 && ((1<<uint((_la-71)))&((1<<(CParserPlus-71))|(1<<(CParserPlusPlus-71))|(1<<(CParserMinus-71))|(1<<(CParserMinusMinus-71))|(1<<(CParserStar-71))|(1<<(CParserAnd-71))|(1<<(CParserAndAnd-71))|(1<<(CParserNot-71))|(1<<(CParserTilde-71)))) != 0) || (((_la-105)&-(0x1f+1)) == 0 && ((1<<uint((_la-105)))&((1<<(CParserIdentifier-105))|(1<<(CParserConstant-105))|(1<<(CParserDigitSequence-105))|(1<<(CParserStringLiteral-105)))) != 0) {
			{
				p.SetState(1057)
				p.Expression()
			}

		}

	case 4:
		{
			p.SetState(1060)
			p.Match(CParserGoto)
		}
		{
			p.SetState(1061)
			p.UnaryExpression()
		}

	}
	{
		p.SetState(1064)
		p.Match(CParserSemi)
	}

	return localctx
}

// ICompilationUnitContext is an interface to support dynamic dispatch.
type ICompilationUnitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCompilationUnitContext differentiates from other interfaces.
	IsCompilationUnitContext()
}

type CompilationUnitContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCompilationUnitContext() *CompilationUnitContext {
	var p = new(CompilationUnitContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_compilationUnit
	return p
}

func (*CompilationUnitContext) IsCompilationUnitContext() {}

func NewCompilationUnitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompilationUnitContext {
	var p = new(CompilationUnitContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_compilationUnit

	return p
}

func (s *CompilationUnitContext) GetParser() antlr.Parser { return s.parser }

func (s *CompilationUnitContext) EOF() antlr.TerminalNode {
	return s.GetToken(CParserEOF, 0)
}

func (s *CompilationUnitContext) TranslationUnit() ITranslationUnitContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITranslationUnitContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITranslationUnitContext)
}

func (s *CompilationUnitContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CompilationUnitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CompilationUnitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterCompilationUnit(s)
	}
}

func (s *CompilationUnitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitCompilationUnit(s)
	}
}

func (p *CParser) CompilationUnit() (localctx ICompilationUnitContext) {
	this := p
	_ = this

	localctx = NewCompilationUnitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 164, CParserRULE_compilationUnit)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1067)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserT__6)|(1<<CParserT__7)|(1<<CParserT__8)|(1<<CParserT__9)|(1<<CParserT__11)|(1<<CParserAuto)|(1<<CParserChar)|(1<<CParserConst)|(1<<CParserDouble)|(1<<CParserEnum)|(1<<CParserExtern)|(1<<CParserFloat)|(1<<CParserInline))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserRegister-32))|(1<<(CParserRestrict-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserStatic-32))|(1<<(CParserStruct-32))|(1<<(CParserTypedef-32))|(1<<(CParserUnion-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserVolatile-32))|(1<<(CParserAlignas-32))|(1<<(CParserAtomic-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32))|(1<<(CParserNoreturn-32))|(1<<(CParserStaticAssert-32))|(1<<(CParserThreadLocal-32))|(1<<(CParserLeftParen-32)))) != 0) || (((_la-75)&-(0x1f+1)) == 0 && ((1<<uint((_la-75)))&((1<<(CParserStar-75))|(1<<(CParserCaret-75))|(1<<(CParserSemi-75))|(1<<(CParserIdentifier-75)))) != 0) {
		{
			p.SetState(1066)
			p.TranslationUnit()
		}

	}
	{
		p.SetState(1069)
		p.Match(CParserEOF)
	}

	return localctx
}

// ITranslationUnitContext is an interface to support dynamic dispatch.
type ITranslationUnitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTranslationUnitContext differentiates from other interfaces.
	IsTranslationUnitContext()
}

type TranslationUnitContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTranslationUnitContext() *TranslationUnitContext {
	var p = new(TranslationUnitContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_translationUnit
	return p
}

func (*TranslationUnitContext) IsTranslationUnitContext() {}

func NewTranslationUnitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TranslationUnitContext {
	var p = new(TranslationUnitContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_translationUnit

	return p
}

func (s *TranslationUnitContext) GetParser() antlr.Parser { return s.parser }

func (s *TranslationUnitContext) AllExternalDeclaration() []IExternalDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExternalDeclarationContext)(nil)).Elem())
	var tst = make([]IExternalDeclarationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IExternalDeclarationContext)
		}
	}

	return tst
}

func (s *TranslationUnitContext) ExternalDeclaration(i int) IExternalDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExternalDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExternalDeclarationContext)
}

func (s *TranslationUnitContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TranslationUnitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TranslationUnitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterTranslationUnit(s)
	}
}

func (s *TranslationUnitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitTranslationUnit(s)
	}
}

func (p *CParser) TranslationUnit() (localctx ITranslationUnitContext) {
	this := p
	_ = this

	localctx = NewTranslationUnitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 166, CParserRULE_translationUnit)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1072)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserT__6)|(1<<CParserT__7)|(1<<CParserT__8)|(1<<CParserT__9)|(1<<CParserT__11)|(1<<CParserAuto)|(1<<CParserChar)|(1<<CParserConst)|(1<<CParserDouble)|(1<<CParserEnum)|(1<<CParserExtern)|(1<<CParserFloat)|(1<<CParserInline))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserRegister-32))|(1<<(CParserRestrict-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserStatic-32))|(1<<(CParserStruct-32))|(1<<(CParserTypedef-32))|(1<<(CParserUnion-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserVolatile-32))|(1<<(CParserAlignas-32))|(1<<(CParserAtomic-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32))|(1<<(CParserNoreturn-32))|(1<<(CParserStaticAssert-32))|(1<<(CParserThreadLocal-32))|(1<<(CParserLeftParen-32)))) != 0) || (((_la-75)&-(0x1f+1)) == 0 && ((1<<uint((_la-75)))&((1<<(CParserStar-75))|(1<<(CParserCaret-75))|(1<<(CParserSemi-75))|(1<<(CParserIdentifier-75)))) != 0) {
		{
			p.SetState(1071)
			p.ExternalDeclaration()
		}

		p.SetState(1074)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IExternalDeclarationContext is an interface to support dynamic dispatch.
type IExternalDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExternalDeclarationContext differentiates from other interfaces.
	IsExternalDeclarationContext()
}

type ExternalDeclarationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExternalDeclarationContext() *ExternalDeclarationContext {
	var p = new(ExternalDeclarationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_externalDeclaration
	return p
}

func (*ExternalDeclarationContext) IsExternalDeclarationContext() {}

func NewExternalDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExternalDeclarationContext {
	var p = new(ExternalDeclarationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_externalDeclaration

	return p
}

func (s *ExternalDeclarationContext) GetParser() antlr.Parser { return s.parser }

func (s *ExternalDeclarationContext) FunctionDefinition() IFunctionDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionDefinitionContext)
}

func (s *ExternalDeclarationContext) Declaration() IDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclarationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclarationContext)
}

func (s *ExternalDeclarationContext) Semi() antlr.TerminalNode {
	return s.GetToken(CParserSemi, 0)
}

func (s *ExternalDeclarationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExternalDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExternalDeclarationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterExternalDeclaration(s)
	}
}

func (s *ExternalDeclarationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitExternalDeclaration(s)
	}
}

func (p *CParser) ExternalDeclaration() (localctx IExternalDeclarationContext) {
	this := p
	_ = this

	localctx = NewExternalDeclarationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 168, CParserRULE_externalDeclaration)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1079)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 133, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1076)
			p.FunctionDefinition()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1077)
			p.Declaration()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1078)
			p.Match(CParserSemi)
		}

	}

	return localctx
}

// IFunctionDefinitionContext is an interface to support dynamic dispatch.
type IFunctionDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunctionDefinitionContext differentiates from other interfaces.
	IsFunctionDefinitionContext()
}

type FunctionDefinitionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunctionDefinitionContext() *FunctionDefinitionContext {
	var p = new(FunctionDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_functionDefinition
	return p
}

func (*FunctionDefinitionContext) IsFunctionDefinitionContext() {}

func NewFunctionDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionDefinitionContext {
	var p = new(FunctionDefinitionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_functionDefinition

	return p
}

func (s *FunctionDefinitionContext) GetParser() antlr.Parser { return s.parser }

func (s *FunctionDefinitionContext) Declarator() IDeclaratorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclaratorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclaratorContext)
}

func (s *FunctionDefinitionContext) CompoundStatement() ICompoundStatementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompoundStatementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICompoundStatementContext)
}

func (s *FunctionDefinitionContext) DeclarationSpecifiers() IDeclarationSpecifiersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclarationSpecifiersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclarationSpecifiersContext)
}

func (s *FunctionDefinitionContext) DeclarationList() IDeclarationListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclarationListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeclarationListContext)
}

func (s *FunctionDefinitionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FunctionDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FunctionDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterFunctionDefinition(s)
	}
}

func (s *FunctionDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitFunctionDefinition(s)
	}
}

func (p *CParser) FunctionDefinition() (localctx IFunctionDefinitionContext) {
	this := p
	_ = this

	localctx = NewFunctionDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 170, CParserRULE_functionDefinition)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1082)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 134, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1081)
			p.DeclarationSpecifiers()
		}

	}
	{
		p.SetState(1084)
		p.Declarator()
	}
	p.SetState(1086)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserT__6)|(1<<CParserT__7)|(1<<CParserT__8)|(1<<CParserT__9)|(1<<CParserT__11)|(1<<CParserAuto)|(1<<CParserChar)|(1<<CParserConst)|(1<<CParserDouble)|(1<<CParserEnum)|(1<<CParserExtern)|(1<<CParserFloat)|(1<<CParserInline))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserRegister-32))|(1<<(CParserRestrict-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserStatic-32))|(1<<(CParserStruct-32))|(1<<(CParserTypedef-32))|(1<<(CParserUnion-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserVolatile-32))|(1<<(CParserAlignas-32))|(1<<(CParserAtomic-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32))|(1<<(CParserNoreturn-32))|(1<<(CParserStaticAssert-32))|(1<<(CParserThreadLocal-32)))) != 0) || _la == CParserIdentifier {
		{
			p.SetState(1085)
			p.DeclarationList()
		}

	}
	{
		p.SetState(1088)
		p.CompoundStatement()
	}

	return localctx
}

// IDeclarationListContext is an interface to support dynamic dispatch.
type IDeclarationListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDeclarationListContext differentiates from other interfaces.
	IsDeclarationListContext()
}

type DeclarationListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDeclarationListContext() *DeclarationListContext {
	var p = new(DeclarationListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CParserRULE_declarationList
	return p
}

func (*DeclarationListContext) IsDeclarationListContext() {}

func NewDeclarationListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclarationListContext {
	var p = new(DeclarationListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CParserRULE_declarationList

	return p
}

func (s *DeclarationListContext) GetParser() antlr.Parser { return s.parser }

func (s *DeclarationListContext) AllDeclaration() []IDeclarationContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDeclarationContext)(nil)).Elem())
	var tst = make([]IDeclarationContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IDeclarationContext)
		}
	}

	return tst
}

func (s *DeclarationListContext) Declaration(i int) IDeclarationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeclarationContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDeclarationContext)
}

func (s *DeclarationListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DeclarationListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DeclarationListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.EnterDeclarationList(s)
	}
}

func (s *DeclarationListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CListener); ok {
		listenerT.ExitDeclarationList(s)
	}
}

func (p *CParser) DeclarationList() (localctx IDeclarationListContext) {
	this := p
	_ = this

	localctx = NewDeclarationListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 172, CParserRULE_declarationList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1091)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<CParserT__0)|(1<<CParserT__3)|(1<<CParserT__4)|(1<<CParserT__5)|(1<<CParserT__6)|(1<<CParserT__7)|(1<<CParserT__8)|(1<<CParserT__9)|(1<<CParserT__11)|(1<<CParserAuto)|(1<<CParserChar)|(1<<CParserConst)|(1<<CParserDouble)|(1<<CParserEnum)|(1<<CParserExtern)|(1<<CParserFloat)|(1<<CParserInline))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(CParserInt-32))|(1<<(CParserLong-32))|(1<<(CParserRegister-32))|(1<<(CParserRestrict-32))|(1<<(CParserShort-32))|(1<<(CParserSigned-32))|(1<<(CParserStatic-32))|(1<<(CParserStruct-32))|(1<<(CParserTypedef-32))|(1<<(CParserUnion-32))|(1<<(CParserUnsigned-32))|(1<<(CParserVoid-32))|(1<<(CParserVolatile-32))|(1<<(CParserAlignas-32))|(1<<(CParserAtomic-32))|(1<<(CParserBool-32))|(1<<(CParserComplex-32))|(1<<(CParserNoreturn-32))|(1<<(CParserStaticAssert-32))|(1<<(CParserThreadLocal-32)))) != 0) || _la == CParserIdentifier {
		{
			p.SetState(1090)
			p.Declaration()
		}

		p.SetState(1093)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

func (p *CParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
	switch ruleIndex {
	case 31:
		var t *TypeSpecifierContext = nil
		if localctx != nil {
			t = localctx.(*TypeSpecifierContext)
		}
		return p.TypeSpecifier_Sempred(t, predIndex)

	case 48:
		var t *DirectDeclaratorContext = nil
		if localctx != nil {
			t = localctx.(*DirectDeclaratorContext)
		}
		return p.DirectDeclarator_Sempred(t, predIndex)

	case 62:
		var t *DirectAbstractDeclaratorContext = nil
		if localctx != nil {
			t = localctx.(*DirectAbstractDeclaratorContext)
		}
		return p.DirectAbstractDeclarator_Sempred(t, predIndex)

	default:
		panic("No predicate with index: " + fmt.Sprint(ruleIndex))
	}
}

func (p *CParser) TypeSpecifier_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 *CParser) DirectDeclarator_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 1:
		return p.Precpred(p.GetParserRuleContext(), 8)

	case 2:
		return p.Precpred(p.GetParserRuleContext(), 7)

	case 3:
		return p.Precpred(p.GetParserRuleContext(), 6)

	case 4:
		return p.Precpred(p.GetParserRuleContext(), 5)

	case 5:
		return p.Precpred(p.GetParserRuleContext(), 4)

	case 6:
		return p.Precpred(p.GetParserRuleContext(), 3)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

func (p *CParser) DirectAbstractDeclarator_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	switch predIndex {
	case 7:
		return p.Precpred(p.GetParserRuleContext(), 5)

	case 8:
		return p.Precpred(p.GetParserRuleContext(), 4)

	case 9:
		return p.Precpred(p.GetParserRuleContext(), 3)

	case 10:
		return p.Precpred(p.GetParserRuleContext(), 2)

	case 11:
		return p.Precpred(p.GetParserRuleContext(), 1)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}
