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

package cql // CqlParser
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, 178, 2332,
	4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7,
	4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13,
	9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9,
	18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23,
	4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4,
	29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34,
	9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9,
	39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44,
	4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4,
	50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55,
	9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9,
	60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65,
	4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4,
	71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76,
	9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9,
	81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86,
	4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4,
	92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97,
	9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102,
	9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106,
	4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111,
	9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115,
	4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120,
	9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124,
	4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129,
	9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133,
	4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138,
	9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142,
	4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147,
	9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151,
	4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156,
	9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160,
	4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165,
	9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 4, 168, 9, 168, 4, 169, 9, 169,
	4, 170, 9, 170, 4, 171, 9, 171, 4, 172, 9, 172, 4, 173, 9, 173, 4, 174,
	9, 174, 4, 175, 9, 175, 4, 176, 9, 176, 4, 177, 9, 177, 4, 178, 9, 178,
	4, 179, 9, 179, 4, 180, 9, 180, 4, 181, 9, 181, 4, 182, 9, 182, 4, 183,
	9, 183, 4, 184, 9, 184, 4, 185, 9, 185, 4, 186, 9, 186, 4, 187, 9, 187,
	4, 188, 9, 188, 4, 189, 9, 189, 4, 190, 9, 190, 4, 191, 9, 191, 4, 192,
	9, 192, 4, 193, 9, 193, 4, 194, 9, 194, 4, 195, 9, 195, 4, 196, 9, 196,
	4, 197, 9, 197, 4, 198, 9, 198, 4, 199, 9, 199, 4, 200, 9, 200, 4, 201,
	9, 201, 4, 202, 9, 202, 4, 203, 9, 203, 4, 204, 9, 204, 4, 205, 9, 205,
	4, 206, 9, 206, 4, 207, 9, 207, 4, 208, 9, 208, 4, 209, 9, 209, 4, 210,
	9, 210, 4, 211, 9, 211, 4, 212, 9, 212, 4, 213, 9, 213, 4, 214, 9, 214,
	4, 215, 9, 215, 4, 216, 9, 216, 4, 217, 9, 217, 4, 218, 9, 218, 4, 219,
	9, 219, 4, 220, 9, 220, 4, 221, 9, 221, 4, 222, 9, 222, 4, 223, 9, 223,
	4, 224, 9, 224, 4, 225, 9, 225, 4, 226, 9, 226, 4, 227, 9, 227, 4, 228,
	9, 228, 4, 229, 9, 229, 4, 230, 9, 230, 4, 231, 9, 231, 4, 232, 9, 232,
	4, 233, 9, 233, 4, 234, 9, 234, 4, 235, 9, 235, 4, 236, 9, 236, 4, 237,
	9, 237, 4, 238, 9, 238, 4, 239, 9, 239, 4, 240, 9, 240, 4, 241, 9, 241,
	4, 242, 9, 242, 4, 243, 9, 243, 4, 244, 9, 244, 4, 245, 9, 245, 4, 246,
	9, 246, 4, 247, 9, 247, 4, 248, 9, 248, 4, 249, 9, 249, 4, 250, 9, 250,
	4, 251, 9, 251, 4, 252, 9, 252, 4, 253, 9, 253, 4, 254, 9, 254, 4, 255,
	9, 255, 4, 256, 9, 256, 4, 257, 9, 257, 4, 258, 9, 258, 4, 259, 9, 259,
	4, 260, 9, 260, 4, 261, 9, 261, 4, 262, 9, 262, 4, 263, 9, 263, 4, 264,
	9, 264, 4, 265, 9, 265, 4, 266, 9, 266, 4, 267, 9, 267, 4, 268, 9, 268,
	4, 269, 9, 269, 4, 270, 9, 270, 4, 271, 9, 271, 4, 272, 9, 272, 4, 273,
	9, 273, 4, 274, 9, 274, 4, 275, 9, 275, 4, 276, 9, 276, 4, 277, 9, 277,
	4, 278, 9, 278, 4, 279, 9, 279, 4, 280, 9, 280, 4, 281, 9, 281, 3, 2, 5,
	2, 564, 10, 2, 3, 2, 5, 2, 567, 10, 2, 3, 2, 3, 2, 3, 3, 3, 3, 5, 3, 573,
	10, 3, 3, 3, 3, 3, 3, 3, 7, 3, 578, 10, 3, 12, 3, 14, 3, 581, 11, 3, 3,
	3, 3, 3, 5, 3, 585, 10, 3, 3, 3, 5, 3, 588, 10, 3, 3, 3, 5, 3, 591, 10,
	3, 3, 4, 3, 4, 3, 5, 3, 5, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3,
	6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3,
	6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3,
	6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 5, 6, 634, 10, 6, 3, 7, 3, 7, 3, 7, 3,
	7, 3, 7, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 5,
	9, 651, 10, 9, 3, 9, 5, 9, 654, 10, 9, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10,
	5, 10, 661, 10, 10, 3, 10, 3, 10, 3, 10, 5, 10, 666, 10, 10, 3, 11, 3,
	11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 5, 12, 677, 10, 12,
	3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 5, 12, 687, 10,
	12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13,
	3, 13, 3, 13, 3, 13, 5, 13, 702, 10, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3,
	13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 713, 10, 13, 3, 13, 3, 13, 3, 13,
	5, 13, 718, 10, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5,
	13, 727, 10, 13, 3, 14, 3, 14, 3, 14, 5, 14, 732, 10, 14, 3, 14, 3, 14,
	3, 14, 3, 14, 3, 14, 3, 14, 5, 14, 740, 10, 14, 3, 15, 3, 15, 3, 15, 5,
	15, 745, 10, 15, 3, 15, 3, 15, 5, 15, 749, 10, 15, 3, 16, 3, 16, 3, 16,
	5, 16, 754, 10, 16, 3, 16, 3, 16, 3, 16, 5, 16, 759, 10, 16, 3, 16, 3,
	16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 7, 17,
	772, 10, 17, 12, 17, 14, 17, 775, 11, 17, 3, 18, 3, 18, 3, 18, 5, 18, 780,
	10, 18, 3, 18, 3, 18, 3, 18, 5, 18, 785, 10, 18, 3, 18, 3, 18, 3, 18, 3,
	18, 3, 19, 3, 19, 3, 19, 3, 19, 5, 19, 795, 10, 19, 3, 19, 3, 19, 3, 19,
	5, 19, 800, 10, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3,
	19, 5, 19, 810, 10, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19,
	3, 19, 3, 19, 3, 19, 5, 19, 822, 10, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3,
	20, 5, 20, 829, 10, 20, 3, 21, 3, 21, 3, 21, 3, 21, 7, 21, 835, 10, 21,
	12, 21, 14, 21, 838, 11, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 3, 23,
	3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 5, 23, 851, 10, 23, 3, 24, 3, 24, 3,
	24, 5, 24, 856, 10, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24,
	3, 24, 3, 24, 3, 24, 5, 24, 868, 10, 24, 3, 25, 3, 25, 5, 25, 872, 10,
	25, 3, 25, 3, 25, 5, 25, 876, 10, 25, 3, 25, 3, 25, 3, 25, 5, 25, 881,
	10, 25, 3, 25, 3, 25, 3, 25, 5, 25, 886, 10, 25, 3, 25, 3, 25, 3, 25, 3,
	25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27,
	3, 27, 7, 27, 903, 10, 27, 12, 27, 14, 27, 906, 11, 27, 3, 28, 3, 28, 3,
	28, 3, 28, 5, 28, 912, 10, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29,
	5, 29, 920, 10, 29, 3, 29, 3, 29, 5, 29, 924, 10, 29, 3, 29, 3, 29, 3,
	29, 5, 29, 929, 10, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29,
	3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 5,
	30, 948, 10, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 7, 31, 955, 10, 31,
	12, 31, 14, 31, 958, 11, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32,
	3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 7, 33, 972, 10, 33, 12, 33, 14,
	33, 975, 11, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 7, 34,
	984, 10, 34, 12, 34, 14, 34, 987, 11, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3,
	35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 5, 36, 1000, 10, 36, 3, 37,
	3, 37, 3, 37, 3, 38, 3, 38, 5, 38, 1007, 10, 38, 3, 39, 3, 39, 3, 39, 3,
	39, 3, 39, 5, 39, 1014, 10, 39, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40,
	5, 40, 1022, 10, 40, 3, 41, 3, 41, 3, 41, 3, 42, 3, 42, 3, 42, 3, 42, 7,
	42, 1031, 10, 42, 12, 42, 14, 42, 1034, 11, 42, 3, 43, 3, 43, 3, 43, 3,
	43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 7, 44, 1047, 10, 44,
	12, 44, 14, 44, 1050, 11, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 46,
	3, 46, 3, 46, 3, 46, 3, 46, 5, 46, 1062, 10, 46, 3, 46, 3, 46, 3, 46, 3,
	47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 1073, 10, 47, 3, 48, 3, 48,
	3, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 3, 50, 3,
	51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 52, 7, 52, 1094, 10, 52, 12,
	52, 14, 52, 1097, 11, 52, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3,
	54, 3, 54, 3, 54, 7, 54, 1108, 10, 54, 12, 54, 14, 54, 1111, 11, 54, 3,
	55, 3, 55, 3, 55, 3, 55, 5, 55, 1117, 10, 55, 3, 56, 3, 56, 3, 56, 3, 56,
	3, 56, 7, 56, 1124, 10, 56, 12, 56, 14, 56, 1127, 11, 56, 3, 57, 3, 57,
	3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3,
	57, 3, 57, 3, 57, 3, 57, 5, 57, 1145, 10, 57, 3, 58, 3, 58, 3, 58, 3, 58,
	3, 58, 3, 58, 5, 58, 1153, 10, 58, 3, 58, 3, 58, 3, 58, 3, 58, 5, 58, 1159,
	10, 58, 3, 59, 3, 59, 3, 59, 5, 59, 1164, 10, 59, 3, 59, 3, 59, 3, 60,
	3, 60, 3, 60, 5, 60, 1171, 10, 60, 3, 60, 3, 60, 3, 60, 5, 60, 1176, 10,
	60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 3, 61, 5, 61, 1184, 10, 61, 3, 61,
	3, 61, 3, 61, 5, 61, 1189, 10, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 5,
	62, 1196, 10, 62, 3, 62, 3, 62, 3, 62, 5, 62, 1201, 10, 62, 3, 62, 3, 62,
	3, 63, 3, 63, 3, 63, 5, 63, 1208, 10, 63, 3, 63, 3, 63, 3, 63, 5, 63, 1213,
	10, 63, 3, 63, 3, 63, 3, 64, 3, 64, 3, 64, 5, 64, 1220, 10, 64, 3, 64,
	3, 64, 3, 64, 3, 64, 3, 64, 5, 64, 1227, 10, 64, 3, 64, 3, 64, 3, 65, 3,
	65, 3, 65, 5, 65, 1234, 10, 65, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 5, 66,
	1241, 10, 66, 3, 66, 3, 66, 3, 66, 5, 66, 1246, 10, 66, 3, 66, 3, 66, 3,
	67, 3, 67, 3, 67, 5, 67, 1253, 10, 67, 3, 67, 3, 67, 3, 68, 3, 68, 3, 68,
	5, 68, 1260, 10, 68, 3, 68, 3, 68, 3, 68, 5, 68, 1265, 10, 68, 3, 68, 3,
	68, 3, 69, 3, 69, 3, 69, 5, 69, 1272, 10, 69, 3, 69, 3, 69, 3, 69, 5, 69,
	1277, 10, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 5, 69, 1284, 10, 69, 3,
	70, 3, 70, 5, 70, 1288, 10, 70, 3, 70, 5, 70, 1291, 10, 70, 3, 71, 3, 71,
	3, 71, 3, 71, 3, 71, 3, 71, 5, 71, 1299, 10, 71, 3, 71, 3, 71, 3, 72, 3,
	72, 3, 72, 3, 72, 7, 72, 1307, 10, 72, 12, 72, 14, 72, 1310, 11, 72, 3,
	73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 5, 73, 1320, 10, 73,
	3, 74, 3, 74, 3, 75, 3, 75, 5, 75, 1326, 10, 75, 3, 76, 3, 76, 3, 76, 3,
	76, 3, 76, 7, 76, 1333, 10, 76, 12, 76, 14, 76, 1336, 11, 76, 3, 76, 3,
	76, 3, 77, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 79, 3, 79, 5, 79, 1348,
	10, 79, 3, 80, 3, 80, 3, 80, 3, 80, 7, 80, 1354, 10, 80, 12, 80, 14, 80,
	1357, 11, 80, 3, 80, 3, 80, 3, 80, 5, 80, 1362, 10, 80, 3, 81, 3, 81, 3,
	81, 5, 81, 1367, 10, 81, 3, 82, 3, 82, 3, 82, 3, 83, 3, 83, 3, 83, 3, 83,
	3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 5, 84, 1381, 10, 84, 3, 85, 3, 85, 3,
	86, 3, 86, 3, 86, 3, 86, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 88,
	3, 88, 3, 88, 3, 88, 7, 88, 1399, 10, 88, 12, 88, 14, 88, 1402, 11, 88,
	3, 89, 3, 89, 3, 89, 3, 89, 7, 89, 1408, 10, 89, 12, 89, 14, 89, 1411,
	11, 89, 3, 90, 3, 90, 3, 91, 3, 91, 3, 92, 3, 92, 3, 92, 3, 93, 3, 93,
	5, 93, 1422, 10, 93, 3, 93, 3, 93, 5, 93, 1426, 10, 93, 3, 94, 3, 94, 5,
	94, 1430, 10, 94, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95,
	3, 95, 3, 95, 3, 95, 3, 95, 5, 95, 1444, 10, 95, 3, 96, 3, 96, 3, 96, 3,
	96, 7, 96, 1450, 10, 96, 12, 96, 14, 96, 1453, 11, 96, 3, 97, 3, 97, 3,
	97, 3, 97, 3, 97, 3, 97, 5, 97, 1461, 10, 97, 3, 98, 3, 98, 3, 98, 3, 98,
	3, 99, 3, 99, 3, 99, 3, 100, 3, 100, 5, 100, 1472, 10, 100, 3, 100, 3,
	100, 3, 100, 5, 100, 1477, 10, 100, 3, 100, 3, 100, 3, 101, 3, 101, 3,
	101, 5, 101, 1484, 10, 101, 3, 101, 5, 101, 1487, 10, 101, 3, 101, 3, 101,
	3, 101, 3, 101, 5, 101, 1493, 10, 101, 3, 101, 3, 101, 3, 101, 3, 101,
	3, 101, 3, 102, 3, 102, 5, 102, 1502, 10, 102, 3, 103, 3, 103, 3, 103,
	3, 103, 5, 103, 1508, 10, 103, 3, 104, 3, 104, 3, 104, 3, 104, 3, 104,
	3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 106, 3, 106, 3, 106, 3, 106,
	3, 106, 3, 107, 5, 107, 1526, 10, 107, 3, 107, 3, 107, 5, 107, 1530, 10,
	107, 3, 107, 3, 107, 5, 107, 1534, 10, 107, 3, 107, 3, 107, 3, 107, 5,
	107, 1539, 10, 107, 3, 108, 3, 108, 3, 108, 3, 108, 7, 108, 1545, 10, 108,
	12, 108, 14, 108, 1548, 11, 108, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109,
	5, 109, 1555, 10, 109, 3, 109, 3, 109, 5, 109, 1559, 10, 109, 3, 110, 5,
	110, 1562, 10, 110, 3, 110, 3, 110, 3, 110, 3, 110, 5, 110, 1568, 10, 110,
	3, 110, 3, 110, 5, 110, 1572, 10, 110, 3, 110, 3, 110, 3, 110, 3, 110,
	3, 110, 5, 110, 1579, 10, 110, 3, 111, 3, 111, 3, 111, 3, 112, 3, 112,
	3, 112, 3, 112, 7, 112, 1588, 10, 112, 12, 112, 14, 112, 1591, 11, 112,
	3, 113, 3, 113, 3, 113, 3, 113, 3, 114, 3, 114, 3, 114, 3, 114, 7, 114,
	1601, 10, 114, 12, 114, 14, 114, 1604, 11, 114, 3, 115, 3, 115, 3, 115,
	3, 115, 3, 115, 3, 115, 5, 115, 1612, 10, 115, 3, 115, 3, 115, 3, 115,
	3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115,
	3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115,
	3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115,
	3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115,
	3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 5, 115, 1659, 10, 115,
	3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 7, 116, 1666, 10, 116, 12, 116,
	14, 116, 1669, 11, 116, 5, 116, 1671, 10, 116, 3, 116, 3, 116, 3, 117,
	3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117,
	7, 117, 1685, 10, 117, 12, 117, 14, 117, 1688, 11, 117, 3, 117, 3, 117,
	3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 7, 118, 1697, 10, 118, 12, 118,
	14, 118, 1700, 11, 118, 3, 118, 3, 118, 3, 119, 3, 119, 3, 119, 3, 119,
	3, 119, 7, 119, 1709, 10, 119, 12, 119, 14, 119, 1712, 11, 119, 3, 119,
	3, 119, 3, 119, 7, 119, 1717, 10, 119, 12, 119, 14, 119, 1720, 11, 119,
	5, 119, 1722, 10, 119, 3, 119, 3, 119, 3, 119, 3, 119, 7, 119, 1728, 10,
	119, 12, 119, 14, 119, 1731, 11, 119, 5, 119, 1733, 10, 119, 3, 119, 3,
	119, 3, 120, 5, 120, 1738, 10, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3,
	120, 5, 120, 1745, 10, 120, 3, 120, 3, 120, 5, 120, 1749, 10, 120, 3, 120,
	3, 120, 5, 120, 1753, 10, 120, 3, 120, 5, 120, 1756, 10, 120, 3, 121, 3,
	121, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 3,
	121, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 5, 121, 1774, 10, 121, 3,
	122, 3, 122, 3, 122, 3, 123, 3, 123, 3, 123, 3, 124, 3, 124, 3, 124, 3,
	125, 3, 125, 3, 125, 3, 125, 3, 126, 3, 126, 3, 126, 3, 127, 3, 127, 3,
	127, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 5, 127, 1800, 10, 127, 3,
	128, 3, 128, 3, 128, 3, 128, 3, 129, 3, 129, 3, 129, 3, 129, 7, 129, 1810,
	10, 129, 12, 129, 14, 129, 1813, 11, 129, 3, 130, 3, 130, 3, 130, 3, 130,
	7, 130, 1819, 10, 130, 12, 130, 14, 130, 1822, 11, 130, 3, 131, 3, 131,
	3, 131, 3, 131, 3, 131, 5, 131, 1829, 10, 131, 3, 132, 3, 132, 5, 132,
	1833, 10, 132, 3, 132, 5, 132, 1836, 10, 132, 3, 132, 3, 132, 3, 132, 5,
	132, 1841, 10, 132, 3, 132, 5, 132, 1844, 10, 132, 3, 132, 5, 132, 1847,
	10, 132, 3, 132, 5, 132, 1850, 10, 132, 3, 133, 3, 133, 3, 133, 3, 134,
	3, 134, 3, 134, 3, 135, 3, 135, 3, 135, 3, 136, 3, 136, 3, 136, 3, 136,
	5, 136, 1865, 10, 136, 3, 137, 3, 137, 3, 137, 3, 137, 3, 138, 3, 138,
	3, 138, 5, 138, 1874, 10, 138, 3, 139, 3, 139, 3, 139, 3, 140, 3, 140,
	3, 141, 3, 141, 5, 141, 1883, 10, 141, 3, 141, 3, 141, 3, 141, 7, 141,
	1888, 10, 141, 12, 141, 14, 141, 1891, 11, 141, 3, 142, 3, 142, 3, 142,
	3, 142, 3, 142, 3, 142, 3, 142, 5, 142, 1900, 10, 142, 3, 142, 3, 142,
	3, 142, 3, 142, 5, 142, 1906, 10, 142, 5, 142, 1908, 10, 142, 3, 143, 3,
	143, 3, 143, 3, 143, 7, 143, 1914, 10, 143, 12, 143, 14, 143, 1917, 11,
	143, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3,
	144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3,
	144, 3, 144, 3, 144, 5, 144, 1939, 10, 144, 3, 144, 3, 144, 3, 144, 3,
	144, 3, 144, 3, 144, 3, 144, 7, 144, 1948, 10, 144, 12, 144, 14, 144, 1951,
	11, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 7, 144,
	1960, 10, 144, 12, 144, 14, 144, 1963, 11, 144, 3, 144, 3, 144, 3, 144,
	3, 144, 3, 144, 3, 144, 3, 144, 7, 144, 1972, 10, 144, 12, 144, 14, 144,
	1975, 11, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 7, 144,
	1983, 10, 144, 12, 144, 14, 144, 1986, 11, 144, 3, 144, 3, 144, 5, 144,
	1990, 10, 144, 3, 145, 3, 145, 3, 145, 3, 145, 3, 146, 3, 146, 3, 146,
	3, 146, 3, 146, 3, 146, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147,
	3, 147, 5, 147, 2009, 10, 147, 3, 147, 5, 147, 2012, 10, 147, 3, 148, 3,
	148, 3, 148, 5, 148, 2017, 10, 148, 3, 148, 3, 148, 3, 148, 3, 148, 5,
	148, 2023, 10, 148, 7, 148, 2025, 10, 148, 12, 148, 14, 148, 2028, 11,
	148, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 5,
	149, 2038, 10, 149, 3, 150, 3, 150, 3, 151, 3, 151, 3, 152, 3, 152, 3,
	153, 3, 153, 3, 154, 3, 154, 3, 155, 3, 155, 3, 155, 3, 155, 5, 155, 2054,
	10, 155, 3, 156, 3, 156, 3, 156, 3, 156, 5, 156, 2060, 10, 156, 3, 157,
	3, 157, 3, 157, 3, 157, 5, 157, 2066, 10, 157, 3, 158, 3, 158, 5, 158,
	2070, 10, 158, 3, 159, 3, 159, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160,
	7, 160, 2079, 10, 160, 12, 160, 14, 160, 2082, 11, 160, 3, 160, 3, 160,
	3, 161, 3, 161, 5, 161, 2088, 10, 161, 3, 162, 3, 162, 3, 163, 3, 163,
	3, 164, 3, 164, 3, 165, 3, 165, 3, 166, 3, 166, 3, 167, 3, 167, 3, 168,
	3, 168, 3, 169, 3, 169, 3, 170, 3, 170, 3, 171, 3, 171, 3, 172, 3, 172,
	3, 173, 3, 173, 3, 173, 3, 174, 3, 174, 3, 175, 3, 175, 3, 176, 3, 176,
	3, 177, 3, 177, 3, 178, 3, 178, 3, 178, 3, 179, 3, 179, 3, 180, 3, 180,
	3, 181, 3, 181, 3, 182, 3, 182, 3, 183, 3, 183, 3, 184, 3, 184, 3, 185,
	3, 185, 3, 186, 3, 186, 3, 187, 3, 187, 3, 188, 3, 188, 3, 189, 3, 189,
	3, 190, 3, 190, 3, 191, 3, 191, 3, 192, 3, 192, 3, 193, 3, 193, 3, 194,
	3, 194, 3, 195, 3, 195, 3, 196, 3, 196, 3, 197, 3, 197, 3, 198, 3, 198,
	3, 199, 3, 199, 3, 200, 3, 200, 3, 201, 3, 201, 3, 202, 3, 202, 3, 203,
	3, 203, 3, 204, 3, 204, 3, 205, 3, 205, 3, 206, 3, 206, 3, 207, 3, 207,
	3, 208, 3, 208, 3, 209, 3, 209, 3, 210, 3, 210, 3, 211, 3, 211, 3, 212,
	3, 212, 3, 213, 3, 213, 3, 214, 3, 214, 3, 215, 3, 215, 3, 216, 3, 216,
	3, 217, 3, 217, 3, 218, 3, 218, 3, 219, 3, 219, 3, 220, 3, 220, 3, 221,
	3, 221, 3, 222, 3, 222, 3, 223, 3, 223, 3, 224, 3, 224, 3, 225, 3, 225,
	3, 226, 3, 226, 3, 227, 3, 227, 3, 228, 3, 228, 3, 229, 3, 229, 3, 230,
	3, 230, 3, 231, 3, 231, 3, 232, 3, 232, 3, 233, 3, 233, 3, 234, 3, 234,
	3, 235, 3, 235, 3, 236, 3, 236, 3, 237, 3, 237, 3, 238, 3, 238, 3, 239,
	3, 239, 3, 240, 3, 240, 3, 241, 3, 241, 3, 242, 3, 242, 3, 243, 3, 243,
	3, 244, 3, 244, 3, 245, 3, 245, 3, 246, 3, 246, 3, 247, 3, 247, 3, 248,
	3, 248, 3, 249, 3, 249, 3, 250, 3, 250, 3, 251, 3, 251, 3, 252, 3, 252,
	3, 253, 3, 253, 3, 254, 3, 254, 3, 255, 3, 255, 3, 256, 3, 256, 3, 257,
	3, 257, 3, 258, 3, 258, 3, 259, 3, 259, 3, 260, 3, 260, 3, 261, 3, 261,
	3, 262, 3, 262, 3, 263, 3, 263, 3, 264, 3, 264, 3, 265, 3, 265, 3, 266,
	3, 266, 3, 267, 3, 267, 3, 268, 3, 268, 3, 269, 3, 269, 3, 270, 3, 270,
	3, 271, 3, 271, 3, 272, 3, 272, 3, 273, 3, 273, 3, 274, 3, 274, 3, 275,
	3, 275, 3, 276, 3, 276, 3, 277, 3, 277, 3, 278, 3, 278, 3, 279, 3, 279,
	3, 280, 3, 280, 3, 281, 3, 281, 3, 281, 2, 2, 282, 2, 4, 6, 8, 10, 12,
	14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48,
	50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84,
	86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116,
	118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146,
	148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176,
	178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206,
	208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236,
	238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266,
	268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296,
	298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326,
	328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356,
	358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386,
	388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416,
	418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446,
	448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476,
	478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506,
	508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536,
	538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 2, 7, 4, 2,
	20, 20, 22, 22, 3, 2, 173, 177, 3, 2, 167, 168, 4, 2, 57, 57, 127, 127,
	7, 2, 115, 115, 123, 123, 137, 137, 143, 164, 171, 171, 2, 2325, 2, 563,
	3, 2, 2, 2, 4, 579, 3, 2, 2, 2, 6, 592, 3, 2, 2, 2, 8, 594, 3, 2, 2, 2,
	10, 633, 3, 2, 2, 2, 12, 635, 3, 2, 2, 2, 14, 642, 3, 2, 2, 2, 16, 645,
	3, 2, 2, 2, 18, 655, 3, 2, 2, 2, 20, 667, 3, 2, 2, 2, 22, 686, 3, 2, 2,
	2, 24, 726, 3, 2, 2, 2, 26, 728, 3, 2, 2, 2, 28, 741, 3, 2, 2, 2, 30, 750,
	3, 2, 2, 2, 32, 765, 3, 2, 2, 2, 34, 776, 3, 2, 2, 2, 36, 790, 3, 2, 2,
	2, 38, 823, 3, 2, 2, 2, 40, 830, 3, 2, 2, 2, 42, 839, 3, 2, 2, 2, 44, 850,
	3, 2, 2, 2, 46, 852, 3, 2, 2, 2, 48, 869, 3, 2, 2, 2, 50, 896, 3, 2, 2,
	2, 52, 898, 3, 2, 2, 2, 54, 911, 3, 2, 2, 2, 56, 917, 3, 2, 2, 2, 58, 947,
	3, 2, 2, 2, 60, 949, 3, 2, 2, 2, 62, 961, 3, 2, 2, 2, 64, 965, 3, 2, 2,
	2, 66, 978, 3, 2, 2, 2, 68, 990, 3, 2, 2, 2, 70, 993, 3, 2, 2, 2, 72, 1001,
	3, 2, 2, 2, 74, 1006, 3, 2, 2, 2, 76, 1008, 3, 2, 2, 2, 78, 1021, 3, 2,
	2, 2, 80, 1023, 3, 2, 2, 2, 82, 1026, 3, 2, 2, 2, 84, 1035, 3, 2, 2, 2,
	86, 1039, 3, 2, 2, 2, 88, 1051, 3, 2, 2, 2, 90, 1056, 3, 2, 2, 2, 92, 1072,
	3, 2, 2, 2, 94, 1074, 3, 2, 2, 2, 96, 1077, 3, 2, 2, 2, 98, 1082, 3, 2,
	2, 2, 100, 1086, 3, 2, 2, 2, 102, 1089, 3, 2, 2, 2, 104, 1098, 3, 2, 2,
	2, 106, 1101, 3, 2, 2, 2, 108, 1112, 3, 2, 2, 2, 110, 1118, 3, 2, 2, 2,
	112, 1144, 3, 2, 2, 2, 114, 1146, 3, 2, 2, 2, 116, 1160, 3, 2, 2, 2, 118,
	1167, 3, 2, 2, 2, 120, 1179, 3, 2, 2, 2, 122, 1192, 3, 2, 2, 2, 124, 1204,
	3, 2, 2, 2, 126, 1216, 3, 2, 2, 2, 128, 1230, 3, 2, 2, 2, 130, 1237, 3,
	2, 2, 2, 132, 1249, 3, 2, 2, 2, 134, 1256, 3, 2, 2, 2, 136, 1268, 3, 2,
	2, 2, 138, 1285, 3, 2, 2, 2, 140, 1292, 3, 2, 2, 2, 142, 1302, 3, 2, 2,
	2, 144, 1319, 3, 2, 2, 2, 146, 1321, 3, 2, 2, 2, 148, 1325, 3, 2, 2, 2,
	150, 1327, 3, 2, 2, 2, 152, 1339, 3, 2, 2, 2, 154, 1343, 3, 2, 2, 2, 156,
	1347, 3, 2, 2, 2, 158, 1349, 3, 2, 2, 2, 160, 1363, 3, 2, 2, 2, 162, 1368,
	3, 2, 2, 2, 164, 1371, 3, 2, 2, 2, 166, 1380, 3, 2, 2, 2, 168, 1382, 3,
	2, 2, 2, 170, 1384, 3, 2, 2, 2, 172, 1388, 3, 2, 2, 2, 174, 1394, 3, 2,
	2, 2, 176, 1403, 3, 2, 2, 2, 178, 1412, 3, 2, 2, 2, 180, 1414, 3, 2, 2,
	2, 182, 1416, 3, 2, 2, 2, 184, 1419, 3, 2, 2, 2, 186, 1429, 3, 2, 2, 2,
	188, 1431, 3, 2, 2, 2, 190, 1445, 3, 2, 2, 2, 192, 1460, 3, 2, 2, 2, 194,
	1462, 3, 2, 2, 2, 196, 1466, 3, 2, 2, 2, 198, 1469, 3, 2, 2, 2, 200, 1480,
	3, 2, 2, 2, 202, 1501, 3, 2, 2, 2, 204, 1507, 3, 2, 2, 2, 206, 1509, 3,
	2, 2, 2, 208, 1514, 3, 2, 2, 2, 210, 1519, 3, 2, 2, 2, 212, 1525, 3, 2,
	2, 2, 214, 1540, 3, 2, 2, 2, 216, 1558, 3, 2, 2, 2, 218, 1561, 3, 2, 2,
	2, 220, 1580, 3, 2, 2, 2, 222, 1583, 3, 2, 2, 2, 224, 1592, 3, 2, 2, 2,
	226, 1596, 3, 2, 2, 2, 228, 1658, 3, 2, 2, 2, 230, 1660, 3, 2, 2, 2, 232,
	1674, 3, 2, 2, 2, 234, 1691, 3, 2, 2, 2, 236, 1703, 3, 2, 2, 2, 238, 1737,
	3, 2, 2, 2, 240, 1773, 3, 2, 2, 2, 242, 1775, 3, 2, 2, 2, 244, 1778, 3,
	2, 2, 2, 246, 1781, 3, 2, 2, 2, 248, 1784, 3, 2, 2, 2, 250, 1788, 3, 2,
	2, 2, 252, 1799, 3, 2, 2, 2, 254, 1801, 3, 2, 2, 2, 256, 1805, 3, 2, 2,
	2, 258, 1814, 3, 2, 2, 2, 260, 1828, 3, 2, 2, 2, 262, 1830, 3, 2, 2, 2,
	264, 1851, 3, 2, 2, 2, 266, 1854, 3, 2, 2, 2, 268, 1857, 3, 2, 2, 2, 270,
	1864, 3, 2, 2, 2, 272, 1866, 3, 2, 2, 2, 274, 1870, 3, 2, 2, 2, 276, 1875,
	3, 2, 2, 2, 278, 1878, 3, 2, 2, 2, 280, 1882, 3, 2, 2, 2, 282, 1907, 3,
	2, 2, 2, 284, 1909, 3, 2, 2, 2, 286, 1989, 3, 2, 2, 2, 288, 1991, 3, 2,
	2, 2, 290, 1995, 3, 2, 2, 2, 292, 2011, 3, 2, 2, 2, 294, 2016, 3, 2, 2,
	2, 296, 2037, 3, 2, 2, 2, 298, 2039, 3, 2, 2, 2, 300, 2041, 3, 2, 2, 2,
	302, 2043, 3, 2, 2, 2, 304, 2045, 3, 2, 2, 2, 306, 2047, 3, 2, 2, 2, 308,
	2053, 3, 2, 2, 2, 310, 2059, 3, 2, 2, 2, 312, 2065, 3, 2, 2, 2, 314, 2067,
	3, 2, 2, 2, 316, 2071, 3, 2, 2, 2, 318, 2073, 3, 2, 2, 2, 320, 2087, 3,
	2, 2, 2, 322, 2089, 3, 2, 2, 2, 324, 2091, 3, 2, 2, 2, 326, 2093, 3, 2,
	2, 2, 328, 2095, 3, 2, 2, 2, 330, 2097, 3, 2, 2, 2, 332, 2099, 3, 2, 2,
	2, 334, 2101, 3, 2, 2, 2, 336, 2103, 3, 2, 2, 2, 338, 2105, 3, 2, 2, 2,
	340, 2107, 3, 2, 2, 2, 342, 2109, 3, 2, 2, 2, 344, 2111, 3, 2, 2, 2, 346,
	2114, 3, 2, 2, 2, 348, 2116, 3, 2, 2, 2, 350, 2118, 3, 2, 2, 2, 352, 2120,
	3, 2, 2, 2, 354, 2122, 3, 2, 2, 2, 356, 2125, 3, 2, 2, 2, 358, 2127, 3,
	2, 2, 2, 360, 2129, 3, 2, 2, 2, 362, 2131, 3, 2, 2, 2, 364, 2133, 3, 2,
	2, 2, 366, 2135, 3, 2, 2, 2, 368, 2137, 3, 2, 2, 2, 370, 2139, 3, 2, 2,
	2, 372, 2141, 3, 2, 2, 2, 374, 2143, 3, 2, 2, 2, 376, 2145, 3, 2, 2, 2,
	378, 2147, 3, 2, 2, 2, 380, 2149, 3, 2, 2, 2, 382, 2151, 3, 2, 2, 2, 384,
	2153, 3, 2, 2, 2, 386, 2155, 3, 2, 2, 2, 388, 2157, 3, 2, 2, 2, 390, 2159,
	3, 2, 2, 2, 392, 2161, 3, 2, 2, 2, 394, 2163, 3, 2, 2, 2, 396, 2165, 3,
	2, 2, 2, 398, 2167, 3, 2, 2, 2, 400, 2169, 3, 2, 2, 2, 402, 2171, 3, 2,
	2, 2, 404, 2173, 3, 2, 2, 2, 406, 2175, 3, 2, 2, 2, 408, 2177, 3, 2, 2,
	2, 410, 2179, 3, 2, 2, 2, 412, 2181, 3, 2, 2, 2, 414, 2183, 3, 2, 2, 2,
	416, 2185, 3, 2, 2, 2, 418, 2187, 3, 2, 2, 2, 420, 2189, 3, 2, 2, 2, 422,
	2191, 3, 2, 2, 2, 424, 2193, 3, 2, 2, 2, 426, 2195, 3, 2, 2, 2, 428, 2197,
	3, 2, 2, 2, 430, 2199, 3, 2, 2, 2, 432, 2201, 3, 2, 2, 2, 434, 2203, 3,
	2, 2, 2, 436, 2205, 3, 2, 2, 2, 438, 2207, 3, 2, 2, 2, 440, 2209, 3, 2,
	2, 2, 442, 2211, 3, 2, 2, 2, 444, 2213, 3, 2, 2, 2, 446, 2215, 3, 2, 2,
	2, 448, 2217, 3, 2, 2, 2, 450, 2219, 3, 2, 2, 2, 452, 2221, 3, 2, 2, 2,
	454, 2223, 3, 2, 2, 2, 456, 2225, 3, 2, 2, 2, 458, 2227, 3, 2, 2, 2, 460,
	2229, 3, 2, 2, 2, 462, 2231, 3, 2, 2, 2, 464, 2233, 3, 2, 2, 2, 466, 2235,
	3, 2, 2, 2, 468, 2237, 3, 2, 2, 2, 470, 2239, 3, 2, 2, 2, 472, 2241, 3,
	2, 2, 2, 474, 2243, 3, 2, 2, 2, 476, 2245, 3, 2, 2, 2, 478, 2247, 3, 2,
	2, 2, 480, 2249, 3, 2, 2, 2, 482, 2251, 3, 2, 2, 2, 484, 2253, 3, 2, 2,
	2, 486, 2255, 3, 2, 2, 2, 488, 2257, 3, 2, 2, 2, 490, 2259, 3, 2, 2, 2,
	492, 2261, 3, 2, 2, 2, 494, 2263, 3, 2, 2, 2, 496, 2265, 3, 2, 2, 2, 498,
	2267, 3, 2, 2, 2, 500, 2269, 3, 2, 2, 2, 502, 2271, 3, 2, 2, 2, 504, 2273,
	3, 2, 2, 2, 506, 2275, 3, 2, 2, 2, 508, 2277, 3, 2, 2, 2, 510, 2279, 3,
	2, 2, 2, 512, 2281, 3, 2, 2, 2, 514, 2283, 3, 2, 2, 2, 516, 2285, 3, 2,
	2, 2, 518, 2287, 3, 2, 2, 2, 520, 2289, 3, 2, 2, 2, 522, 2291, 3, 2, 2,
	2, 524, 2293, 3, 2, 2, 2, 526, 2295, 3, 2, 2, 2, 528, 2297, 3, 2, 2, 2,
	530, 2299, 3, 2, 2, 2, 532, 2301, 3, 2, 2, 2, 534, 2303, 3, 2, 2, 2, 536,
	2305, 3, 2, 2, 2, 538, 2307, 3, 2, 2, 2, 540, 2309, 3, 2, 2, 2, 542, 2311,
	3, 2, 2, 2, 544, 2313, 3, 2, 2, 2, 546, 2315, 3, 2, 2, 2, 548, 2317, 3,
	2, 2, 2, 550, 2319, 3, 2, 2, 2, 552, 2321, 3, 2, 2, 2, 554, 2323, 3, 2,
	2, 2, 556, 2325, 3, 2, 2, 2, 558, 2327, 3, 2, 2, 2, 560, 2329, 3, 2, 2,
	2, 562, 564, 5, 4, 3, 2, 563, 562, 3, 2, 2, 2, 563, 564, 3, 2, 2, 2, 564,
	566, 3, 2, 2, 2, 565, 567, 7, 21, 2, 2, 566, 565, 3, 2, 2, 2, 566, 567,
	3, 2, 2, 2, 567, 568, 3, 2, 2, 2, 568, 569, 5, 540, 271, 2, 569, 3, 3,
	2, 2, 2, 570, 572, 5, 10, 6, 2, 571, 573, 7, 21, 2, 2, 572, 571, 3, 2,
	2, 2, 572, 573, 3, 2, 2, 2, 573, 574, 3, 2, 2, 2, 574, 575, 5, 6, 4, 2,
	575, 578, 3, 2, 2, 2, 576, 578, 5, 8, 5, 2, 577, 570, 3, 2, 2, 2, 577,
	576, 3, 2, 2, 2, 578, 581, 3, 2, 2, 2, 579, 577, 3, 2, 2, 2, 579, 580,
	3, 2, 2, 2, 580, 590, 3, 2, 2, 2, 581, 579, 3, 2, 2, 2, 582, 587, 5, 10,
	6, 2, 583, 585, 7, 21, 2, 2, 584, 583, 3, 2, 2, 2, 584, 585, 3, 2, 2, 2,
	585, 586, 3, 2, 2, 2, 586, 588, 5, 6, 4, 2, 587, 584, 3, 2, 2, 2, 587,
	588, 3, 2, 2, 2, 588, 591, 3, 2, 2, 2, 589, 591, 5, 8, 5, 2, 590, 582,
	3, 2, 2, 2, 590, 589, 3, 2, 2, 2, 591, 5, 3, 2, 2, 2, 592, 593, 7, 10,
	2, 2, 593, 7, 3, 2, 2, 2, 594, 595, 5, 6, 4, 2, 595, 9, 3, 2, 2, 2, 596,
	634, 5, 188, 95, 2, 597, 634, 5, 114, 58, 2, 598, 634, 5, 108, 55, 2, 599,
	634, 5, 90, 46, 2, 600, 634, 5, 76, 39, 2, 601, 634, 5, 70, 36, 2, 602,
	634, 5, 182, 92, 2, 603, 634, 5, 56, 29, 2, 604, 634, 5, 48, 25, 2, 605,
	634, 5, 200, 101, 2, 606, 634, 5, 46, 24, 2, 607, 634, 5, 36, 19, 2, 608,
	634, 5, 28, 15, 2, 609, 634, 5, 136, 69, 2, 610, 634, 5, 34, 18, 2, 611,
	634, 5, 30, 16, 2, 612, 634, 5, 26, 14, 2, 613, 634, 5, 212, 107, 2, 614,
	634, 5, 122, 62, 2, 615, 634, 5, 124, 63, 2, 616, 634, 5, 134, 68, 2, 617,
	634, 5, 132, 67, 2, 618, 634, 5, 120, 61, 2, 619, 634, 5, 128, 65, 2, 620,
	634, 5, 130, 66, 2, 621, 634, 5, 126, 64, 2, 622, 634, 5, 118, 60, 2, 623,
	634, 5, 116, 59, 2, 624, 634, 5, 20, 11, 2, 625, 634, 5, 238, 120, 2, 626,
	634, 5, 18, 10, 2, 627, 634, 5, 16, 9, 2, 628, 634, 5, 12, 7, 2, 629, 634,
	5, 262, 132, 2, 630, 634, 5, 198, 100, 2, 631, 634, 5, 218, 110, 2, 632,
	634, 5, 196, 99, 2, 633, 596, 3, 2, 2, 2, 633, 597, 3, 2, 2, 2, 633, 598,
	3, 2, 2, 2, 633, 599, 3, 2, 2, 2, 633, 600, 3, 2, 2, 2, 633, 601, 3, 2,
	2, 2, 633, 602, 3, 2, 2, 2, 633, 603, 3, 2, 2, 2, 633, 604, 3, 2, 2, 2,
	633, 605, 3, 2, 2, 2, 633, 606, 3, 2, 2, 2, 633, 607, 3, 2, 2, 2, 633,
	608, 3, 2, 2, 2, 633, 609, 3, 2, 2, 2, 633, 610, 3, 2, 2, 2, 633, 611,
	3, 2, 2, 2, 633, 612, 3, 2, 2, 2, 633, 613, 3, 2, 2, 2, 633, 614, 3, 2,
	2, 2, 633, 615, 3, 2, 2, 2, 633, 616, 3, 2, 2, 2, 633, 617, 3, 2, 2, 2,
	633, 618, 3, 2, 2, 2, 633, 619, 3, 2, 2, 2, 633, 620, 3, 2, 2, 2, 633,
	621, 3, 2, 2, 2, 633, 622, 3, 2, 2, 2, 633, 623, 3, 2, 2, 2, 633, 624,
	3, 2, 2, 2, 633, 625, 3, 2, 2, 2, 633, 626, 3, 2, 2, 2, 633, 627, 3, 2,
	2, 2, 633, 628, 3, 2, 2, 2, 633, 629, 3, 2, 2, 2, 633, 630, 3, 2, 2, 2,
	633, 631, 3, 2, 2, 2, 633, 632, 3, 2, 2, 2, 634, 11, 3, 2, 2, 2, 635, 636,
	5, 538, 270, 2, 636, 637, 5, 22, 12, 2, 637, 638, 5, 468, 235, 2, 638,
	639, 5, 24, 13, 2, 639, 640, 5, 408, 205, 2, 640, 641, 5, 322, 162, 2,
	641, 13, 3, 2, 2, 2, 642, 643, 5, 448, 225, 2, 643, 644, 5, 526, 264, 2,
	644, 15, 3, 2, 2, 2, 645, 646, 5, 448, 225, 2, 646, 650, 5, 490, 246, 2,
	647, 648, 5, 466, 234, 2, 648, 649, 5, 322, 162, 2, 649, 651, 3, 2, 2,
	2, 650, 647, 3, 2, 2, 2, 650, 651, 3, 2, 2, 2, 651, 653, 3, 2, 2, 2, 652,
	654, 5, 460, 231, 2, 653, 652, 3, 2, 2, 2, 653, 654, 3, 2, 2, 2, 654, 17,
	3, 2, 2, 2, 655, 656, 5, 448, 225, 2, 656, 660, 5, 22, 12, 2, 657, 658,
	5, 468, 235, 2, 658, 659, 5, 24, 13, 2, 659, 661, 3, 2, 2, 2, 660, 657,
	3, 2, 2, 2, 660, 661, 3, 2, 2, 2, 661, 665, 3, 2, 2, 2, 662, 663, 5, 466,
	234, 2, 663, 664, 5, 322, 162, 2, 664, 666, 3, 2, 2, 2, 665, 662, 3, 2,
	2, 2, 665, 666, 3, 2, 2, 2, 666, 19, 3, 2, 2, 2, 667, 668, 5, 416, 209,
	2, 668, 669, 5, 22, 12, 2, 669, 670, 5, 468, 235, 2, 670, 671, 5, 24, 13,
	2, 671, 672, 5, 508, 255, 2, 672, 673, 5, 322, 162, 2, 673, 21, 3, 2, 2,
	2, 674, 677, 5, 352, 177, 2, 675, 677, 5, 354, 178, 2, 676, 674, 3, 2,
	2, 2, 676, 675, 3, 2, 2, 2, 677, 687, 3, 2, 2, 2, 678, 687, 5, 358, 180,
	2, 679, 687, 5, 368, 185, 2, 680, 687, 5, 390, 196, 2, 681, 687, 5, 400,
	201, 2, 682, 687, 5, 384, 193, 2, 683, 687, 5, 394, 198, 2, 684, 687, 5,
	456, 229, 2, 685, 687, 5, 492, 247, 2, 686, 676, 3, 2, 2, 2, 686, 678,
	3, 2, 2, 2, 686, 679, 3, 2, 2, 2, 686, 680, 3, 2, 2, 2, 686, 681, 3, 2,
	2, 2, 686, 682, 3, 2, 2, 2, 686, 683, 3, 2, 2, 2, 686, 684, 3, 2, 2, 2,
	686, 685, 3, 2, 2, 2, 687, 23, 3, 2, 2, 2, 688, 689, 5, 352, 177, 2, 689,
	690, 5, 414, 208, 2, 690, 727, 3, 2, 2, 2, 691, 692, 5, 352, 177, 2, 692,
	693, 5, 414, 208, 2, 693, 694, 5, 420, 211, 2, 694, 695, 5, 440, 221, 2,
	695, 696, 5, 308, 155, 2, 696, 727, 3, 2, 2, 2, 697, 701, 5, 412, 207,
	2, 698, 699, 5, 308, 155, 2, 699, 700, 7, 16, 2, 2, 700, 702, 3, 2, 2,
	2, 701, 698, 3, 2, 2, 2, 701, 702, 3, 2, 2, 2, 702, 703, 3, 2, 2, 2, 703,
	704, 5, 334, 168, 2, 704, 727, 3, 2, 2, 2, 705, 706, 5, 352, 177, 2, 706,
	707, 5, 442, 222, 2, 707, 727, 3, 2, 2, 2, 708, 709, 5, 440, 221, 2, 709,
	710, 5, 308, 155, 2, 710, 727, 3, 2, 2, 2, 711, 713, 5, 504, 253, 2, 712,
	711, 3, 2, 2, 2, 712, 713, 3, 2, 2, 2, 713, 717, 3, 2, 2, 2, 714, 715,
	5, 308, 155, 2, 715, 716, 7, 16, 2, 2, 716, 718, 3, 2, 2, 2, 717, 714,
	3, 2, 2, 2, 717, 718, 3, 2, 2, 2, 718, 719, 3, 2, 2, 2, 719, 727, 5, 310,
	156, 2, 720, 721, 5, 352, 177, 2, 721, 722, 5, 490, 246, 2, 722, 727, 3,
	2, 2, 2, 723, 724, 5, 488, 245, 2, 724, 725, 5, 322, 162, 2, 725, 727,
	3, 2, 2, 2, 726, 688, 3, 2, 2, 2, 726, 691, 3, 2, 2, 2, 726, 697, 3, 2,
	2, 2, 726, 705, 3, 2, 2, 2, 726, 708, 3, 2, 2, 2, 726, 712, 3, 2, 2, 2,
	726, 720, 3, 2, 2, 2, 726, 723, 3, 2, 2, 2, 727, 25, 3, 2, 2, 2, 728, 729,
	5, 384, 193, 2, 729, 731, 5, 524, 263, 2, 730, 732, 5, 248, 125, 2, 731,
	730, 3, 2, 2, 2, 731, 732, 3, 2, 2, 2, 732, 733, 3, 2, 2, 2, 733, 734,
	5, 338, 170, 2, 734, 735, 5, 536, 269, 2, 735, 736, 5, 476, 239, 2, 736,
	739, 5, 302, 152, 2, 737, 740, 5, 502, 252, 2, 738, 740, 5, 458, 230, 2,
	739, 737, 3, 2, 2, 2, 739, 738, 3, 2, 2, 2, 739, 740, 3, 2, 2, 2, 740,
	27, 3, 2, 2, 2, 741, 742, 5, 384, 193, 2, 742, 744, 5, 488, 245, 2, 743,
	745, 5, 248, 125, 2, 744, 743, 3, 2, 2, 2, 744, 745, 3, 2, 2, 2, 745, 746,
	3, 2, 2, 2, 746, 748, 5, 322, 162, 2, 747, 749, 5, 110, 56, 2, 748, 747,
	3, 2, 2, 2, 748, 749, 3, 2, 2, 2, 749, 29, 3, 2, 2, 2, 750, 751, 5, 384,
	193, 2, 751, 753, 5, 516, 259, 2, 752, 754, 5, 248, 125, 2, 753, 752, 3,
	2, 2, 2, 753, 754, 3, 2, 2, 2, 754, 758, 3, 2, 2, 2, 755, 756, 5, 308,
	155, 2, 756, 757, 7, 16, 2, 2, 757, 759, 3, 2, 2, 2, 758, 755, 3, 2, 2,
	2, 758, 759, 3, 2, 2, 2, 759, 760, 3, 2, 2, 2, 760, 761, 5, 330, 166, 2,
	761, 762, 5, 542, 272, 2, 762, 763, 5, 32, 17, 2, 763, 764, 5, 544, 273,
	2, 764, 31, 3, 2, 2, 2, 765, 766, 5, 312, 157, 2, 766, 773, 5, 314, 158,
	2, 767, 768, 5, 558, 280, 2, 768, 769, 5, 312, 157, 2, 769, 770, 5, 314,
	158, 2, 770, 772, 3, 2, 2, 2, 771, 767, 3, 2, 2, 2, 772, 775, 3, 2, 2,
	2, 773, 771, 3, 2, 2, 2, 773, 774, 3, 2, 2, 2, 774, 33, 3, 2, 2, 2, 775,
	773, 3, 2, 2, 2, 776, 777, 5, 384, 193, 2, 777, 779, 5, 510, 256, 2, 778,
	780, 5, 248, 125, 2, 779, 778, 3, 2, 2, 2, 779, 780, 3, 2, 2, 2, 780, 784,
	3, 2, 2, 2, 781, 782, 5, 308, 155, 2, 782, 783, 7, 16, 2, 2, 783, 785,
	3, 2, 2, 2, 784, 781, 3, 2, 2, 2, 784, 785, 3, 2, 2, 2, 785, 786, 3, 2,
	2, 2, 786, 787, 5, 324, 163, 2, 787, 788, 5, 528, 265, 2, 788, 789, 5,
	326, 164, 2, 789, 35, 3, 2, 2, 2, 790, 791, 5, 384, 193, 2, 791, 792, 5,
	454, 228, 2, 792, 794, 5, 532, 267, 2, 793, 795, 5, 248, 125, 2, 794, 793,
	3, 2, 2, 2, 794, 795, 3, 2, 2, 2, 795, 799, 3, 2, 2, 2, 796, 797, 5, 308,
	155, 2, 797, 798, 7, 16, 2, 2, 798, 800, 3, 2, 2, 2, 799, 796, 3, 2, 2,
	2, 799, 800, 3, 2, 2, 2, 800, 801, 3, 2, 2, 2, 801, 802, 5, 328, 165, 2,
	802, 803, 5, 364, 183, 2, 803, 804, 5, 492, 247, 2, 804, 805, 5, 256, 129,
	2, 805, 809, 5, 408, 205, 2, 806, 807, 5, 308, 155, 2, 807, 808, 7, 16,
	2, 2, 808, 810, 3, 2, 2, 2, 809, 806, 3, 2, 2, 2, 809, 810, 3, 2, 2, 2,
	810, 811, 3, 2, 2, 2, 811, 812, 5, 310, 156, 2, 812, 813, 5, 38, 20, 2,
	813, 814, 5, 478, 240, 2, 814, 815, 5, 436, 219, 2, 815, 816, 5, 542, 272,
	2, 816, 817, 5, 256, 129, 2, 817, 821, 5, 544, 273, 2, 818, 819, 5, 536,
	269, 2, 819, 820, 5, 44, 23, 2, 820, 822, 3, 2, 2, 2, 821, 818, 3, 2, 2,
	2, 821, 822, 3, 2, 2, 2, 822, 37, 3, 2, 2, 2, 823, 824, 5, 534, 268, 2,
	824, 828, 5, 40, 21, 2, 825, 826, 5, 360, 181, 2, 826, 827, 5, 284, 143,
	2, 827, 829, 3, 2, 2, 2, 828, 825, 3, 2, 2, 2, 828, 829, 3, 2, 2, 2, 829,
	39, 3, 2, 2, 2, 830, 836, 5, 42, 22, 2, 831, 832, 5, 360, 181, 2, 832,
	833, 5, 42, 22, 2, 833, 835, 3, 2, 2, 2, 834, 831, 3, 2, 2, 2, 835, 838,
	3, 2, 2, 2, 836, 834, 3, 2, 2, 2, 836, 837, 3, 2, 2, 2, 837, 41, 3, 2,
	2, 2, 838, 836, 3, 2, 2, 2, 839, 840, 5, 312, 157, 2, 840, 841, 5, 432,
	217, 2, 841, 842, 5, 462, 232, 2, 842, 843, 5, 464, 233, 2, 843, 43, 3,
	2, 2, 2, 844, 851, 5, 142, 72, 2, 845, 846, 5, 142, 72, 2, 846, 847, 5,
	360, 181, 2, 847, 848, 5, 140, 71, 2, 848, 851, 3, 2, 2, 2, 849, 851, 5,
	140, 71, 2, 850, 844, 3, 2, 2, 2, 850, 845, 3, 2, 2, 2, 850, 849, 3, 2,
	2, 2, 851, 45, 3, 2, 2, 2, 852, 853, 5, 384, 193, 2, 853, 855, 5, 440,
	221, 2, 854, 856, 5, 248, 125, 2, 855, 854, 3, 2, 2, 2, 855, 856, 3, 2,
	2, 2, 856, 857, 3, 2, 2, 2, 857, 858, 5, 308, 155, 2, 858, 859, 5, 536,
	269, 2, 859, 860, 5, 484, 243, 2, 860, 861, 7, 173, 2, 2, 861, 862, 5,
	546, 274, 2, 862, 863, 5, 190, 96, 2, 863, 867, 5, 548, 275, 2, 864, 865,
	5, 360, 181, 2, 865, 866, 5, 194, 98, 2, 866, 868, 3, 2, 2, 2, 867, 864,
	3, 2, 2, 2, 867, 868, 3, 2, 2, 2, 868, 47, 3, 2, 2, 2, 869, 871, 5, 384,
	193, 2, 870, 872, 5, 68, 35, 2, 871, 870, 3, 2, 2, 2, 871, 872, 3, 2, 2,
	2, 872, 873, 3, 2, 2, 2, 873, 875, 5, 412, 207, 2, 874, 876, 5, 248, 125,
	2, 875, 874, 3, 2, 2, 2, 875, 876, 3, 2, 2, 2, 876, 880, 3, 2, 2, 2, 877,
	878, 5, 308, 155, 2, 878, 879, 7, 16, 2, 2, 879, 881, 3, 2, 2, 2, 880,
	877, 3, 2, 2, 2, 880, 881, 3, 2, 2, 2, 881, 882, 3, 2, 2, 2, 882, 883,
	5, 334, 168, 2, 883, 885, 5, 542, 272, 2, 884, 886, 5, 52, 27, 2, 885,
	884, 3, 2, 2, 2, 885, 886, 3, 2, 2, 2, 886, 887, 3, 2, 2, 2, 887, 888,
	5, 544, 273, 2, 888, 889, 5, 54, 28, 2, 889, 890, 5, 486, 244, 2, 890,
	891, 5, 314, 158, 2, 891, 892, 5, 444, 223, 2, 892, 893, 5, 336, 169, 2,
	893, 894, 5, 364, 183, 2, 894, 895, 5, 50, 26, 2, 895, 49, 3, 2, 2, 2,
	896, 897, 7, 165, 2, 2, 897, 51, 3, 2, 2, 2, 898, 904, 5, 344, 173, 2,
	899, 900, 5, 558, 280, 2, 900, 901, 5, 344, 173, 2, 901, 903, 3, 2, 2,
	2, 902, 899, 3, 2, 2, 2, 903, 906, 3, 2, 2, 2, 904, 902, 3, 2, 2, 2, 904,
	905, 3, 2, 2, 2, 905, 53, 3, 2, 2, 2, 906, 904, 3, 2, 2, 2, 907, 912, 5,
	376, 189, 2, 908, 909, 5, 486, 244, 2, 909, 910, 5, 464, 233, 2, 910, 912,
	3, 2, 2, 2, 911, 907, 3, 2, 2, 2, 911, 908, 3, 2, 2, 2, 912, 913, 3, 2,
	2, 2, 913, 914, 5, 468, 235, 2, 914, 915, 5, 464, 233, 2, 915, 916, 5,
	426, 214, 2, 916, 55, 3, 2, 2, 2, 917, 919, 5, 384, 193, 2, 918, 920, 5,
	68, 35, 2, 919, 918, 3, 2, 2, 2, 919, 920, 3, 2, 2, 2, 920, 921, 3, 2,
	2, 2, 921, 923, 5, 350, 176, 2, 922, 924, 5, 248, 125, 2, 923, 922, 3,
	2, 2, 2, 923, 924, 3, 2, 2, 2, 924, 928, 3, 2, 2, 2, 925, 926, 5, 308,
	155, 2, 926, 927, 7, 16, 2, 2, 927, 929, 3, 2, 2, 2, 928, 925, 3, 2, 2,
	2, 928, 929, 3, 2, 2, 2, 929, 930, 3, 2, 2, 2, 930, 931, 5, 332, 167, 2,
	931, 932, 5, 542, 272, 2, 932, 933, 5, 314, 158, 2, 933, 934, 5, 544, 273,
	2, 934, 935, 5, 496, 249, 2, 935, 936, 5, 334, 168, 2, 936, 937, 5, 500,
	251, 2, 937, 938, 5, 314, 158, 2, 938, 939, 5, 406, 204, 2, 939, 940, 5,
	334, 168, 2, 940, 941, 5, 424, 213, 2, 941, 942, 5, 58, 30, 2, 942, 57,
	3, 2, 2, 2, 943, 948, 5, 296, 149, 2, 944, 948, 5, 66, 34, 2, 945, 948,
	5, 64, 33, 2, 946, 948, 5, 60, 31, 2, 947, 943, 3, 2, 2, 2, 947, 944, 3,
	2, 2, 2, 947, 945, 3, 2, 2, 2, 947, 946, 3, 2, 2, 2, 948, 59, 3, 2, 2,
	2, 949, 950, 5, 546, 274, 2, 950, 956, 5, 62, 32, 2, 951, 952, 5, 558,
	280, 2, 952, 953, 5, 62, 32, 2, 953, 955, 3, 2, 2, 2, 954, 951, 3, 2, 2,
	2, 955, 958, 3, 2, 2, 2, 956, 954, 3, 2, 2, 2, 956, 957, 3, 2, 2, 2, 957,
	959, 3, 2, 2, 2, 958, 956, 3, 2, 2, 2, 959, 960, 5, 548, 275, 2, 960, 61,
	3, 2, 2, 2, 961, 962, 5, 342, 172, 2, 962, 963, 7, 11, 2, 2, 963, 964,
	5, 58, 30, 2, 964, 63, 3, 2, 2, 2, 965, 966, 5, 542, 272, 2, 966, 973,
	5, 66, 34, 2, 967, 968, 5, 558, 280, 2, 968, 969, 5, 296, 149, 2, 969,
	972, 3, 2, 2, 2, 970, 972, 5, 66, 34, 2, 971, 967, 3, 2, 2, 2, 971, 970,
	3, 2, 2, 2, 972, 975, 3, 2, 2, 2, 973, 971, 3, 2, 2, 2, 973, 974, 3, 2,
	2, 2, 974, 976, 3, 2, 2, 2, 975, 973, 3, 2, 2, 2, 976, 977, 5, 544, 273,
	2, 977, 65, 3, 2, 2, 2, 978, 979, 5, 542, 272, 2, 979, 985, 5, 296, 149,
	2, 980, 981, 5, 558, 280, 2, 981, 982, 5, 296, 149, 2, 982, 984, 3, 2,
	2, 2, 983, 980, 3, 2, 2, 2, 984, 987, 3, 2, 2, 2, 985, 983, 3, 2, 2, 2,
	985, 986, 3, 2, 2, 2, 986, 988, 3, 2, 2, 2, 987, 985, 3, 2, 2, 2, 988,
	989, 5, 544, 273, 2, 989, 67, 3, 2, 2, 2, 990, 991, 5, 472, 237, 2, 991,
	992, 5, 482, 242, 2, 992, 69, 3, 2, 2, 2, 993, 994, 5, 358, 180, 2, 994,
	995, 5, 524, 263, 2, 995, 996, 5, 338, 170, 2, 996, 997, 5, 536, 269, 2,
	997, 999, 5, 72, 37, 2, 998, 1000, 5, 74, 38, 2, 999, 998, 3, 2, 2, 2,
	999, 1000, 3, 2, 2, 2, 1000, 71, 3, 2, 2, 2, 1001, 1002, 5, 476, 239, 2,
	1002, 1003, 5, 302, 152, 2, 1003, 73, 3, 2, 2, 2, 1004, 1007, 5, 502, 252,
	2, 1005, 1007, 5, 458, 230, 2, 1006, 1004, 3, 2, 2, 2, 1006, 1005, 3, 2,
	2, 2, 1007, 75, 3, 2, 2, 2, 1008, 1009, 5, 358, 180, 2, 1009, 1013, 5,
	516, 259, 2, 1010, 1011, 5, 308, 155, 2, 1011, 1012, 7, 16, 2, 2, 1012,
	1014, 3, 2, 2, 2, 1013, 1010, 3, 2, 2, 2, 1013, 1014, 3, 2, 2, 2, 1014,
	1015, 3, 2, 2, 2, 1015, 1016, 5, 330, 166, 2, 1016, 1017, 5, 78, 40, 2,
	1017, 77, 3, 2, 2, 2, 1018, 1022, 5, 88, 45, 2, 1019, 1022, 5, 86, 44,
	2, 1020, 1022, 5, 80, 41, 2, 1021, 1018, 3, 2, 2, 2, 1021, 1019, 3, 2,
	2, 2, 1021, 1020, 3, 2, 2, 2, 1022, 79, 3, 2, 2, 2, 1023, 1024, 5, 480,
	241, 2, 1024, 1025, 5, 82, 42, 2, 1025, 81, 3, 2, 2, 2, 1026, 1032, 5,
	84, 43, 2, 1027, 1028, 5, 360, 181, 2, 1028, 1029, 5, 84, 43, 2, 1029,
	1031, 3, 2, 2, 2, 1030, 1027, 3, 2, 2, 2, 1031, 1034, 3, 2, 2, 2, 1032,
	1030, 3, 2, 2, 2, 1032, 1033, 3, 2, 2, 2, 1033, 83, 3, 2, 2, 2, 1034, 1032,
	3, 2, 2, 2, 1035, 1036, 5, 312, 157, 2, 1036, 1037, 5, 508, 255, 2, 1037,
	1038, 5, 312, 157, 2, 1038, 85, 3, 2, 2, 2, 1039, 1040, 5, 348, 175, 2,
	1040, 1041, 5, 312, 157, 2, 1041, 1048, 5, 314, 158, 2, 1042, 1043, 5,
	558, 280, 2, 1043, 1044, 5, 312, 157, 2, 1044, 1045, 5, 314, 158, 2, 1045,
	1047, 3, 2, 2, 2, 1046, 1042, 3, 2, 2, 2, 1047, 1050, 3, 2, 2, 2, 1048,
	1046, 3, 2, 2, 2, 1048, 1049, 3, 2, 2, 2, 1049, 87, 3, 2, 2, 2, 1050, 1048,
	3, 2, 2, 2, 1051, 1052, 5, 358, 180, 2, 1052, 1053, 5, 312, 157, 2, 1053,
	1054, 5, 516, 259, 2, 1054, 1055, 5, 314, 158, 2, 1055, 89, 3, 2, 2, 2,
	1056, 1057, 5, 358, 180, 2, 1057, 1061, 5, 504, 253, 2, 1058, 1059, 5,
	308, 155, 2, 1059, 1060, 7, 16, 2, 2, 1060, 1062, 3, 2, 2, 2, 1061, 1058,
	3, 2, 2, 2, 1061, 1062, 3, 2, 2, 2, 1062, 1063, 3, 2, 2, 2, 1063, 1064,
	5, 310, 156, 2, 1064, 1065, 5, 92, 47, 2, 1065, 91, 3, 2, 2, 2, 1066, 1073,
	5, 104, 53, 2, 1067, 1073, 5, 100, 51, 2, 1068, 1073, 5, 100, 51, 2, 1069,
	1073, 5, 98, 50, 2, 1070, 1073, 5, 96, 49, 2, 1071, 1073, 5, 94, 48, 2,
	1072, 1066, 3, 2, 2, 2, 1072, 1067, 3, 2, 2, 2, 1072, 1068, 3, 2, 2, 2,
	1072, 1069, 3, 2, 2, 2, 1072, 1070, 3, 2, 2, 2, 1072, 1071, 3, 2, 2, 2,
	1073, 93, 3, 2, 2, 2, 1074, 1075, 5, 536, 269, 2, 1075, 1076, 5, 142, 72,
	2, 1076, 95, 3, 2, 2, 2, 1077, 1078, 5, 480, 241, 2, 1078, 1079, 5, 312,
	157, 2, 1079, 1080, 5, 508, 255, 2, 1080, 1081, 5, 312, 157, 2, 1081, 97,
	3, 2, 2, 2, 1082, 1083, 5, 394, 198, 2, 1083, 1084, 5, 380, 191, 2, 1084,
	1085, 5, 498, 250, 2, 1085, 99, 3, 2, 2, 2, 1086, 1087, 5, 394, 198, 2,
	1087, 1088, 5, 102, 52, 2, 1088, 101, 3, 2, 2, 2, 1089, 1095, 5, 312, 157,
	2, 1090, 1091, 5, 558, 280, 2, 1091, 1092, 5, 312, 157, 2, 1092, 1094,
	3, 2, 2, 2, 1093, 1090, 3, 2, 2, 2, 1094, 1097, 3, 2, 2, 2, 1095, 1093,
	3, 2, 2, 2, 1095, 1096, 3, 2, 2, 2, 1096, 103, 3, 2, 2, 2, 1097, 1095,
	3, 2, 2, 2, 1098, 1099, 5, 348, 175, 2, 1099, 1100, 5, 106, 54, 2, 1100,
	105, 3, 2, 2, 2, 1101, 1102, 5, 312, 157, 2, 1102, 1109, 5, 314, 158, 2,
	1103, 1104, 5, 558, 280, 2, 1104, 1105, 5, 312, 157, 2, 1105, 1106, 5,
	314, 158, 2, 1106, 1108, 3, 2, 2, 2, 1107, 1103, 3, 2, 2, 2, 1108, 1111,
	3, 2, 2, 2, 1109, 1107, 3, 2, 2, 2, 1109, 1110, 3, 2, 2, 2, 1110, 107,
	3, 2, 2, 2, 1111, 1109, 3, 2, 2, 2, 1112, 1113, 5, 358, 180, 2, 1113, 1114,
	5, 488, 245, 2, 1114, 1116, 5, 322, 162, 2, 1115, 1117, 5, 110, 56, 2,
	1116, 1115, 3, 2, 2, 2, 1116, 1117, 3, 2, 2, 2, 1117, 109, 3, 2, 2, 2,
	1118, 1119, 5, 536, 269, 2, 1119, 1125, 5, 112, 57, 2, 1120, 1121, 5, 360,
	181, 2, 1121, 1122, 5, 112, 57, 2, 1122, 1124, 3, 2, 2, 2, 1123, 1120,
	3, 2, 2, 2, 1124, 1127, 3, 2, 2, 2, 1125, 1123, 3, 2, 2, 2, 1125, 1126,
	3, 2, 2, 2, 1126, 111, 3, 2, 2, 2, 1127, 1125, 3, 2, 2, 2, 1128, 1129,
	5, 476, 239, 2, 1129, 1130, 7, 173, 2, 2, 1130, 1131, 5, 302, 152, 2, 1131,
	1145, 3, 2, 2, 2, 1132, 1133, 5, 452, 227, 2, 1133, 1134, 7, 173, 2, 2,
	1134, 1135, 5, 304, 153, 2, 1135, 1145, 3, 2, 2, 2, 1136, 1137, 5, 502,
	252, 2, 1137, 1138, 7, 173, 2, 2, 1138, 1139, 5, 304, 153, 2, 1139, 1145,
	3, 2, 2, 2, 1140, 1141, 5, 470, 236, 2, 1141, 1142, 7, 173, 2, 2, 1142,
	1143, 5, 150, 76, 2, 1143, 1145, 3, 2, 2, 2, 1144, 1128, 3, 2, 2, 2, 1144,
	1132, 3, 2, 2, 2, 1144, 1136, 3, 2, 2, 2, 1144, 1140, 3, 2, 2, 2, 1145,
	113, 3, 2, 2, 2, 1146, 1147, 5, 358, 180, 2, 1147, 1148, 5, 454, 228, 2,
	1148, 1152, 5, 532, 267, 2, 1149, 1150, 5, 308, 155, 2, 1150, 1151, 7,
	16, 2, 2, 1151, 1153, 3, 2, 2, 2, 1152, 1149, 3, 2, 2, 2, 1152, 1153, 3,
	2, 2, 2, 1153, 1154, 3, 2, 2, 2, 1154, 1158, 5, 328, 165, 2, 1155, 1156,
	5, 536, 269, 2, 1156, 1157, 5, 142, 72, 2, 1157, 1159, 3, 2, 2, 2, 1158,
	1155, 3, 2, 2, 2, 1158, 1159, 3, 2, 2, 2, 1159, 115, 3, 2, 2, 2, 1160,
	1161, 5, 394, 198, 2, 1161, 1163, 5, 524, 263, 2, 1162, 1164, 5, 250, 126,
	2, 1163, 1162, 3, 2, 2, 2, 1163, 1164, 3, 2, 2, 2, 1164, 1165, 3, 2, 2,
	2, 1165, 1166, 5, 338, 170, 2, 1166, 117, 3, 2, 2, 2, 1167, 1168, 5, 394,
	198, 2, 1168, 1170, 5, 516, 259, 2, 1169, 1171, 5, 250, 126, 2, 1170, 1169,
	3, 2, 2, 2, 1170, 1171, 3, 2, 2, 2, 1171, 1175, 3, 2, 2, 2, 1172, 1173,
	5, 308, 155, 2, 1173, 1174, 7, 16, 2, 2, 1174, 1176, 3, 2, 2, 2, 1175,
	1172, 3, 2, 2, 2, 1175, 1176, 3, 2, 2, 2, 1176, 1177, 3, 2, 2, 2, 1177,
	1178, 5, 330, 166, 2, 1178, 119, 3, 2, 2, 2, 1179, 1180, 5, 394, 198, 2,
	1180, 1181, 5, 454, 228, 2, 1181, 1183, 5, 532, 267, 2, 1182, 1184, 5,
	250, 126, 2, 1183, 1182, 3, 2, 2, 2, 1183, 1184, 3, 2, 2, 2, 1184, 1188,
	3, 2, 2, 2, 1185, 1186, 5, 308, 155, 2, 1186, 1187, 7, 16, 2, 2, 1187,
	1189, 3, 2, 2, 2, 1188, 1185, 3, 2, 2, 2, 1188, 1189, 3, 2, 2, 2, 1189,
	1190, 3, 2, 2, 2, 1190, 1191, 5, 328, 165, 2, 1191, 121, 3, 2, 2, 2, 1192,
	1193, 5, 394, 198, 2, 1193, 1195, 5, 350, 176, 2, 1194, 1196, 5, 250, 126,
	2, 1195, 1194, 3, 2, 2, 2, 1195, 1196, 3, 2, 2, 2, 1196, 1200, 3, 2, 2,
	2, 1197, 1198, 5, 308, 155, 2, 1198, 1199, 7, 16, 2, 2, 1199, 1201, 3,
	2, 2, 2, 1200, 1197, 3, 2, 2, 2, 1200, 1201, 3, 2, 2, 2, 1201, 1202, 3,
	2, 2, 2, 1202, 1203, 5, 332, 167, 2, 1203, 123, 3, 2, 2, 2, 1204, 1205,
	5, 394, 198, 2, 1205, 1207, 5, 412, 207, 2, 1206, 1208, 5, 250, 126, 2,
	1207, 1206, 3, 2, 2, 2, 1207, 1208, 3, 2, 2, 2, 1208, 1212, 3, 2, 2, 2,
	1209, 1210, 5, 308, 155, 2, 1210, 1211, 7, 16, 2, 2, 1211, 1213, 3, 2,
	2, 2, 1212, 1209, 3, 2, 2, 2, 1212, 1213, 3, 2, 2, 2, 1213, 1214, 3, 2,
	2, 2, 1214, 1215, 5, 334, 168, 2, 1215, 125, 3, 2, 2, 2, 1216, 1217, 5,
	394, 198, 2, 1217, 1219, 5, 510, 256, 2, 1218, 1220, 5, 250, 126, 2, 1219,
	1218, 3, 2, 2, 2, 1219, 1220, 3, 2, 2, 2, 1220, 1221, 3, 2, 2, 2, 1221,
	1222, 5, 324, 163, 2, 1222, 1226, 5, 468, 235, 2, 1223, 1224, 5, 308, 155,
	2, 1224, 1225, 7, 16, 2, 2, 1225, 1227, 3, 2, 2, 2, 1226, 1223, 3, 2, 2,
	2, 1226, 1227, 3, 2, 2, 2, 1227, 1228, 3, 2, 2, 2, 1228, 1229, 5, 310,
	156, 2, 1229, 127, 3, 2, 2, 2, 1230, 1231, 5, 394, 198, 2, 1231, 1233,
	5, 488, 245, 2, 1232, 1234, 5, 250, 126, 2, 1233, 1232, 3, 2, 2, 2, 1233,
	1234, 3, 2, 2, 2, 1234, 1235, 3, 2, 2, 2, 1235, 1236, 5, 322, 162, 2, 1236,
	129, 3, 2, 2, 2, 1237, 1238, 5, 394, 198, 2, 1238, 1240, 5, 504, 253, 2,
	1239, 1241, 5, 250, 126, 2, 1240, 1239, 3, 2, 2, 2, 1240, 1241, 3, 2, 2,
	2, 1241, 1245, 3, 2, 2, 2, 1242, 1243, 5, 308, 155, 2, 1243, 1244, 7, 16,
	2, 2, 1244, 1246, 3, 2, 2, 2, 1245, 1242, 3, 2, 2, 2, 1245, 1246, 3, 2,
	2, 2, 1246, 1247, 3, 2, 2, 2, 1247, 1248, 5, 310, 156, 2, 1248, 131, 3,
	2, 2, 2, 1249, 1250, 5, 394, 198, 2, 1250, 1252, 5, 440, 221, 2, 1251,
	1253, 5, 250, 126, 2, 1252, 1251, 3, 2, 2, 2, 1252, 1253, 3, 2, 2, 2, 1253,
	1254, 3, 2, 2, 2, 1254, 1255, 5, 308, 155, 2, 1255, 133, 3, 2, 2, 2, 1256,
	1257, 5, 394, 198, 2, 1257, 1259, 5, 422, 212, 2, 1258, 1260, 5, 250, 126,
	2, 1259, 1258, 3, 2, 2, 2, 1259, 1260, 3, 2, 2, 2, 1260, 1264, 3, 2, 2,
	2, 1261, 1262, 5, 308, 155, 2, 1262, 1263, 7, 16, 2, 2, 1263, 1265, 3,
	2, 2, 2, 1264, 1261, 3, 2, 2, 2, 1264, 1265, 3, 2, 2, 2, 1265, 1266, 3,
	2, 2, 2, 1266, 1267, 5, 202, 102, 2, 1267, 135, 3, 2, 2, 2, 1268, 1269,
	5, 384, 193, 2, 1269, 1271, 5, 504, 253, 2, 1270, 1272, 5, 248, 125, 2,
	1271, 1270, 3, 2, 2, 2, 1271, 1272, 3, 2, 2, 2, 1272, 1276, 3, 2, 2, 2,
	1273, 1274, 5, 308, 155, 2, 1274, 1275, 7, 16, 2, 2, 1275, 1277, 3, 2,
	2, 2, 1276, 1273, 3, 2, 2, 2, 1276, 1277, 3, 2, 2, 2, 1277, 1278, 3, 2,
	2, 2, 1278, 1279, 5, 310, 156, 2, 1279, 1280, 5, 542, 272, 2, 1280, 1281,
	5, 158, 80, 2, 1281, 1283, 5, 544, 273, 2, 1282, 1284, 5, 138, 70, 2, 1283,
	1282, 3, 2, 2, 2, 1283, 1284, 3, 2, 2, 2, 1284, 137, 3, 2, 2, 2, 1285,
	1287, 5, 536, 269, 2, 1286, 1288, 5, 142, 72, 2, 1287, 1286, 3, 2, 2, 2,
	1287, 1288, 3, 2, 2, 2, 1288, 1290, 3, 2, 2, 2, 1289, 1291, 5, 140, 71,
	2, 1290, 1289, 3, 2, 2, 2, 1290, 1291, 3, 2, 2, 2, 1291, 139, 3, 2, 2,
	2, 1292, 1293, 5, 378, 190, 2, 1293, 1294, 5, 474, 238, 2, 1294, 1295,
	5, 374, 188, 2, 1295, 1296, 5, 542, 272, 2, 1296, 1298, 5, 312, 157, 2,
	1297, 1299, 5, 320, 161, 2, 1298, 1297, 3, 2, 2, 2, 1298, 1299, 3, 2, 2,
	2, 1299, 1300, 3, 2, 2, 2, 1300, 1301, 5, 544, 273, 2, 1301, 141, 3, 2,
	2, 2, 1302, 1308, 5, 144, 73, 2, 1303, 1304, 5, 360, 181, 2, 1304, 1305,
	5, 144, 73, 2, 1305, 1307, 3, 2, 2, 2, 1306, 1303, 3, 2, 2, 2, 1307, 1310,
	3, 2, 2, 2, 1308, 1306, 3, 2, 2, 2, 1308, 1309, 3, 2, 2, 2, 1309, 143,
	3, 2, 2, 2, 1310, 1308, 3, 2, 2, 2, 1311, 1312, 5, 146, 74, 2, 1312, 1313,
	7, 173, 2, 2, 1313, 1314, 5, 148, 75, 2, 1314, 1320, 3, 2, 2, 2, 1315,
	1316, 5, 146, 74, 2, 1316, 1317, 7, 173, 2, 2, 1317, 1318, 5, 150, 76,
	2, 1318, 1320, 3, 2, 2, 2, 1319, 1311, 3, 2, 2, 2, 1319, 1315, 3, 2, 2,
	2, 1320, 145, 3, 2, 2, 2, 1321, 1322, 7, 171, 2, 2, 1322, 147, 3, 2, 2,
	2, 1323, 1326, 5, 302, 152, 2, 1324, 1326, 5, 300, 151, 2, 1325, 1323,
	3, 2, 2, 2, 1325, 1324, 3, 2, 2, 2, 1326, 149, 3, 2, 2, 2, 1327, 1328,
	5, 546, 274, 2, 1328, 1334, 5, 152, 77, 2, 1329, 1330, 5, 558, 280, 2,
	1330, 1331, 5, 152, 77, 2, 1331, 1333, 3, 2, 2, 2, 1332, 1329, 3, 2, 2,
	2, 1333, 1336, 3, 2, 2, 2, 1334, 1332, 3, 2, 2, 2, 1334, 1335, 3, 2, 2,
	2, 1335, 1337, 3, 2, 2, 2, 1336, 1334, 3, 2, 2, 2, 1337, 1338, 5, 548,
	275, 2, 1338, 151, 3, 2, 2, 2, 1339, 1340, 5, 154, 78, 2, 1340, 1341, 7,
	11, 2, 2, 1341, 1342, 5, 156, 79, 2, 1342, 153, 3, 2, 2, 2, 1343, 1344,
	5, 302, 152, 2, 1344, 155, 3, 2, 2, 2, 1345, 1348, 5, 302, 152, 2, 1346,
	1348, 5, 300, 151, 2, 1347, 1345, 3, 2, 2, 2, 1347, 1346, 3, 2, 2, 2, 1348,
	157, 3, 2, 2, 2, 1349, 1355, 5, 160, 81, 2, 1350, 1351, 5, 558, 280, 2,
	1351, 1352, 5, 160, 81, 2, 1352, 1354, 3, 2, 2, 2, 1353, 1350, 3, 2, 2,
	2, 1354, 1357, 3, 2, 2, 2, 1355, 1353, 3, 2, 2, 2, 1355, 1356, 3, 2, 2,
	2, 1356, 1361, 3, 2, 2, 2, 1357, 1355, 3, 2, 2, 2, 1358, 1359, 5, 558,
	280, 2, 1359, 1360, 5, 164, 83, 2, 1360, 1362, 3, 2, 2, 2, 1361, 1358,
	3, 2, 2, 2, 1361, 1362, 3, 2, 2, 2, 1362, 159, 3, 2, 2, 2, 1363, 1364,
	5, 312, 157, 2, 1364, 1366, 5, 314, 158, 2, 1365, 1367, 5, 162, 82, 2,
	1366, 1365, 3, 2, 2, 2, 1366, 1367, 3, 2, 2, 2, 1367, 161, 3, 2, 2, 2,
	1368, 1369, 5, 478, 240, 2, 1369, 1370, 5, 436, 219, 2, 1370, 163, 3, 2,
	2, 2, 1371, 1372, 5, 478, 240, 2, 1372, 1373, 5, 436, 219, 2, 1373, 1374,
	5, 542, 272, 2, 1374, 1375, 5, 166, 84, 2, 1375, 1376, 5, 544, 273, 2,
	1376, 165, 3, 2, 2, 2, 1377, 1381, 5, 168, 85, 2, 1378, 1381, 5, 170, 86,
	2, 1379, 1381, 5, 172, 87, 2, 1380, 1377, 3, 2, 2, 2, 1380, 1378, 3, 2,
	2, 2, 1380, 1379, 3, 2, 2, 2, 1381, 167, 3, 2, 2, 2, 1382, 1383, 5, 312,
	157, 2, 1383, 169, 3, 2, 2, 2, 1384, 1385, 5, 178, 90, 2, 1385, 1386, 5,
	558, 280, 2, 1386, 1387, 5, 176, 89, 2, 1387, 171, 3, 2, 2, 2, 1388, 1389,
	5, 542, 272, 2, 1389, 1390, 5, 174, 88, 2, 1390, 1391, 5, 544, 273, 2,
	1391, 1392, 5, 558, 280, 2, 1392, 1393, 5, 176, 89, 2, 1393, 173, 3, 2,
	2, 2, 1394, 1400, 5, 178, 90, 2, 1395, 1396, 5, 558, 280, 2, 1396, 1397,
	5, 178, 90, 2, 1397, 1399, 3, 2, 2, 2, 1398, 1395, 3, 2, 2, 2, 1399, 1402,
	3, 2, 2, 2, 1400, 1398, 3, 2, 2, 2, 1400, 1401, 3, 2, 2, 2, 1401, 175,
	3, 2, 2, 2, 1402, 1400, 3, 2, 2, 2, 1403, 1409, 5, 180, 91, 2, 1404, 1405,
	5, 558, 280, 2, 1405, 1406, 5, 180, 91, 2, 1406, 1408, 3, 2, 2, 2, 1407,
	1404, 3, 2, 2, 2, 1408, 1411, 3, 2, 2, 2, 1409, 1407, 3, 2, 2, 2, 1409,
	1410, 3, 2, 2, 2, 1410, 177, 3, 2, 2, 2, 1411, 1409, 3, 2, 2, 2, 1412,
	1413, 5, 312, 157, 2, 1413, 179, 3, 2, 2, 2, 1414, 1415, 5, 312, 157, 2,
	1415, 181, 3, 2, 2, 2, 1416, 1417, 5, 362, 182, 2, 1417, 1418, 5, 370,
	186, 2, 1418, 183, 3, 2, 2, 2, 1419, 1421, 5, 372, 187, 2, 1420, 1422,
	5, 186, 94, 2, 1421, 1420, 3, 2, 2, 2, 1421, 1422, 3, 2, 2, 2, 1422, 1423,
	3, 2, 2, 2, 1423, 1425, 5, 370, 186, 2, 1424, 1426, 5, 246, 124, 2, 1425,
	1424, 3, 2, 2, 2, 1425, 1426, 3, 2, 2, 2, 1426, 185, 3, 2, 2, 2, 1427,
	1430, 5, 450, 226, 2, 1428, 1430, 5, 518, 260, 2, 1429, 1427, 3, 2, 2,
	2, 1429, 1428, 3, 2, 2, 2, 1430, 187, 3, 2, 2, 2, 1431, 1432, 5, 358, 180,
	2, 1432, 1433, 5, 440, 221, 2, 1433, 1434, 5, 308, 155, 2, 1434, 1435,
	5, 536, 269, 2, 1435, 1436, 5, 484, 243, 2, 1436, 1437, 7, 173, 2, 2, 1437,
	1438, 5, 546, 274, 2, 1438, 1439, 5, 190, 96, 2, 1439, 1443, 5, 548, 275,
	2, 1440, 1441, 5, 360, 181, 2, 1441, 1442, 5, 194, 98, 2, 1442, 1444, 3,
	2, 2, 2, 1443, 1440, 3, 2, 2, 2, 1443, 1444, 3, 2, 2, 2, 1444, 189, 3,
	2, 2, 2, 1445, 1451, 5, 192, 97, 2, 1446, 1447, 5, 558, 280, 2, 1447, 1448,
	5, 192, 97, 2, 1448, 1450, 3, 2, 2, 2, 1449, 1446, 3, 2, 2, 2, 1450, 1453,
	3, 2, 2, 2, 1451, 1449, 3, 2, 2, 2, 1451, 1452, 3, 2, 2, 2, 1452, 191,
	3, 2, 2, 2, 1453, 1451, 3, 2, 2, 2, 1454, 1455, 7, 166, 2, 2, 1455, 1456,
	7, 11, 2, 2, 1456, 1461, 7, 166, 2, 2, 1457, 1458, 7, 166, 2, 2, 1458,
	1459, 7, 11, 2, 2, 1459, 1461, 7, 167, 2, 2, 1460, 1454, 3, 2, 2, 2, 1460,
	1457, 3, 2, 2, 2, 1461, 193, 3, 2, 2, 2, 1462, 1463, 5, 396, 199, 2, 1463,
	1464, 7, 173, 2, 2, 1464, 1465, 5, 304, 153, 2, 1465, 195, 3, 2, 2, 2,
	1466, 1467, 5, 522, 262, 2, 1467, 1468, 5, 308, 155, 2, 1468, 197, 3, 2,
	2, 2, 1469, 1471, 5, 512, 257, 2, 1470, 1472, 5, 504, 253, 2, 1471, 1470,
	3, 2, 2, 2, 1471, 1472, 3, 2, 2, 2, 1472, 1476, 3, 2, 2, 2, 1473, 1474,
	5, 308, 155, 2, 1474, 1475, 7, 16, 2, 2, 1475, 1477, 3, 2, 2, 2, 1476,
	1473, 3, 2, 2, 2, 1476, 1477, 3, 2, 2, 2, 1477, 1478, 3, 2, 2, 2, 1478,
	1479, 5, 310, 156, 2, 1479, 199, 3, 2, 2, 2, 1480, 1481, 5, 384, 193, 2,
	1481, 1483, 5, 422, 212, 2, 1482, 1484, 5, 248, 125, 2, 1483, 1482, 3,
	2, 2, 2, 1483, 1484, 3, 2, 2, 2, 1484, 1486, 3, 2, 2, 2, 1485, 1487, 5,
	202, 102, 2, 1486, 1485, 3, 2, 2, 2, 1486, 1487, 3, 2, 2, 2, 1487, 1488,
	3, 2, 2, 2, 1488, 1492, 5, 468, 235, 2, 1489, 1490, 5, 308, 155, 2, 1490,
	1491, 7, 16, 2, 2, 1491, 1493, 3, 2, 2, 2, 1492, 1489, 3, 2, 2, 2, 1492,
	1493, 3, 2, 2, 2, 1493, 1494, 3, 2, 2, 2, 1494, 1495, 5, 310, 156, 2, 1495,
	1496, 5, 542, 272, 2, 1496, 1497, 5, 204, 103, 2, 1497, 1498, 5, 544, 273,
	2, 1498, 201, 3, 2, 2, 2, 1499, 1502, 7, 171, 2, 2, 1500, 1502, 5, 302,
	152, 2, 1501, 1499, 3, 2, 2, 2, 1501, 1500, 3, 2, 2, 2, 1502, 203, 3, 2,
	2, 2, 1503, 1508, 5, 312, 157, 2, 1504, 1508, 5, 206, 104, 2, 1505, 1508,
	5, 208, 105, 2, 1506, 1508, 5, 210, 106, 2, 1507, 1503, 3, 2, 2, 2, 1507,
	1504, 3, 2, 2, 2, 1507, 1505, 3, 2, 2, 2, 1507, 1506, 3, 2, 2, 2, 1508,
	205, 3, 2, 2, 2, 1509, 1510, 5, 438, 220, 2, 1510, 1511, 5, 542, 272, 2,
	1511, 1512, 7, 171, 2, 2, 1512, 1513, 5, 544, 273, 2, 1513, 207, 3, 2,
	2, 2, 1514, 1515, 5, 398, 200, 2, 1515, 1516, 5, 542, 272, 2, 1516, 1517,
	7, 171, 2, 2, 1517, 1518, 5, 544, 273, 2, 1518, 209, 3, 2, 2, 2, 1519,
	1520, 5, 410, 206, 2, 1520, 1521, 5, 542, 272, 2, 1521, 1522, 7, 171, 2,
	2, 1522, 1523, 5, 544, 273, 2, 1523, 211, 3, 2, 2, 2, 1524, 1526, 5, 184,
	93, 2, 1525, 1524, 3, 2, 2, 2, 1525, 1526, 3, 2, 2, 2, 1526, 1527, 3, 2,
	2, 2, 1527, 1529, 5, 386, 194, 2, 1528, 1530, 5, 214, 108, 2, 1529, 1528,
	3, 2, 2, 2, 1529, 1530, 3, 2, 2, 2, 1530, 1531, 3, 2, 2, 2, 1531, 1533,
	5, 268, 135, 2, 1532, 1534, 5, 246, 124, 2, 1533, 1532, 3, 2, 2, 2, 1533,
	1534, 3, 2, 2, 2, 1534, 1535, 3, 2, 2, 2, 1535, 1538, 5, 276, 139, 2, 1536,
	1539, 5, 250, 126, 2, 1537, 1539, 5, 220, 111, 2, 1538, 1536, 3, 2, 2,
	2, 1538, 1537, 3, 2, 2, 2, 1538, 1539, 3, 2, 2, 2, 1539, 213, 3, 2, 2,
	2, 1540, 1546, 5, 216, 109, 2, 1541, 1542, 5, 558, 280, 2, 1542, 1543,
	5, 216, 109, 2, 1543, 1545, 3, 2, 2, 2, 1544, 1541, 3, 2, 2, 2, 1545, 1548,
	3, 2, 2, 2, 1546, 1544, 3, 2, 2, 2, 1546, 1547, 3, 2, 2, 2, 1547, 215,
	3, 2, 2, 2, 1548, 1546, 3, 2, 2, 2, 1549, 1559, 7, 171, 2, 2, 1550, 1551,
	7, 171, 2, 2, 1551, 1554, 7, 7, 2, 2, 1552, 1555, 5, 302, 152, 2, 1553,
	1555, 5, 298, 150, 2, 1554, 1552, 3, 2, 2, 2, 1554, 1553, 3, 2, 2, 2, 1555,
	1556, 3, 2, 2, 2, 1556, 1557, 7, 8, 2, 2, 1557, 1559, 3, 2, 2, 2, 1558,
	1549, 3, 2, 2, 2, 1558, 1550, 3, 2, 2, 2, 1559, 217, 3, 2, 2, 2, 1560,
	1562, 5, 184, 93, 2, 1561, 1560, 3, 2, 2, 2, 1561, 1562, 3, 2, 2, 2, 1562,
	1563, 3, 2, 2, 2, 1563, 1567, 5, 520, 261, 2, 1564, 1565, 5, 308, 155,
	2, 1565, 1566, 7, 16, 2, 2, 1566, 1568, 3, 2, 2, 2, 1567, 1564, 3, 2, 2,
	2, 1567, 1568, 3, 2, 2, 2, 1568, 1569, 3, 2, 2, 2, 1569, 1571, 5, 310,
	156, 2, 1570, 1572, 5, 240, 121, 2, 1571, 1570, 3, 2, 2, 2, 1571, 1572,
	3, 2, 2, 2, 1572, 1573, 3, 2, 2, 2, 1573, 1574, 5, 494, 248, 2, 1574, 1575,
	5, 226, 114, 2, 1575, 1578, 5, 276, 139, 2, 1576, 1579, 5, 250, 126, 2,
	1577, 1579, 5, 220, 111, 2, 1578, 1576, 3, 2, 2, 2, 1578, 1577, 3, 2, 2,
	2, 1578, 1579, 3, 2, 2, 2, 1579, 219, 3, 2, 2, 2, 1580, 1581, 5, 418, 210,
	2, 1581, 1582, 5, 222, 112, 2, 1582, 221, 3, 2, 2, 2, 1583, 1589, 5, 224,
	113, 2, 1584, 1585, 5, 360, 181, 2, 1585, 1586, 5, 224, 113, 2, 1586, 1588,
	3, 2, 2, 2, 1587, 1584, 3, 2, 2, 2, 1588, 1591, 3, 2, 2, 2, 1589, 1587,
	3, 2, 2, 2, 1589, 1590, 3, 2, 2, 2, 1590, 223, 3, 2, 2, 2, 1591, 1589,
	3, 2, 2, 2, 1592, 1593, 7, 171, 2, 2, 1593, 1594, 7, 173, 2, 2, 1594, 1595,
	5, 296, 149, 2, 1595, 225, 3, 2, 2, 2, 1596, 1602, 5, 228, 115, 2, 1597,
	1598, 5, 558, 280, 2, 1598, 1599, 5, 228, 115, 2, 1599, 1601, 3, 2, 2,
	2, 1600, 1597, 3, 2, 2, 2, 1601, 1604, 3, 2, 2, 2, 1602, 1600, 3, 2, 2,
	2, 1602, 1603, 3, 2, 2, 2, 1603, 227, 3, 2, 2, 2, 1604, 1602, 3, 2, 2,
	2, 1605, 1606, 7, 171, 2, 2, 1606, 1611, 7, 173, 2, 2, 1607, 1612, 5, 296,
	149, 2, 1608, 1612, 5, 232, 117, 2, 1609, 1612, 5, 230, 116, 2, 1610, 1612,
	5, 234, 118, 2, 1611, 1607, 3, 2, 2, 2, 1611, 1608, 3, 2, 2, 2, 1611, 1609,
	3, 2, 2, 2, 1611, 1610, 3, 2, 2, 2, 1612, 1659, 3, 2, 2, 2, 1613, 1614,
	7, 171, 2, 2, 1614, 1615, 7, 173, 2, 2, 1615, 1616, 7, 171, 2, 2, 1616,
	1617, 9, 2, 2, 2, 1617, 1659, 5, 298, 150, 2, 1618, 1619, 7, 171, 2, 2,
	1619, 1620, 7, 173, 2, 2, 1620, 1621, 7, 171, 2, 2, 1621, 1622, 9, 2, 2,
	2, 1622, 1659, 5, 230, 116, 2, 1623, 1624, 7, 171, 2, 2, 1624, 1625, 7,
	173, 2, 2, 1625, 1626, 5, 230, 116, 2, 1626, 1627, 9, 2, 2, 2, 1627, 1628,
	7, 171, 2, 2, 1628, 1659, 3, 2, 2, 2, 1629, 1630, 7, 171, 2, 2, 1630, 1631,
	7, 173, 2, 2, 1631, 1632, 7, 171, 2, 2, 1632, 1633, 9, 2, 2, 2, 1633, 1659,
	5, 232, 117, 2, 1634, 1635, 7, 171, 2, 2, 1635, 1636, 7, 173, 2, 2, 1636,
	1637, 5, 232, 117, 2, 1637, 1638, 9, 2, 2, 2, 1638, 1639, 7, 171, 2, 2,
	1639, 1659, 3, 2, 2, 2, 1640, 1641, 7, 171, 2, 2, 1641, 1642, 7, 173, 2,
	2, 1642, 1643, 7, 171, 2, 2, 1643, 1644, 9, 2, 2, 2, 1644, 1659, 5, 234,
	118, 2, 1645, 1646, 7, 171, 2, 2, 1646, 1647, 7, 173, 2, 2, 1647, 1648,
	5, 234, 118, 2, 1648, 1649, 9, 2, 2, 2, 1649, 1650, 7, 171, 2, 2, 1650,
	1659, 3, 2, 2, 2, 1651, 1652, 7, 171, 2, 2, 1652, 1653, 5, 554, 278, 2,
	1653, 1654, 5, 298, 150, 2, 1654, 1655, 5, 556, 279, 2, 1655, 1656, 7,
	173, 2, 2, 1656, 1657, 5, 296, 149, 2, 1657, 1659, 3, 2, 2, 2, 1658, 1605,
	3, 2, 2, 2, 1658, 1613, 3, 2, 2, 2, 1658, 1618, 3, 2, 2, 2, 1658, 1623,
	3, 2, 2, 2, 1658, 1629, 3, 2, 2, 2, 1658, 1634, 3, 2, 2, 2, 1658, 1640,
	3, 2, 2, 2, 1658, 1645, 3, 2, 2, 2, 1658, 1651, 3, 2, 2, 2, 1659, 229,
	3, 2, 2, 2, 1660, 1670, 5, 546, 274, 2, 1661, 1667, 5, 296, 149, 2, 1662,
	1663, 5, 558, 280, 2, 1663, 1664, 5, 296, 149, 2, 1664, 1666, 3, 2, 2,
	2, 1665, 1662, 3, 2, 2, 2, 1666, 1669, 3, 2, 2, 2, 1667, 1665, 3, 2, 2,
	2, 1667, 1668, 3, 2, 2, 2, 1668, 1671, 3, 2, 2, 2, 1669, 1667, 3, 2, 2,
	2, 1670, 1661, 3, 2, 2, 2, 1670, 1671, 3, 2, 2, 2, 1671, 1672, 3, 2, 2,
	2, 1672, 1673, 5, 548, 275, 2, 1673, 231, 3, 2, 2, 2, 1674, 1675, 5, 546,
	274, 2, 1675, 1676, 5, 296, 149, 2, 1676, 1677, 5, 560, 281, 2, 1677, 1678,
	5, 296, 149, 2, 1678, 1686, 3, 2, 2, 2, 1679, 1680, 5, 558, 280, 2, 1680,
	1681, 5, 296, 149, 2, 1681, 1682, 5, 560, 281, 2, 1682, 1683, 5, 296, 149,
	2, 1683, 1685, 3, 2, 2, 2, 1684, 1679, 3, 2, 2, 2, 1685, 1688, 3, 2, 2,
	2, 1686, 1684, 3, 2, 2, 2, 1686, 1687, 3, 2, 2, 2, 1687, 1689, 3, 2, 2,
	2, 1688, 1686, 3, 2, 2, 2, 1689, 1690, 5, 548, 275, 2, 1690, 233, 3, 2,
	2, 2, 1691, 1692, 5, 554, 278, 2, 1692, 1698, 5, 296, 149, 2, 1693, 1694,
	5, 558, 280, 2, 1694, 1695, 5, 296, 149, 2, 1695, 1697, 3, 2, 2, 2, 1696,
	1693, 3, 2, 2, 2, 1697, 1700, 3, 2, 2, 2, 1698, 1696, 3, 2, 2, 2, 1698,
	1699, 3, 2, 2, 2, 1699, 1701, 3, 2, 2, 2, 1700, 1698, 3, 2, 2, 2, 1701,
	1702, 5, 556, 279, 2, 1702, 235, 3, 2, 2, 2, 1703, 1732, 5, 542, 272, 2,
	1704, 1721, 5, 296, 149, 2, 1705, 1706, 5, 558, 280, 2, 1706, 1707, 5,
	296, 149, 2, 1707, 1709, 3, 2, 2, 2, 1708, 1705, 3, 2, 2, 2, 1709, 1712,
	3, 2, 2, 2, 1710, 1708, 3, 2, 2, 2, 1710, 1711, 3, 2, 2, 2, 1711, 1722,
	3, 2, 2, 2, 1712, 1710, 3, 2, 2, 2, 1713, 1714, 5, 558, 280, 2, 1714, 1715,
	5, 236, 119, 2, 1715, 1717, 3, 2, 2, 2, 1716, 1713, 3, 2, 2, 2, 1717, 1720,
	3, 2, 2, 2, 1718, 1716, 3, 2, 2, 2, 1718, 1719, 3, 2, 2, 2, 1719, 1722,
	3, 2, 2, 2, 1720, 1718, 3, 2, 2, 2, 1721, 1710, 3, 2, 2, 2, 1721, 1718,
	3, 2, 2, 2, 1722, 1733, 3, 2, 2, 2, 1723, 1729, 5, 236, 119, 2, 1724, 1725,
	5, 558, 280, 2, 1725, 1726, 5, 236, 119, 2, 1726, 1728, 3, 2, 2, 2, 1727,
	1724, 3, 2, 2, 2, 1728, 1731, 3, 2, 2, 2, 1729, 1727, 3, 2, 2, 2, 1729,
	1730, 3, 2, 2, 2, 1730, 1733, 3, 2, 2, 2, 1731, 1729, 3, 2, 2, 2, 1732,
	1704, 3, 2, 2, 2, 1732, 1723, 3, 2, 2, 2, 1733, 1734, 3, 2, 2, 2, 1734,
	1735, 5, 544, 273, 2, 1735, 237, 3, 2, 2, 2, 1736, 1738, 5, 184, 93, 2,
	1737, 1736, 3, 2, 2, 2, 1737, 1738, 3, 2, 2, 2, 1738, 1739, 3, 2, 2, 2,
	1739, 1740, 5, 428, 215, 2, 1740, 1744, 5, 430, 216, 2, 1741, 1742, 5,
	308, 155, 2, 1742, 1743, 7, 16, 2, 2, 1743, 1745, 3, 2, 2, 2, 1744, 1741,
	3, 2, 2, 2, 1744, 1745, 3, 2, 2, 2, 1745, 1746, 3, 2, 2, 2, 1746, 1748,
	5, 310, 156, 2, 1747, 1749, 5, 254, 128, 2, 1748, 1747, 3, 2, 2, 2, 1748,
	1749, 3, 2, 2, 2, 1749, 1750, 3, 2, 2, 2, 1750, 1752, 5, 252, 127, 2, 1751,
	1753, 5, 248, 125, 2, 1752, 1751, 3, 2, 2, 2, 1752, 1753, 3, 2, 2, 2, 1753,
	1755, 3, 2, 2, 2, 1754, 1756, 5, 240, 121, 2, 1755, 1754, 3, 2, 2, 2, 1755,
	1756, 3, 2, 2, 2, 1756, 239, 3, 2, 2, 2, 1757, 1758, 5, 528, 265, 2, 1758,
	1759, 5, 244, 123, 2, 1759, 1774, 3, 2, 2, 2, 1760, 1761, 5, 528, 265,
	2, 1761, 1762, 5, 244, 123, 2, 1762, 1763, 5, 360, 181, 2, 1763, 1764,
	5, 242, 122, 2, 1764, 1774, 3, 2, 2, 2, 1765, 1766, 5, 528, 265, 2, 1766,
	1767, 5, 242, 122, 2, 1767, 1774, 3, 2, 2, 2, 1768, 1769, 5, 528, 265,
	2, 1769, 1770, 5, 242, 122, 2, 1770, 1771, 5, 360, 181, 2, 1771, 1772,
	5, 244, 123, 2, 1772, 1774, 3, 2, 2, 2, 1773, 1757, 3, 2, 2, 2, 1773, 1760,
	3, 2, 2, 2, 1773, 1765, 3, 2, 2, 2, 1773, 1768, 3, 2, 2, 2, 1774, 241,
	3, 2, 2, 2, 1775, 1776, 5, 506, 254, 2, 1776, 1777, 5, 298, 150, 2, 1777,
	243, 3, 2, 2, 2, 1778, 1779, 5, 514, 258, 2, 1779, 1780, 5, 298, 150, 2,
	1780, 245, 3, 2, 2, 2, 1781, 1782, 5, 528, 265, 2, 1782, 1783, 5, 242,
	122, 2, 1783, 247, 3, 2, 2, 2, 1784, 1785, 5, 418, 210, 2, 1785, 1786,
	5, 462, 232, 2, 1786, 1787, 5, 402, 202, 2, 1787, 249, 3, 2, 2, 2, 1788,
	1789, 5, 418, 210, 2, 1789, 1790, 5, 402, 202, 2, 1790, 251, 3, 2, 2, 2,
	1791, 1792, 5, 530, 266, 2, 1792, 1793, 7, 3, 2, 2, 1793, 1794, 5, 258,
	130, 2, 1794, 1795, 7, 4, 2, 2, 1795, 1800, 3, 2, 2, 2, 1796, 1797, 5,
	434, 218, 2, 1797, 1798, 5, 296, 149, 2, 1798, 1800, 3, 2, 2, 2, 1799,
	1791, 3, 2, 2, 2, 1799, 1796, 3, 2, 2, 2, 1800, 253, 3, 2, 2, 2, 1801,
	1802, 7, 3, 2, 2, 1802, 1803, 5, 256, 129, 2, 1803, 1804, 7, 4, 2, 2, 1804,
	255, 3, 2, 2, 2, 1805, 1811, 5, 312, 157, 2, 1806, 1807, 5, 558, 280, 2,
	1807, 1808, 5, 312, 157, 2, 1808, 1810, 3, 2, 2, 2, 1809, 1806, 3, 2, 2,
	2, 1810, 1813, 3, 2, 2, 2, 1811, 1809, 3, 2, 2, 2, 1811, 1812, 3, 2, 2,
	2, 1812, 257, 3, 2, 2, 2, 1813, 1811, 3, 2, 2, 2, 1814, 1820, 5, 260, 131,
	2, 1815, 1816, 5, 558, 280, 2, 1816, 1817, 5, 260, 131, 2, 1817, 1819,
	3, 2, 2, 2, 1818, 1815, 3, 2, 2, 2, 1819, 1822, 3, 2, 2, 2, 1820, 1818,
	3, 2, 2, 2, 1820, 1821, 3, 2, 2, 2, 1821, 259, 3, 2, 2, 2, 1822, 1820,
	3, 2, 2, 2, 1823, 1829, 5, 296, 149, 2, 1824, 1829, 5, 232, 117, 2, 1825,
	1829, 5, 230, 116, 2, 1826, 1829, 5, 234, 118, 2, 1827, 1829, 5, 236, 119,
	2, 1828, 1823, 3, 2, 2, 2, 1828, 1824, 3, 2, 2, 2, 1828, 1825, 3, 2, 2,
	2, 1828, 1826, 3, 2, 2, 2, 1828, 1827, 3, 2, 2, 2, 1829, 261, 3, 2, 2,
	2, 1830, 1832, 5, 492, 247, 2, 1831, 1833, 5, 278, 140, 2, 1832, 1831,
	3, 2, 2, 2, 1832, 1833, 3, 2, 2, 2, 1833, 1835, 3, 2, 2, 2, 1834, 1836,
	5, 434, 218, 2, 1835, 1834, 3, 2, 2, 2, 1835, 1836, 3, 2, 2, 2, 1836, 1837,
	3, 2, 2, 2, 1837, 1838, 5, 280, 141, 2, 1838, 1840, 5, 268, 135, 2, 1839,
	1841, 5, 276, 139, 2, 1840, 1839, 3, 2, 2, 2, 1840, 1841, 3, 2, 2, 2, 1841,
	1843, 3, 2, 2, 2, 1842, 1844, 5, 272, 137, 2, 1843, 1842, 3, 2, 2, 2, 1843,
	1844, 3, 2, 2, 2, 1844, 1846, 3, 2, 2, 2, 1845, 1847, 5, 266, 134, 2, 1846,
	1845, 3, 2, 2, 2, 1846, 1847, 3, 2, 2, 2, 1847, 1849, 3, 2, 2, 2, 1848,
	1850, 5, 264, 133, 2, 1849, 1848, 3, 2, 2, 2, 1849, 1850, 3, 2, 2, 2, 1850,
	263, 3, 2, 2, 2, 1851, 1852, 5, 356, 179, 2, 1852, 1853, 5, 404, 203, 2,
	1853, 265, 3, 2, 2, 2, 1854, 1855, 5, 446, 224, 2, 1855, 1856, 5, 298,
	150, 2, 1856, 267, 3, 2, 2, 2, 1857, 1858, 5, 408, 205, 2, 1858, 1859,
	5, 270, 136, 2, 1859, 269, 3, 2, 2, 2, 1860, 1865, 7, 171, 2, 2, 1861,
	1862, 7, 171, 2, 2, 1862, 1863, 7, 16, 2, 2, 1863, 1865, 7, 171, 2, 2,
	1864, 1860, 3, 2, 2, 2, 1864, 1861, 3, 2, 2, 2, 1865, 271, 3, 2, 2, 2,
	1866, 1867, 5, 474, 238, 2, 1867, 1868, 5, 374, 188, 2, 1868, 1869, 5,
	274, 138, 2, 1869, 273, 3, 2, 2, 2, 1870, 1873, 7, 171, 2, 2, 1871, 1874,
	5, 366, 184, 2, 1872, 1874, 5, 388, 195, 2, 1873, 1871, 3, 2, 2, 2, 1873,
	1872, 3, 2, 2, 2, 1873, 1874, 3, 2, 2, 2, 1874, 275, 3, 2, 2, 2, 1875,
	1876, 5, 534, 268, 2, 1876, 1877, 5, 284, 143, 2, 1877, 277, 3, 2, 2, 2,
	1878, 1879, 5, 392, 197, 2, 1879, 279, 3, 2, 2, 2, 1880, 1883, 7, 17, 2,
	2, 1881, 1883, 5, 282, 142, 2, 1882, 1880, 3, 2, 2, 2, 1882, 1881, 3, 2,
	2, 2, 1883, 1889, 3, 2, 2, 2, 1884, 1885, 5, 558, 280, 2, 1885, 1886, 5,
	282, 142, 2, 1886, 1888, 3, 2, 2, 2, 1887, 1884, 3, 2, 2, 2, 1888, 1891,
	3, 2, 2, 2, 1889, 1887, 3, 2, 2, 2, 1889, 1890, 3, 2, 2, 2, 1890, 281,
	3, 2, 2, 2, 1891, 1889, 3, 2, 2, 2, 1892, 1893, 7, 171, 2, 2, 1893, 1894,
	7, 16, 2, 2, 1894, 1908, 7, 17, 2, 2, 1895, 1899, 7, 171, 2, 2, 1896, 1897,
	5, 364, 183, 2, 1897, 1898, 7, 171, 2, 2, 1898, 1900, 3, 2, 2, 2, 1899,
	1896, 3, 2, 2, 2, 1899, 1900, 3, 2, 2, 2, 1900, 1908, 3, 2, 2, 2, 1901,
	1905, 5, 292, 147, 2, 1902, 1903, 5, 364, 183, 2, 1903, 1904, 7, 171, 2,
	2, 1904, 1906, 3, 2, 2, 2, 1905, 1902, 3, 2, 2, 2, 1905, 1906, 3, 2, 2,
	2, 1906, 1908, 3, 2, 2, 2, 1907, 1892, 3, 2, 2, 2, 1907, 1895, 3, 2, 2,
	2, 1907, 1901, 3, 2, 2, 2, 1908, 283, 3, 2, 2, 2, 1909, 1915, 5, 286, 144,
	2, 1910, 1911, 5, 360, 181, 2, 1911, 1912, 5, 286, 144, 2, 1912, 1914,
	3, 2, 2, 2, 1913, 1910, 3, 2, 2, 2, 1914, 1917, 3, 2, 2, 2, 1915, 1913,
	3, 2, 2, 2, 1915, 1916, 3, 2, 2, 2, 1916, 285, 3, 2, 2, 2, 1917, 1915,
	3, 2, 2, 2, 1918, 1919, 7, 171, 2, 2, 1919, 1920, 9, 3, 2, 2, 1920, 1990,
	5, 296, 149, 2, 1921, 1922, 7, 171, 2, 2, 1922, 1923, 7, 16, 2, 2, 1923,
	1924, 7, 171, 2, 2, 1924, 1925, 9, 3, 2, 2, 1925, 1990, 5, 296, 149, 2,
	1926, 1927, 5, 292, 147, 2, 1927, 1928, 9, 3, 2, 2, 1928, 1929, 5, 296,
	149, 2, 1929, 1990, 3, 2, 2, 2, 1930, 1931, 5, 292, 147, 2, 1931, 1932,
	9, 3, 2, 2, 1932, 1933, 5, 292, 147, 2, 1933, 1990, 3, 2, 2, 2, 1934, 1935,
	7, 171, 2, 2, 1935, 1936, 5, 420, 211, 2, 1936, 1938, 7, 3, 2, 2, 1937,
	1939, 5, 294, 148, 2, 1938, 1937, 3, 2, 2, 2, 1938, 1939, 3, 2, 2, 2, 1939,
	1940, 3, 2, 2, 2, 1940, 1941, 7, 4, 2, 2, 1941, 1990, 3, 2, 2, 2, 1942,
	1943, 7, 3, 2, 2, 1943, 1949, 7, 171, 2, 2, 1944, 1945, 5, 558, 280, 2,
	1945, 1946, 7, 171, 2, 2, 1946, 1948, 3, 2, 2, 2, 1947, 1944, 3, 2, 2,
	2, 1948, 1951, 3, 2, 2, 2, 1949, 1947, 3, 2, 2, 2, 1949, 1950, 3, 2, 2,
	2, 1950, 1952, 3, 2, 2, 2, 1951, 1949, 3, 2, 2, 2, 1952, 1953, 7, 4, 2,
	2, 1953, 1954, 5, 420, 211, 2, 1954, 1955, 7, 3, 2, 2, 1955, 1961, 5, 236,
	119, 2, 1956, 1957, 5, 558, 280, 2, 1957, 1958, 5, 236, 119, 2, 1958, 1960,
	3, 2, 2, 2, 1959, 1956, 3, 2, 2, 2, 1960, 1963, 3, 2, 2, 2, 1961, 1959,
	3, 2, 2, 2, 1961, 1962, 3, 2, 2, 2, 1962, 1964, 3, 2, 2, 2, 1963, 1961,
	3, 2, 2, 2, 1964, 1965, 7, 4, 2, 2, 1965, 1990, 3, 2, 2, 2, 1966, 1967,
	7, 3, 2, 2, 1967, 1973, 7, 171, 2, 2, 1968, 1969, 5, 558, 280, 2, 1969,
	1970, 7, 171, 2, 2, 1970, 1972, 3, 2, 2, 2, 1971, 1968, 3, 2, 2, 2, 1972,
	1975, 3, 2, 2, 2, 1973, 1971, 3, 2, 2, 2, 1973, 1974, 3, 2, 2, 2, 1974,
	1976, 3, 2, 2, 2, 1975, 1973, 3, 2, 2, 2, 1976, 1977, 7, 4, 2, 2, 1977,
	1978, 9, 3, 2, 2, 1978, 1984, 5, 236, 119, 2, 1979, 1980, 5, 558, 280,
	2, 1980, 1981, 5, 236, 119, 2, 1981, 1983, 3, 2, 2, 2, 1982, 1979, 3, 2,
	2, 2, 1983, 1986, 3, 2, 2, 2, 1984, 1982, 3, 2, 2, 2, 1984, 1985, 3, 2,
	2, 2, 1985, 1990, 3, 2, 2, 2, 1986, 1984, 3, 2, 2, 2, 1987, 1990, 5, 290,
	146, 2, 1988, 1990, 5, 288, 145, 2, 1989, 1918, 3, 2, 2, 2, 1989, 1921,
	3, 2, 2, 2, 1989, 1926, 3, 2, 2, 2, 1989, 1930, 3, 2, 2, 2, 1989, 1934,
	3, 2, 2, 2, 1989, 1942, 3, 2, 2, 2, 1989, 1966, 3, 2, 2, 2, 1989, 1987,
	3, 2, 2, 2, 1989, 1988, 3, 2, 2, 2, 1990, 287, 3, 2, 2, 2, 1991, 1992,
	7, 171, 2, 2, 1992, 1993, 5, 382, 192, 2, 1993, 1994, 5, 296, 149, 2, 1994,
	289, 3, 2, 2, 2, 1995, 1996, 7, 171, 2, 2, 1996, 1997, 5, 382, 192, 2,
	1997, 1998, 5, 436, 219, 2, 1998, 1999, 3, 2, 2, 2, 1999, 2000, 5, 296,
	149, 2, 2000, 291, 3, 2, 2, 2, 2001, 2002, 7, 171, 2, 2, 2002, 2003, 7,
	3, 2, 2, 2003, 2004, 7, 17, 2, 2, 2004, 2012, 7, 4, 2, 2, 2005, 2006, 7,
	171, 2, 2, 2006, 2008, 7, 3, 2, 2, 2007, 2009, 5, 294, 148, 2, 2008, 2007,
	3, 2, 2, 2, 2008, 2009, 3, 2, 2, 2, 2009, 2010, 3, 2, 2, 2, 2010, 2012,
	7, 4, 2, 2, 2011, 2001, 3, 2, 2, 2, 2011, 2005, 3, 2, 2, 2, 2012, 293,
	3, 2, 2, 2, 2013, 2017, 5, 296, 149, 2, 2014, 2017, 7, 171, 2, 2, 2015,
	2017, 5, 292, 147, 2, 2016, 2013, 3, 2, 2, 2, 2016, 2014, 3, 2, 2, 2, 2016,
	2015, 3, 2, 2, 2, 2017, 2026, 3, 2, 2, 2, 2018, 2022, 5, 558, 280, 2, 2019,
	2023, 5, 296, 149, 2, 2020, 2023, 7, 171, 2, 2, 2021, 2023, 5, 292, 147,
	2, 2022, 2019, 3, 2, 2, 2, 2022, 2020, 3, 2, 2, 2, 2022, 2021, 3, 2, 2,
	2, 2023, 2025, 3, 2, 2, 2, 2024, 2018, 3, 2, 2, 2, 2025, 2028, 3, 2, 2,
	2, 2026, 2024, 3, 2, 2, 2, 2026, 2027, 3, 2, 2, 2, 2027, 295, 3, 2, 2,
	2, 2028, 2026, 3, 2, 2, 2, 2029, 2038, 7, 172, 2, 2, 2030, 2038, 5, 302,
	152, 2, 2031, 2038, 5, 298, 150, 2, 2032, 2038, 5, 300, 151, 2, 2033, 2038,
	5, 306, 154, 2, 2034, 2038, 5, 304, 153, 2, 2035, 2038, 5, 50, 26, 2, 2036,
	2038, 5, 464, 233, 2, 2037, 2029, 3, 2, 2, 2, 2037, 2030, 3, 2, 2, 2, 2037,
	2031, 3, 2, 2, 2, 2037, 2032, 3, 2, 2, 2, 2037, 2033, 3, 2, 2, 2, 2037,
	2034, 3, 2, 2, 2, 2037, 2035, 3, 2, 2, 2, 2037, 2036, 3, 2, 2, 2, 2038,
	297, 3, 2, 2, 2, 2039, 2040, 7, 167, 2, 2, 2040, 299, 3, 2, 2, 2, 2041,
	2042, 9, 4, 2, 2, 2042, 301, 3, 2, 2, 2, 2043, 2044, 7, 166, 2, 2, 2044,
	303, 3, 2, 2, 2, 2045, 2046, 9, 5, 2, 2, 2046, 305, 3, 2, 2, 2, 2047, 2048,
	7, 169, 2, 2, 2048, 307, 3, 2, 2, 2, 2049, 2054, 7, 171, 2, 2, 2050, 2051,
	7, 23, 2, 2, 2051, 2052, 7, 171, 2, 2, 2052, 2054, 7, 23, 2, 2, 2053, 2049,
	3, 2, 2, 2, 2053, 2050, 3, 2, 2, 2, 2054, 309, 3, 2, 2, 2, 2055, 2060,
	7, 171, 2, 2, 2056, 2057, 7, 23, 2, 2, 2057, 2058, 7, 171, 2, 2, 2058,
	2060, 7, 23, 2, 2, 2059, 2055, 3, 2, 2, 2, 2059, 2056, 3, 2, 2, 2, 2060,
	311, 3, 2, 2, 2, 2061, 2066, 7, 171, 2, 2, 2062, 2063, 7, 23, 2, 2, 2063,
	2064, 7, 171, 2, 2, 2064, 2066, 7, 23, 2, 2, 2065, 2061, 3, 2, 2, 2, 2065,
	2062, 3, 2, 2, 2, 2066, 313, 3, 2, 2, 2, 2067, 2069, 5, 316, 159, 2, 2068,
	2070, 5, 318, 160, 2, 2069, 2068, 3, 2, 2, 2, 2069, 2070, 3, 2, 2, 2, 2070,
	315, 3, 2, 2, 2, 2071, 2072, 9, 6, 2, 2, 2072, 317, 3, 2, 2, 2, 2073, 2074,
	5, 550, 276, 2, 2074, 2080, 5, 316, 159, 2, 2075, 2076, 5, 558, 280, 2,
	2076, 2077, 5, 316, 159, 2, 2077, 2079, 3, 2, 2, 2, 2078, 2075, 3, 2, 2,
	2, 2079, 2082, 3, 2, 2, 2, 2080, 2078, 3, 2, 2, 2, 2080, 2081, 3, 2, 2,
	2, 2081, 2083, 3, 2, 2, 2, 2082, 2080, 3, 2, 2, 2, 2083, 2084, 5, 552,
	277, 2, 2084, 319, 3, 2, 2, 2, 2085, 2088, 5, 366, 184, 2, 2086, 2088,
	5, 388, 195, 2, 2087, 2085, 3, 2, 2, 2, 2087, 2086, 3, 2, 2, 2, 2088, 321,
	3, 2, 2, 2, 2089, 2090, 7, 171, 2, 2, 2090, 323, 3, 2, 2, 2, 2091, 2092,
	7, 171, 2, 2, 2092, 325, 3, 2, 2, 2, 2093, 2094, 5, 302, 152, 2, 2094,
	327, 3, 2, 2, 2, 2095, 2096, 7, 171, 2, 2, 2096, 329, 3, 2, 2, 2, 2097,
	2098, 7, 171, 2, 2, 2098, 331, 3, 2, 2, 2, 2099, 2100, 7, 171, 2, 2, 2100,
	333, 3, 2, 2, 2, 2101, 2102, 7, 171, 2, 2, 2102, 335, 3, 2, 2, 2, 2103,
	2104, 7, 171, 2, 2, 2104, 337, 3, 2, 2, 2, 2105, 2106, 7, 171, 2, 2, 2106,
	339, 3, 2, 2, 2, 2107, 2108, 5, 302, 152, 2, 2108, 341, 3, 2, 2, 2, 2109,
	2110, 7, 171, 2, 2, 2110, 343, 3, 2, 2, 2, 2111, 2112, 5, 346, 174, 2,
	2112, 2113, 5, 314, 158, 2, 2113, 345, 3, 2, 2, 2, 2114, 2115, 7, 171,
	2, 2, 2115, 347, 3, 2, 2, 2, 2116, 2117, 7, 25, 2, 2, 2117, 349, 3, 2,
	2, 2, 2118, 2119, 7, 26, 2, 2, 2119, 351, 3, 2, 2, 2, 2120, 2121, 7, 27,
	2, 2, 2121, 353, 3, 2, 2, 2, 2122, 2123, 7, 27, 2, 2, 2123, 2124, 7, 103,
	2, 2, 2124, 355, 3, 2, 2, 2, 2125, 2126, 7, 28, 2, 2, 2126, 357, 3, 2,
	2, 2, 2127, 2128, 7, 29, 2, 2, 2128, 359, 3, 2, 2, 2, 2129, 2130, 7, 30,
	2, 2, 2130, 361, 3, 2, 2, 2, 2131, 2132, 7, 32, 2, 2, 2132, 363, 3, 2,
	2, 2, 2133, 2134, 7, 33, 2, 2, 2134, 365, 3, 2, 2, 2, 2135, 2136, 7, 34,
	2, 2, 2136, 367, 3, 2, 2, 2, 2137, 2138, 7, 35, 2, 2, 2138, 369, 3, 2,
	2, 2, 2139, 2140, 7, 36, 2, 2, 2140, 371, 3, 2, 2, 2, 2141, 2142, 7, 37,
	2, 2, 2142, 373, 3, 2, 2, 2, 2143, 2144, 7, 38, 2, 2, 2144, 375, 3, 2,
	2, 2, 2145, 2146, 7, 39, 2, 2, 2146, 377, 3, 2, 2, 2, 2147, 2148, 7, 40,
	2, 2, 2148, 379, 3, 2, 2, 2, 2149, 2150, 7, 42, 2, 2, 2150, 381, 3, 2,
	2, 2, 2151, 2152, 7, 44, 2, 2, 2152, 383, 3, 2, 2, 2, 2153, 2154, 7, 45,
	2, 2, 2154, 385, 3, 2, 2, 2, 2155, 2156, 7, 47, 2, 2, 2156, 387, 3, 2,
	2, 2, 2157, 2158, 7, 48, 2, 2, 2158, 389, 3, 2, 2, 2, 2159, 2160, 7, 49,
	2, 2, 2160, 391, 3, 2, 2, 2, 2161, 2162, 7, 50, 2, 2, 2162, 393, 3, 2,
	2, 2, 2163, 2164, 7, 51, 2, 2, 2164, 395, 3, 2, 2, 2, 2165, 2166, 7, 52,
	2, 2, 2166, 397, 3, 2, 2, 2, 2167, 2168, 7, 54, 2, 2, 2168, 399, 3, 2,
	2, 2, 2169, 2170, 7, 55, 2, 2, 2170, 401, 3, 2, 2, 2, 2171, 2172, 7, 56,
	2, 2, 2172, 403, 3, 2, 2, 2, 2173, 2174, 7, 58, 2, 2, 2174, 405, 3, 2,
	2, 2, 2175, 2176, 7, 59, 2, 2, 2176, 407, 3, 2, 2, 2, 2177, 2178, 7, 60,
	2, 2, 2178, 409, 3, 2, 2, 2, 2179, 2180, 7, 61, 2, 2, 2180, 411, 3, 2,
	2, 2, 2181, 2182, 7, 62, 2, 2, 2182, 413, 3, 2, 2, 2, 2183, 2184, 7, 63,
	2, 2, 2184, 415, 3, 2, 2, 2, 2185, 2186, 7, 64, 2, 2, 2186, 417, 3, 2,
	2, 2, 2187, 2188, 7, 65, 2, 2, 2188, 419, 3, 2, 2, 2, 2189, 2190, 7, 66,
	2, 2, 2190, 421, 3, 2, 2, 2, 2191, 2192, 7, 67, 2, 2, 2192, 423, 3, 2,
	2, 2, 2193, 2194, 7, 69, 2, 2, 2194, 425, 3, 2, 2, 2, 2195, 2196, 7, 70,
	2, 2, 2196, 427, 3, 2, 2, 2, 2197, 2198, 7, 71, 2, 2, 2198, 429, 3, 2,
	2, 2, 2199, 2200, 7, 72, 2, 2, 2200, 431, 3, 2, 2, 2, 2201, 2202, 7, 73,
	2, 2, 2202, 433, 3, 2, 2, 2, 2203, 2204, 7, 74, 2, 2, 2204, 435, 3, 2,
	2, 2, 2205, 2206, 7, 75, 2, 2, 2206, 437, 3, 2, 2, 2, 2207, 2208, 7, 76,
	2, 2, 2208, 439, 3, 2, 2, 2, 2209, 2210, 7, 77, 2, 2, 2210, 441, 3, 2,
	2, 2, 2211, 2212, 7, 78, 2, 2, 2212, 443, 3, 2, 2, 2, 2213, 2214, 7, 79,
	2, 2, 2214, 445, 3, 2, 2, 2, 2215, 2216, 7, 81, 2, 2, 2216, 447, 3, 2,
	2, 2, 2217, 2218, 7, 155, 2, 2, 2218, 449, 3, 2, 2, 2, 2219, 2220, 7, 84,
	2, 2, 2220, 451, 3, 2, 2, 2, 2221, 2222, 7, 85, 2, 2, 2222, 453, 3, 2,
	2, 2, 2223, 2224, 7, 86, 2, 2, 2224, 455, 3, 2, 2, 2, 2225, 2226, 7, 87,
	2, 2, 2226, 457, 3, 2, 2, 2, 2227, 2228, 7, 90, 2, 2, 2228, 459, 3, 2,
	2, 2, 2229, 2230, 7, 89, 2, 2, 2230, 461, 3, 2, 2, 2, 2231, 2232, 7, 91,
	2, 2, 2232, 463, 3, 2, 2, 2, 2233, 2234, 7, 92, 2, 2, 2234, 465, 3, 2,
	2, 2, 2235, 2236, 7, 93, 2, 2, 2236, 467, 3, 2, 2, 2, 2237, 2238, 7, 94,
	2, 2, 2238, 469, 3, 2, 2, 2, 2239, 2240, 7, 96, 2, 2, 2240, 471, 3, 2,
	2, 2, 2241, 2242, 7, 97, 2, 2, 2242, 473, 3, 2, 2, 2, 2243, 2244, 7, 98,
	2, 2, 2244, 475, 3, 2, 2, 2, 2245, 2246, 7, 100, 2, 2, 2246, 477, 3, 2,
	2, 2, 2247, 2248, 7, 104, 2, 2, 2248, 479, 3, 2, 2, 2, 2249, 2250, 7, 106,
	2, 2, 2250, 481, 3, 2, 2, 2, 2251, 2252, 7, 107, 2, 2, 2252, 483, 3, 2,
	2, 2, 2253, 2254, 7, 108, 2, 2, 2254, 485, 3, 2, 2, 2, 2255, 2256, 7, 109,
	2, 2, 2256, 487, 3, 2, 2, 2, 2257, 2258, 7, 111, 2, 2, 2258, 489, 3, 2,
	2, 2, 2259, 2260, 7, 112, 2, 2, 2260, 491, 3, 2, 2, 2, 2261, 2262, 7, 114,
	2, 2, 2262, 493, 3, 2, 2, 2, 2263, 2264, 7, 115, 2, 2, 2264, 495, 3, 2,
	2, 2, 2265, 2266, 7, 116, 2, 2, 2266, 497, 3, 2, 2, 2, 2267, 2268, 7, 118,
	2, 2, 2268, 499, 3, 2, 2, 2, 2269, 2270, 7, 119, 2, 2, 2270, 501, 3, 2,
	2, 2, 2271, 2272, 7, 120, 2, 2, 2272, 503, 3, 2, 2, 2, 2273, 2274, 7, 121,
	2, 2, 2274, 505, 3, 2, 2, 2, 2275, 2276, 7, 123, 2, 2, 2276, 507, 3, 2,
	2, 2, 2277, 2278, 7, 124, 2, 2, 2278, 509, 3, 2, 2, 2, 2279, 2280, 7, 126,
	2, 2, 2280, 511, 3, 2, 2, 2, 2281, 2282, 7, 128, 2, 2, 2282, 513, 3, 2,
	2, 2, 2283, 2284, 7, 129, 2, 2, 2284, 515, 3, 2, 2, 2, 2285, 2286, 7, 131,
	2, 2, 2286, 517, 3, 2, 2, 2, 2287, 2288, 7, 132, 2, 2, 2288, 519, 3, 2,
	2, 2, 2289, 2290, 7, 133, 2, 2, 2290, 521, 3, 2, 2, 2, 2291, 2292, 7, 134,
	2, 2, 2292, 523, 3, 2, 2, 2, 2293, 2294, 7, 135, 2, 2, 2294, 525, 3, 2,
	2, 2, 2295, 2296, 7, 178, 2, 2, 2296, 527, 3, 2, 2, 2, 2297, 2298, 7, 136,
	2, 2, 2298, 529, 3, 2, 2, 2, 2299, 2300, 7, 138, 2, 2, 2300, 531, 3, 2,
	2, 2, 2301, 2302, 7, 139, 2, 2, 2302, 533, 3, 2, 2, 2, 2303, 2304, 7, 140,
	2, 2, 2304, 535, 3, 2, 2, 2, 2305, 2306, 7, 141, 2, 2, 2306, 537, 3, 2,
	2, 2, 2307, 2308, 7, 110, 2, 2, 2308, 539, 3, 2, 2, 2, 2309, 2310, 7, 2,
	2, 3, 2310, 541, 3, 2, 2, 2, 2311, 2312, 7, 3, 2, 2, 2312, 543, 3, 2, 2,
	2, 2313, 2314, 7, 4, 2, 2, 2314, 545, 3, 2, 2, 2, 2315, 2316, 7, 5, 2,
	2, 2316, 547, 3, 2, 2, 2, 2317, 2318, 7, 6, 2, 2, 2318, 549, 3, 2, 2, 2,
	2319, 2320, 7, 174, 2, 2, 2320, 551, 3, 2, 2, 2, 2321, 2322, 7, 175, 2,
	2, 2322, 553, 3, 2, 2, 2, 2323, 2324, 7, 7, 2, 2, 2324, 555, 3, 2, 2, 2,
	2325, 2326, 7, 8, 2, 2, 2326, 557, 3, 2, 2, 2, 2327, 2328, 7, 9, 2, 2,
	2328, 559, 3, 2, 2, 2, 2329, 2330, 7, 11, 2, 2, 2330, 561, 3, 2, 2, 2,
	181, 563, 566, 572, 577, 579, 584, 587, 590, 633, 650, 653, 660, 665, 676,
	686, 701, 712, 717, 726, 731, 739, 744, 748, 753, 758, 773, 779, 784, 794,
	799, 809, 821, 828, 836, 850, 855, 867, 871, 875, 880, 885, 904, 911, 919,
	923, 928, 947, 956, 971, 973, 985, 999, 1006, 1013, 1021, 1032, 1048, 1061,
	1072, 1095, 1109, 1116, 1125, 1144, 1152, 1158, 1163, 1170, 1175, 1183,
	1188, 1195, 1200, 1207, 1212, 1219, 1226, 1233, 1240, 1245, 1252, 1259,
	1264, 1271, 1276, 1283, 1287, 1290, 1298, 1308, 1319, 1325, 1334, 1347,
	1355, 1361, 1366, 1380, 1400, 1409, 1421, 1425, 1429, 1443, 1451, 1460,
	1471, 1476, 1483, 1486, 1492, 1501, 1507, 1525, 1529, 1533, 1538, 1546,
	1554, 1558, 1561, 1567, 1571, 1578, 1589, 1602, 1611, 1658, 1667, 1670,
	1686, 1698, 1710, 1718, 1721, 1729, 1732, 1737, 1744, 1748, 1752, 1755,
	1773, 1799, 1811, 1820, 1828, 1832, 1835, 1840, 1843, 1846, 1849, 1864,
	1873, 1882, 1889, 1899, 1905, 1907, 1915, 1938, 1949, 1961, 1973, 1984,
	1989, 2008, 2011, 2016, 2022, 2026, 2037, 2053, 2059, 2065, 2069, 2080,
	2087,
}
var literalNames = []string{
	"", "'('", "')'", "'{'", "'}'", "'['", "']'", "','", "';'", "':'", "",
	"", "", "", "'.'", "'*'", "'/'", "'%'", "'+'", "'--'", "'-'", "'\"'", "'''",
}
var symbolicNames = []string{
	"", "LR_BRACKET", "RR_BRACKET", "LC_BRACKET", "RC_BRACKET", "LS_BRACKET",
	"RS_BRACKET", "COMMA", "SEMI", "COLON", "SPACE", "SPEC_MYSQL_COMMENT",
	"COMMENT_INPUT", "LINE_COMMENT", "DOT", "STAR", "DIVIDE", "MODULE", "PLUS",
	"MINUSMINUS", "MINUS", "DQUOTE", "SQUOTE", "K_ADD", "K_AGGREGATE", "K_ALL",
	"K_ALLOW", "K_ALTER", "K_AND", "K_ANY", "K_APPLY", "K_AS", "K_ASC", "K_AUTHORIZE",
	"K_BATCH", "K_BEGIN", "K_BY", "K_CALLED", "K_CLUSTERING", "K_COLUMNFAMILY",
	"K_COMPACT", "K_CONSISTENCY", "K_CONTAINS", "K_CREATE", "K_CUSTOM", "K_DELETE",
	"K_DESC", "K_DESCRIBE", "K_DISTINCT", "K_DROP", "K_DURABLE_WRITES", "K_EACH_QUORUM",
	"K_ENTRIES", "K_EXECUTE", "K_EXISTS", "K_FALSE", "K_FILTERING", "K_FINALFUNC",
	"K_FROM", "K_FULL", "K_FUNCTION", "K_FUNCTIONS", "K_GRANT", "K_IF", "K_IN",
	"K_INDEX", "K_INFINITY", "K_INITCOND", "K_INPUT", "K_INSERT", "K_INTO",
	"K_IS", "K_JSON", "K_KEY", "K_KEYS", "K_KEYSPACE", "K_KEYSPACES", "K_LANGUAGE",
	"K_LEVEL", "K_LIMIT", "K_LOCAL_ONE", "K_LOCAL_QUORUM", "K_LOGGED", "K_LOGIN",
	"K_MATERIALIZED", "K_MODIFY", "K_NAN", "K_NORECURSIVE", "K_NOSUPERUSER",
	"K_NOT", "K_NULL", "K_OF", "K_ON", "K_ONE", "K_OPTIONS", "K_OR", "K_ORDER",
	"K_PARTITION", "K_PASSWORD", "K_PER", "K_PERMISSION", "K_PERMISSIONS",
	"K_PRIMARY", "K_QUORUM", "K_RENAME", "K_REPLACE", "K_REPLICATION", "K_RETURNS",
	"K_REVOKE", "K_ROLE", "K_ROLES", "K_SCHEMA", "K_SELECT", "K_SET", "K_SFUNC",
	"K_STATIC", "K_STORAGE", "K_STYPE", "K_SUPERUSER", "K_TABLE", "K_THREE",
	"K_TIMESTAMP", "K_TO", "K_TOKEN", "K_TRIGGER", "K_TRUE", "K_TRUNCATE",
	"K_TTL", "K_TWO", "K_TYPE", "K_UNLOGGED", "K_UPDATE", "K_USE", "K_USER",
	"K_USING", "K_UUID", "K_VALUES", "K_VIEW", "K_WHERE", "K_WITH", "K_WRITETIME",
	"K_ASCII", "K_BIGINT", "K_BLOB", "K_BOOLEAN", "K_COUNTER", "K_DATE", "K_DECIMAL",
	"K_DOUBLE", "K_FLOAT", "K_FROZEN", "K_INET", "K_INT", "K_LIST", "K_MAP",
	"K_SMALLINT", "K_TEXT", "K_TIMEUUID", "K_TIME", "K_TINYINT", "K_TUPLE",
	"K_VARCHAR", "K_VARINT", "CODE_BLOCK", "STRING_LITERAL", "DECIMAL_LITERAL",
	"FLOAT_LITERAL", "HEXADECIMAL_LITERAL", "REAL_LITERAL", "OBJECT_NAME",
	"UUID", "OPERATOR_EQ", "OPERATOR_LT", "OPERATOR_GT", "OPERATOR_LTE", "OPERATOR_GTE",
	"K_USERS",
}

var ruleNames = []string{
	"root", "cqls", "statementSeparator", "empty_", "cql", "revoke", "listUsers",
	"listRoles", "listPermissions", "grant", "priviledge", "resource", "createUser",
	"createRole", "createType", "typeMemberColumnList", "createTrigger", "createMaterializedView",
	"materializedViewWhere", "columnNotNullList", "columnNotNull", "materializedViewOptions",
	"createKeyspace", "createFunction", "codeBlock", "paramList", "returnMode",
	"createAggregate", "initCondDefinition", "initCondHash", "initCondHashItem",
	"initCondListNested", "initCondList", "orReplace", "alterUser", "userPassword",
	"userSuperUser", "alterType", "alterTypeOperation", "alterTypeRename",
	"alterTypeRenameList", "alterTypeRenameItem", "alterTypeAdd", "alterTypeAlterType",
	"alterTable", "alterTableOperation", "alterTableWith", "alterTableRename",
	"alterTableDropCompactStorage", "alterTableDropColumns", "alterTableDropColumnList",
	"alterTableAdd", "alterTableColumnDefinition", "alterRole", "roleWith",
	"roleWithOptions", "alterMaterializedView", "dropUser", "dropType", "dropMaterializedView",
	"dropAggregate", "dropFunction", "dropTrigger", "dropRole", "dropTable",
	"dropKeyspace", "dropIndex", "createTable", "withElement", "clusteringOrder",
	"tableOptions", "tableOptionItem", "tableOptionName", "tableOptionValue",
	"optionHash", "optionHashItem", "optionHashKey", "optionHashValue", "columnDefinitionList",
	"columnDefinition", "primaryKeyColumn", "primaryKeyElement", "primaryKeyDefinition",
	"singlePrimaryKey", "compoundKey", "compositeKey", "partitionKeyList",
	"clusteringKeyList", "partitionKey", "clusteringKey", "applyBatch", "beginBatch",
	"batchType", "alterKeyspace", "replicationList", "replicationListItem",
	"durableWrites", "use_", "truncate", "createIndex", "indexName", "indexColumnSpec",
	"indexKeysSpec", "indexEntriesSSpec", "indexFullSpec", "delete_", "deleteColumnList",
	"deleteColumnItem", "update", "ifSpec", "ifConditionList", "ifCondition",
	"assignments", "assignmentElement", "assignmentSet", "assignmentMap", "assignmentList",
	"assignmentTuple", "insert", "usingTtlTimestamp", "timestamp", "ttl", "usingTimestampSpec",
	"ifNotExist", "ifExist", "insertValuesSpec", "insertColumnSpec", "columnList",
	"expressionList", "expression", "select_", "allowFilteringSpec", "limitSpec",
	"fromSpec", "fromSpecElement", "orderSpec", "orderSpecElement", "whereSpec",
	"distinctSpec", "selectElements", "selectElement", "relationElements",
	"relationElement", "relalationContains", "relalationContainsKey", "functionCall",
	"functionArgs", "constant", "decimalLiteral", "floatLiteral", "stringLiteral",
	"booleanLiteral", "hexadecimalLiteral", "keyspace", "table", "column",
	"dataType", "dataTypeName", "dataTypeDefinition", "orderDirection", "role",
	"trigger", "triggerClass", "materializedView", "type_", "aggregate", "function_",
	"language", "user", "password", "hashKey", "param", "paramName", "kwAdd",
	"kwAggregate", "kwAll", "kwAllPermissions", "kwAllow", "kwAlter", "kwAnd",
	"kwApply", "kwAs", "kwAsc", "kwAuthorize", "kwBatch", "kwBegin", "kwBy",
	"kwCalled", "kwClustering", "kwCompact", "kwContains", "kwCreate", "kwDelete",
	"kwDesc", "kwDescibe", "kwDistinct", "kwDrop", "kwDurableWrites", "kwEntries",
	"kwExecute", "kwExists", "kwFiltering", "kwFinalfunc", "kwFrom", "kwFull",
	"kwFunction", "kwFunctions", "kwGrant", "kwIf", "kwIn", "kwIndex", "kwInitcond",
	"kwInput", "kwInsert", "kwInto", "kwIs", "kwJson", "kwKey", "kwKeys", "kwKeyspace",
	"kwKeyspaces", "kwLanguage", "kwLimit", "kwList", "kwLogged", "kwLogin",
	"kwMaterialized", "kwModify", "kwNosuperuser", "kwNorecursive", "kwNot",
	"kwNull", "kwOf", "kwOn", "kwOptions", "kwOr", "kwOrder", "kwPassword",
	"kwPrimary", "kwRename", "kwReplace", "kwReplication", "kwReturns", "kwRole",
	"kwRoles", "kwSelect", "kwSet", "kwSfunc", "kwStorage", "kwStype", "kwSuperuser",
	"kwTable", "kwTimestamp", "kwTo", "kwTrigger", "kwTruncate", "kwTtl", "kwType",
	"kwUnlogged", "kwUpdate", "kwUse", "kwUser", "kwUsers", "kwUsing", "kwValues",
	"kwView", "kwWhere", "kwWith", "kwRevoke", "eof", "syntaxBracketLr", "syntaxBracketRr",
	"syntaxBracketLc", "syntaxBracketRc", "syntaxBracketLa", "syntaxBracketRa",
	"syntaxBracketLs", "syntaxBracketRs", "syntaxComma", "syntaxColon",
}

type CqlParser struct {
	*antlr.BaseParser
}

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

	return this
}

// CqlParser tokens.
const (
	CqlParserEOF                 = antlr.TokenEOF
	CqlParserLR_BRACKET          = 1
	CqlParserRR_BRACKET          = 2
	CqlParserLC_BRACKET          = 3
	CqlParserRC_BRACKET          = 4
	CqlParserLS_BRACKET          = 5
	CqlParserRS_BRACKET          = 6
	CqlParserCOMMA               = 7
	CqlParserSEMI                = 8
	CqlParserCOLON               = 9
	CqlParserSPACE               = 10
	CqlParserSPEC_MYSQL_COMMENT  = 11
	CqlParserCOMMENT_INPUT       = 12
	CqlParserLINE_COMMENT        = 13
	CqlParserDOT                 = 14
	CqlParserSTAR                = 15
	CqlParserDIVIDE              = 16
	CqlParserMODULE              = 17
	CqlParserPLUS                = 18
	CqlParserMINUSMINUS          = 19
	CqlParserMINUS               = 20
	CqlParserDQUOTE              = 21
	CqlParserSQUOTE              = 22
	CqlParserK_ADD               = 23
	CqlParserK_AGGREGATE         = 24
	CqlParserK_ALL               = 25
	CqlParserK_ALLOW             = 26
	CqlParserK_ALTER             = 27
	CqlParserK_AND               = 28
	CqlParserK_ANY               = 29
	CqlParserK_APPLY             = 30
	CqlParserK_AS                = 31
	CqlParserK_ASC               = 32
	CqlParserK_AUTHORIZE         = 33
	CqlParserK_BATCH             = 34
	CqlParserK_BEGIN             = 35
	CqlParserK_BY                = 36
	CqlParserK_CALLED            = 37
	CqlParserK_CLUSTERING        = 38
	CqlParserK_COLUMNFAMILY      = 39
	CqlParserK_COMPACT           = 40
	CqlParserK_CONSISTENCY       = 41
	CqlParserK_CONTAINS          = 42
	CqlParserK_CREATE            = 43
	CqlParserK_CUSTOM            = 44
	CqlParserK_DELETE            = 45
	CqlParserK_DESC              = 46
	CqlParserK_DESCRIBE          = 47
	CqlParserK_DISTINCT          = 48
	CqlParserK_DROP              = 49
	CqlParserK_DURABLE_WRITES    = 50
	CqlParserK_EACH_QUORUM       = 51
	CqlParserK_ENTRIES           = 52
	CqlParserK_EXECUTE           = 53
	CqlParserK_EXISTS            = 54
	CqlParserK_FALSE             = 55
	CqlParserK_FILTERING         = 56
	CqlParserK_FINALFUNC         = 57
	CqlParserK_FROM              = 58
	CqlParserK_FULL              = 59
	CqlParserK_FUNCTION          = 60
	CqlParserK_FUNCTIONS         = 61
	CqlParserK_GRANT             = 62
	CqlParserK_IF                = 63
	CqlParserK_IN                = 64
	CqlParserK_INDEX             = 65
	CqlParserK_INFINITY          = 66
	CqlParserK_INITCOND          = 67
	CqlParserK_INPUT             = 68
	CqlParserK_INSERT            = 69
	CqlParserK_INTO              = 70
	CqlParserK_IS                = 71
	CqlParserK_JSON              = 72
	CqlParserK_KEY               = 73
	CqlParserK_KEYS              = 74
	CqlParserK_KEYSPACE          = 75
	CqlParserK_KEYSPACES         = 76
	CqlParserK_LANGUAGE          = 77
	CqlParserK_LEVEL             = 78
	CqlParserK_LIMIT             = 79
	CqlParserK_LOCAL_ONE         = 80
	CqlParserK_LOCAL_QUORUM      = 81
	CqlParserK_LOGGED            = 82
	CqlParserK_LOGIN             = 83
	CqlParserK_MATERIALIZED      = 84
	CqlParserK_MODIFY            = 85
	CqlParserK_NAN               = 86
	CqlParserK_NORECURSIVE       = 87
	CqlParserK_NOSUPERUSER       = 88
	CqlParserK_NOT               = 89
	CqlParserK_NULL              = 90
	CqlParserK_OF                = 91
	CqlParserK_ON                = 92
	CqlParserK_ONE               = 93
	CqlParserK_OPTIONS           = 94
	CqlParserK_OR                = 95
	CqlParserK_ORDER             = 96
	CqlParserK_PARTITION         = 97
	CqlParserK_PASSWORD          = 98
	CqlParserK_PER               = 99
	CqlParserK_PERMISSION        = 100
	CqlParserK_PERMISSIONS       = 101
	CqlParserK_PRIMARY           = 102
	CqlParserK_QUORUM            = 103
	CqlParserK_RENAME            = 104
	CqlParserK_REPLACE           = 105
	CqlParserK_REPLICATION       = 106
	CqlParserK_RETURNS           = 107
	CqlParserK_REVOKE            = 108
	CqlParserK_ROLE              = 109
	CqlParserK_ROLES             = 110
	CqlParserK_SCHEMA            = 111
	CqlParserK_SELECT            = 112
	CqlParserK_SET               = 113
	CqlParserK_SFUNC             = 114
	CqlParserK_STATIC            = 115
	CqlParserK_STORAGE           = 116
	CqlParserK_STYPE             = 117
	CqlParserK_SUPERUSER         = 118
	CqlParserK_TABLE             = 119
	CqlParserK_THREE             = 120
	CqlParserK_TIMESTAMP         = 121
	CqlParserK_TO                = 122
	CqlParserK_TOKEN             = 123
	CqlParserK_TRIGGER           = 124
	CqlParserK_TRUE              = 125
	CqlParserK_TRUNCATE          = 126
	CqlParserK_TTL               = 127
	CqlParserK_TWO               = 128
	CqlParserK_TYPE              = 129
	CqlParserK_UNLOGGED          = 130
	CqlParserK_UPDATE            = 131
	CqlParserK_USE               = 132
	CqlParserK_USER              = 133
	CqlParserK_USING             = 134
	CqlParserK_UUID              = 135
	CqlParserK_VALUES            = 136
	CqlParserK_VIEW              = 137
	CqlParserK_WHERE             = 138
	CqlParserK_WITH              = 139
	CqlParserK_WRITETIME         = 140
	CqlParserK_ASCII             = 141
	CqlParserK_BIGINT            = 142
	CqlParserK_BLOB              = 143
	CqlParserK_BOOLEAN           = 144
	CqlParserK_COUNTER           = 145
	CqlParserK_DATE              = 146
	CqlParserK_DECIMAL           = 147
	CqlParserK_DOUBLE            = 148
	CqlParserK_FLOAT             = 149
	CqlParserK_FROZEN            = 150
	CqlParserK_INET              = 151
	CqlParserK_INT               = 152
	CqlParserK_LIST              = 153
	CqlParserK_MAP               = 154
	CqlParserK_SMALLINT          = 155
	CqlParserK_TEXT              = 156
	CqlParserK_TIMEUUID          = 157
	CqlParserK_TIME              = 158
	CqlParserK_TINYINT           = 159
	CqlParserK_TUPLE             = 160
	CqlParserK_VARCHAR           = 161
	CqlParserK_VARINT            = 162
	CqlParserCODE_BLOCK          = 163
	CqlParserSTRING_LITERAL      = 164
	CqlParserDECIMAL_LITERAL     = 165
	CqlParserFLOAT_LITERAL       = 166
	CqlParserHEXADECIMAL_LITERAL = 167
	CqlParserREAL_LITERAL        = 168
	CqlParserOBJECT_NAME         = 169
	CqlParserUUID                = 170
	CqlParserOPERATOR_EQ         = 171
	CqlParserOPERATOR_LT         = 172
	CqlParserOPERATOR_GT         = 173
	CqlParserOPERATOR_LTE        = 174
	CqlParserOPERATOR_GTE        = 175
	CqlParserK_USERS             = 176
)

// CqlParser rules.
const (
	CqlParserRULE_root                         = 0
	CqlParserRULE_cqls                         = 1
	CqlParserRULE_statementSeparator           = 2
	CqlParserRULE_empty_                       = 3
	CqlParserRULE_cql                          = 4
	CqlParserRULE_revoke                       = 5
	CqlParserRULE_listUsers                    = 6
	CqlParserRULE_listRoles                    = 7
	CqlParserRULE_listPermissions              = 8
	CqlParserRULE_grant                        = 9
	CqlParserRULE_priviledge                   = 10
	CqlParserRULE_resource                     = 11
	CqlParserRULE_createUser                   = 12
	CqlParserRULE_createRole                   = 13
	CqlParserRULE_createType                   = 14
	CqlParserRULE_typeMemberColumnList         = 15
	CqlParserRULE_createTrigger                = 16
	CqlParserRULE_createMaterializedView       = 17
	CqlParserRULE_materializedViewWhere        = 18
	CqlParserRULE_columnNotNullList            = 19
	CqlParserRULE_columnNotNull                = 20
	CqlParserRULE_materializedViewOptions      = 21
	CqlParserRULE_createKeyspace               = 22
	CqlParserRULE_createFunction               = 23
	CqlParserRULE_codeBlock                    = 24
	CqlParserRULE_paramList                    = 25
	CqlParserRULE_returnMode                   = 26
	CqlParserRULE_createAggregate              = 27
	CqlParserRULE_initCondDefinition           = 28
	CqlParserRULE_initCondHash                 = 29
	CqlParserRULE_initCondHashItem             = 30
	CqlParserRULE_initCondListNested           = 31
	CqlParserRULE_initCondList                 = 32
	CqlParserRULE_orReplace                    = 33
	CqlParserRULE_alterUser                    = 34
	CqlParserRULE_userPassword                 = 35
	CqlParserRULE_userSuperUser                = 36
	CqlParserRULE_alterType                    = 37
	CqlParserRULE_alterTypeOperation           = 38
	CqlParserRULE_alterTypeRename              = 39
	CqlParserRULE_alterTypeRenameList          = 40
	CqlParserRULE_alterTypeRenameItem          = 41
	CqlParserRULE_alterTypeAdd                 = 42
	CqlParserRULE_alterTypeAlterType           = 43
	CqlParserRULE_alterTable                   = 44
	CqlParserRULE_alterTableOperation          = 45
	CqlParserRULE_alterTableWith               = 46
	CqlParserRULE_alterTableRename             = 47
	CqlParserRULE_alterTableDropCompactStorage = 48
	CqlParserRULE_alterTableDropColumns        = 49
	CqlParserRULE_alterTableDropColumnList     = 50
	CqlParserRULE_alterTableAdd                = 51
	CqlParserRULE_alterTableColumnDefinition   = 52
	CqlParserRULE_alterRole                    = 53
	CqlParserRULE_roleWith                     = 54
	CqlParserRULE_roleWithOptions              = 55
	CqlParserRULE_alterMaterializedView        = 56
	CqlParserRULE_dropUser                     = 57
	CqlParserRULE_dropType                     = 58
	CqlParserRULE_dropMaterializedView         = 59
	CqlParserRULE_dropAggregate                = 60
	CqlParserRULE_dropFunction                 = 61
	CqlParserRULE_dropTrigger                  = 62
	CqlParserRULE_dropRole                     = 63
	CqlParserRULE_dropTable                    = 64
	CqlParserRULE_dropKeyspace                 = 65
	CqlParserRULE_dropIndex                    = 66
	CqlParserRULE_createTable                  = 67
	CqlParserRULE_withElement                  = 68
	CqlParserRULE_clusteringOrder              = 69
	CqlParserRULE_tableOptions                 = 70
	CqlParserRULE_tableOptionItem              = 71
	CqlParserRULE_tableOptionName              = 72
	CqlParserRULE_tableOptionValue             = 73
	CqlParserRULE_optionHash                   = 74
	CqlParserRULE_optionHashItem               = 75
	CqlParserRULE_optionHashKey                = 76
	CqlParserRULE_optionHashValue              = 77
	CqlParserRULE_columnDefinitionList         = 78
	CqlParserRULE_columnDefinition             = 79
	CqlParserRULE_primaryKeyColumn             = 80
	CqlParserRULE_primaryKeyElement            = 81
	CqlParserRULE_primaryKeyDefinition         = 82
	CqlParserRULE_singlePrimaryKey             = 83
	CqlParserRULE_compoundKey                  = 84
	CqlParserRULE_compositeKey                 = 85
	CqlParserRULE_partitionKeyList             = 86
	CqlParserRULE_clusteringKeyList            = 87
	CqlParserRULE_partitionKey                 = 88
	CqlParserRULE_clusteringKey                = 89
	CqlParserRULE_applyBatch                   = 90
	CqlParserRULE_beginBatch                   = 91
	CqlParserRULE_batchType                    = 92
	CqlParserRULE_alterKeyspace                = 93
	CqlParserRULE_replicationList              = 94
	CqlParserRULE_replicationListItem          = 95
	CqlParserRULE_durableWrites                = 96
	CqlParserRULE_use_                         = 97
	CqlParserRULE_truncate                     = 98
	CqlParserRULE_createIndex                  = 99
	CqlParserRULE_indexName                    = 100
	CqlParserRULE_indexColumnSpec              = 101
	CqlParserRULE_indexKeysSpec                = 102
	CqlParserRULE_indexEntriesSSpec            = 103
	CqlParserRULE_indexFullSpec                = 104
	CqlParserRULE_delete_                      = 105
	CqlParserRULE_deleteColumnList             = 106
	CqlParserRULE_deleteColumnItem             = 107
	CqlParserRULE_update                       = 108
	CqlParserRULE_ifSpec                       = 109
	CqlParserRULE_ifConditionList              = 110
	CqlParserRULE_ifCondition                  = 111
	CqlParserRULE_assignments                  = 112
	CqlParserRULE_assignmentElement            = 113
	CqlParserRULE_assignmentSet                = 114
	CqlParserRULE_assignmentMap                = 115
	CqlParserRULE_assignmentList               = 116
	CqlParserRULE_assignmentTuple              = 117
	CqlParserRULE_insert                       = 118
	CqlParserRULE_usingTtlTimestamp            = 119
	CqlParserRULE_timestamp                    = 120
	CqlParserRULE_ttl                          = 121
	CqlParserRULE_usingTimestampSpec           = 122
	CqlParserRULE_ifNotExist                   = 123
	CqlParserRULE_ifExist                      = 124
	CqlParserRULE_insertValuesSpec             = 125
	CqlParserRULE_insertColumnSpec             = 126
	CqlParserRULE_columnList                   = 127
	CqlParserRULE_expressionList               = 128
	CqlParserRULE_expression                   = 129
	CqlParserRULE_select_                      = 130
	CqlParserRULE_allowFilteringSpec           = 131
	CqlParserRULE_limitSpec                    = 132
	CqlParserRULE_fromSpec                     = 133
	CqlParserRULE_fromSpecElement              = 134
	CqlParserRULE_orderSpec                    = 135
	CqlParserRULE_orderSpecElement             = 136
	CqlParserRULE_whereSpec                    = 137
	CqlParserRULE_distinctSpec                 = 138
	CqlParserRULE_selectElements               = 139
	CqlParserRULE_selectElement                = 140
	CqlParserRULE_relationElements             = 141
	CqlParserRULE_relationElement              = 142
	CqlParserRULE_relalationContains           = 143
	CqlParserRULE_relalationContainsKey        = 144
	CqlParserRULE_functionCall                 = 145
	CqlParserRULE_functionArgs                 = 146
	CqlParserRULE_constant                     = 147
	CqlParserRULE_decimalLiteral               = 148
	CqlParserRULE_floatLiteral                 = 149
	CqlParserRULE_stringLiteral                = 150
	CqlParserRULE_booleanLiteral               = 151
	CqlParserRULE_hexadecimalLiteral           = 152
	CqlParserRULE_keyspace                     = 153
	CqlParserRULE_table                        = 154
	CqlParserRULE_column                       = 155
	CqlParserRULE_dataType                     = 156
	CqlParserRULE_dataTypeName                 = 157
	CqlParserRULE_dataTypeDefinition           = 158
	CqlParserRULE_orderDirection               = 159
	CqlParserRULE_role                         = 160
	CqlParserRULE_trigger                      = 161
	CqlParserRULE_triggerClass                 = 162
	CqlParserRULE_materializedView             = 163
	CqlParserRULE_type_                        = 164
	CqlParserRULE_aggregate                    = 165
	CqlParserRULE_function_                    = 166
	CqlParserRULE_language                     = 167
	CqlParserRULE_user                         = 168
	CqlParserRULE_password                     = 169
	CqlParserRULE_hashKey                      = 170
	CqlParserRULE_param                        = 171
	CqlParserRULE_paramName                    = 172
	CqlParserRULE_kwAdd                        = 173
	CqlParserRULE_kwAggregate                  = 174
	CqlParserRULE_kwAll                        = 175
	CqlParserRULE_kwAllPermissions             = 176
	CqlParserRULE_kwAllow                      = 177
	CqlParserRULE_kwAlter                      = 178
	CqlParserRULE_kwAnd                        = 179
	CqlParserRULE_kwApply                      = 180
	CqlParserRULE_kwAs                         = 181
	CqlParserRULE_kwAsc                        = 182
	CqlParserRULE_kwAuthorize                  = 183
	CqlParserRULE_kwBatch                      = 184
	CqlParserRULE_kwBegin                      = 185
	CqlParserRULE_kwBy                         = 186
	CqlParserRULE_kwCalled                     = 187
	CqlParserRULE_kwClustering                 = 188
	CqlParserRULE_kwCompact                    = 189
	CqlParserRULE_kwContains                   = 190
	CqlParserRULE_kwCreate                     = 191
	CqlParserRULE_kwDelete                     = 192
	CqlParserRULE_kwDesc                       = 193
	CqlParserRULE_kwDescibe                    = 194
	CqlParserRULE_kwDistinct                   = 195
	CqlParserRULE_kwDrop                       = 196
	CqlParserRULE_kwDurableWrites              = 197
	CqlParserRULE_kwEntries                    = 198
	CqlParserRULE_kwExecute                    = 199
	CqlParserRULE_kwExists                     = 200
	CqlParserRULE_kwFiltering                  = 201
	CqlParserRULE_kwFinalfunc                  = 202
	CqlParserRULE_kwFrom                       = 203
	CqlParserRULE_kwFull                       = 204
	CqlParserRULE_kwFunction                   = 205
	CqlParserRULE_kwFunctions                  = 206
	CqlParserRULE_kwGrant                      = 207
	CqlParserRULE_kwIf                         = 208
	CqlParserRULE_kwIn                         = 209
	CqlParserRULE_kwIndex                      = 210
	CqlParserRULE_kwInitcond                   = 211
	CqlParserRULE_kwInput                      = 212
	CqlParserRULE_kwInsert                     = 213
	CqlParserRULE_kwInto                       = 214
	CqlParserRULE_kwIs                         = 215
	CqlParserRULE_kwJson                       = 216
	CqlParserRULE_kwKey                        = 217
	CqlParserRULE_kwKeys                       = 218
	CqlParserRULE_kwKeyspace                   = 219
	CqlParserRULE_kwKeyspaces                  = 220
	CqlParserRULE_kwLanguage                   = 221
	CqlParserRULE_kwLimit                      = 222
	CqlParserRULE_kwList                       = 223
	CqlParserRULE_kwLogged                     = 224
	CqlParserRULE_kwLogin                      = 225
	CqlParserRULE_kwMaterialized               = 226
	CqlParserRULE_kwModify                     = 227
	CqlParserRULE_kwNosuperuser                = 228
	CqlParserRULE_kwNorecursive                = 229
	CqlParserRULE_kwNot                        = 230
	CqlParserRULE_kwNull                       = 231
	CqlParserRULE_kwOf                         = 232
	CqlParserRULE_kwOn                         = 233
	CqlParserRULE_kwOptions                    = 234
	CqlParserRULE_kwOr                         = 235
	CqlParserRULE_kwOrder                      = 236
	CqlParserRULE_kwPassword                   = 237
	CqlParserRULE_kwPrimary                    = 238
	CqlParserRULE_kwRename                     = 239
	CqlParserRULE_kwReplace                    = 240
	CqlParserRULE_kwReplication                = 241
	CqlParserRULE_kwReturns                    = 242
	CqlParserRULE_kwRole                       = 243
	CqlParserRULE_kwRoles                      = 244
	CqlParserRULE_kwSelect                     = 245
	CqlParserRULE_kwSet                        = 246
	CqlParserRULE_kwSfunc                      = 247
	CqlParserRULE_kwStorage                    = 248
	CqlParserRULE_kwStype                      = 249
	CqlParserRULE_kwSuperuser                  = 250
	CqlParserRULE_kwTable                      = 251
	CqlParserRULE_kwTimestamp                  = 252
	CqlParserRULE_kwTo                         = 253
	CqlParserRULE_kwTrigger                    = 254
	CqlParserRULE_kwTruncate                   = 255
	CqlParserRULE_kwTtl                        = 256
	CqlParserRULE_kwType                       = 257
	CqlParserRULE_kwUnlogged                   = 258
	CqlParserRULE_kwUpdate                     = 259
	CqlParserRULE_kwUse                        = 260
	CqlParserRULE_kwUser                       = 261
	CqlParserRULE_kwUsers                      = 262
	CqlParserRULE_kwUsing                      = 263
	CqlParserRULE_kwValues                     = 264
	CqlParserRULE_kwView                       = 265
	CqlParserRULE_kwWhere                      = 266
	CqlParserRULE_kwWith                       = 267
	CqlParserRULE_kwRevoke                     = 268
	CqlParserRULE_eof                          = 269
	CqlParserRULE_syntaxBracketLr              = 270
	CqlParserRULE_syntaxBracketRr              = 271
	CqlParserRULE_syntaxBracketLc              = 272
	CqlParserRULE_syntaxBracketRc              = 273
	CqlParserRULE_syntaxBracketLa              = 274
	CqlParserRULE_syntaxBracketRa              = 275
	CqlParserRULE_syntaxBracketLs              = 276
	CqlParserRULE_syntaxBracketRs              = 277
	CqlParserRULE_syntaxComma                  = 278
	CqlParserRULE_syntaxColon                  = 279
)

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

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

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

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

func NewEmptyRootContext() *RootContext {
	var p = new(RootContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_root
	return p
}

func (*RootContext) IsRootContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_root

	return p
}

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

func (s *RootContext) Eof() IEofContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEofContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IEofContext)
}

func (s *RootContext) Cqls() ICqlsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICqlsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICqlsContext)
}

func (s *RootContext) MINUSMINUS() antlr.TerminalNode {
	return s.GetToken(CqlParserMINUSMINUS, 0)
}

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

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

func (s *RootContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterRoot(s)
	}
}

func (s *RootContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitRoot(s)
	}
}

func (p *CqlParser) Root() (localctx IRootContext) {
	this := p
	_ = this

	localctx = NewRootContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 0, CqlParserRULE_root)
	var _la int

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

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

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

	if (((_la-8)&-(0x1f+1)) == 0 && ((1<<uint((_la-8)))&((1<<(CqlParserSEMI-8))|(1<<(CqlParserK_ALTER-8))|(1<<(CqlParserK_APPLY-8))|(1<<(CqlParserK_BEGIN-8)))) != 0) || (((_la-43)&-(0x1f+1)) == 0 && ((1<<uint((_la-43)))&((1<<(CqlParserK_CREATE-43))|(1<<(CqlParserK_DELETE-43))|(1<<(CqlParserK_DROP-43))|(1<<(CqlParserK_GRANT-43))|(1<<(CqlParserK_INSERT-43)))) != 0) || (((_la-108)&-(0x1f+1)) == 0 && ((1<<uint((_la-108)))&((1<<(CqlParserK_REVOKE-108))|(1<<(CqlParserK_SELECT-108))|(1<<(CqlParserK_TRUNCATE-108))|(1<<(CqlParserK_UPDATE-108))|(1<<(CqlParserK_USE-108)))) != 0) || _la == CqlParserK_LIST {
		{
			p.SetState(560)
			p.Cqls()
		}

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

	if _la == CqlParserMINUSMINUS {
		{
			p.SetState(563)
			p.Match(CqlParserMINUSMINUS)
		}

	}
	{
		p.SetState(566)
		p.Eof()
	}

	return localctx
}

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

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

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

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

func NewEmptyCqlsContext() *CqlsContext {
	var p = new(CqlsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_cqls
	return p
}

func (*CqlsContext) IsCqlsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_cqls

	return p
}

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

func (s *CqlsContext) AllCql() []ICqlContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICqlContext)(nil)).Elem())
	var tst = make([]ICqlContext, len(ts))

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

	return tst
}

func (s *CqlsContext) Cql(i int) ICqlContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICqlContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICqlContext)
}

func (s *CqlsContext) AllEmpty_() []IEmpty_Context {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IEmpty_Context)(nil)).Elem())
	var tst = make([]IEmpty_Context, len(ts))

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

	return tst
}

func (s *CqlsContext) Empty_(i int) IEmpty_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IEmpty_Context)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IEmpty_Context)
}

func (s *CqlsContext) AllStatementSeparator() []IStatementSeparatorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IStatementSeparatorContext)(nil)).Elem())
	var tst = make([]IStatementSeparatorContext, len(ts))

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

	return tst
}

func (s *CqlsContext) StatementSeparator(i int) IStatementSeparatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementSeparatorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IStatementSeparatorContext)
}

func (s *CqlsContext) AllMINUSMINUS() []antlr.TerminalNode {
	return s.GetTokens(CqlParserMINUSMINUS)
}

func (s *CqlsContext) MINUSMINUS(i int) antlr.TerminalNode {
	return s.GetToken(CqlParserMINUSMINUS, i)
}

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

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

func (s *CqlsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCqls(s)
	}
}

func (s *CqlsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCqls(s)
	}
}

func (p *CqlParser) Cqls() (localctx ICqlsContext) {
	this := p
	_ = this

	localctx = NewCqlsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 2, CqlParserRULE_cqls)
	var _la int

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

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

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(575)
			p.GetErrorHandler().Sync(p)

			switch p.GetTokenStream().LA(1) {
			case CqlParserK_ALTER, CqlParserK_APPLY, CqlParserK_BEGIN, CqlParserK_CREATE, CqlParserK_DELETE, CqlParserK_DROP, CqlParserK_GRANT, CqlParserK_INSERT, CqlParserK_REVOKE, CqlParserK_SELECT, CqlParserK_TRUNCATE, CqlParserK_UPDATE, CqlParserK_USE, CqlParserK_LIST:
				{
					p.SetState(568)
					p.Cql()
				}
				p.SetState(570)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == CqlParserMINUSMINUS {
					{
						p.SetState(569)
						p.Match(CqlParserMINUSMINUS)
					}

				}
				{
					p.SetState(572)
					p.StatementSeparator()
				}

			case CqlParserSEMI:
				{
					p.SetState(574)
					p.Empty_()
				}

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

		}
		p.SetState(579)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 4, p.GetParserRuleContext())
	}
	p.SetState(588)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserK_ALTER, CqlParserK_APPLY, CqlParserK_BEGIN, CqlParserK_CREATE, CqlParserK_DELETE, CqlParserK_DROP, CqlParserK_GRANT, CqlParserK_INSERT, CqlParserK_REVOKE, CqlParserK_SELECT, CqlParserK_TRUNCATE, CqlParserK_UPDATE, CqlParserK_USE, CqlParserK_LIST:
		{
			p.SetState(580)
			p.Cql()
		}
		p.SetState(585)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 6, p.GetParserRuleContext()) == 1 {
			p.SetState(582)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == CqlParserMINUSMINUS {
				{
					p.SetState(581)
					p.Match(CqlParserMINUSMINUS)
				}

			}
			{
				p.SetState(584)
				p.StatementSeparator()
			}

		}

	case CqlParserSEMI:
		{
			p.SetState(587)
			p.Empty_()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyStatementSeparatorContext() *StatementSeparatorContext {
	var p = new(StatementSeparatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_statementSeparator
	return p
}

func (*StatementSeparatorContext) IsStatementSeparatorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_statementSeparator

	return p
}

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

func (s *StatementSeparatorContext) SEMI() antlr.TerminalNode {
	return s.GetToken(CqlParserSEMI, 0)
}

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

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

func (s *StatementSeparatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterStatementSeparator(s)
	}
}

func (s *StatementSeparatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitStatementSeparator(s)
	}
}

func (p *CqlParser) StatementSeparator() (localctx IStatementSeparatorContext) {
	this := p
	_ = this

	localctx = NewStatementSeparatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, CqlParserRULE_statementSeparator)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(590)
		p.Match(CqlParserSEMI)
	}

	return localctx
}

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

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

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

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

func NewEmptyEmpty_Context() *Empty_Context {
	var p = new(Empty_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_empty_
	return p
}

func (*Empty_Context) IsEmpty_Context() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_empty_

	return p
}

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

func (s *Empty_Context) StatementSeparator() IStatementSeparatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStatementSeparatorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStatementSeparatorContext)
}

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

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

func (s *Empty_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterEmpty_(s)
	}
}

func (s *Empty_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitEmpty_(s)
	}
}

func (p *CqlParser) Empty_() (localctx IEmpty_Context) {
	this := p
	_ = this

	localctx = NewEmpty_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 6, CqlParserRULE_empty_)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(592)
		p.StatementSeparator()
	}

	return localctx
}

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

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

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

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

func NewEmptyCqlContext() *CqlContext {
	var p = new(CqlContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_cql
	return p
}

func (*CqlContext) IsCqlContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_cql

	return p
}

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

func (s *CqlContext) AlterKeyspace() IAlterKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterKeyspaceContext)
}

func (s *CqlContext) AlterMaterializedView() IAlterMaterializedViewContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterMaterializedViewContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterMaterializedViewContext)
}

func (s *CqlContext) AlterRole() IAlterRoleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterRoleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterRoleContext)
}

func (s *CqlContext) AlterTable() IAlterTableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTableContext)
}

func (s *CqlContext) AlterType() IAlterTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTypeContext)
}

func (s *CqlContext) AlterUser() IAlterUserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterUserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterUserContext)
}

func (s *CqlContext) ApplyBatch() IApplyBatchContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IApplyBatchContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IApplyBatchContext)
}

func (s *CqlContext) CreateAggregate() ICreateAggregateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreateAggregateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreateAggregateContext)
}

func (s *CqlContext) CreateFunction() ICreateFunctionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreateFunctionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreateFunctionContext)
}

func (s *CqlContext) CreateIndex() ICreateIndexContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreateIndexContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreateIndexContext)
}

func (s *CqlContext) CreateKeyspace() ICreateKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreateKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreateKeyspaceContext)
}

func (s *CqlContext) CreateMaterializedView() ICreateMaterializedViewContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreateMaterializedViewContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreateMaterializedViewContext)
}

func (s *CqlContext) CreateRole() ICreateRoleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreateRoleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreateRoleContext)
}

func (s *CqlContext) CreateTable() ICreateTableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreateTableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreateTableContext)
}

func (s *CqlContext) CreateTrigger() ICreateTriggerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreateTriggerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreateTriggerContext)
}

func (s *CqlContext) CreateType() ICreateTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreateTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreateTypeContext)
}

func (s *CqlContext) CreateUser() ICreateUserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreateUserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreateUserContext)
}

func (s *CqlContext) Delete_() IDelete_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDelete_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDelete_Context)
}

func (s *CqlContext) DropAggregate() IDropAggregateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDropAggregateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDropAggregateContext)
}

func (s *CqlContext) DropFunction() IDropFunctionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDropFunctionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDropFunctionContext)
}

func (s *CqlContext) DropIndex() IDropIndexContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDropIndexContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDropIndexContext)
}

func (s *CqlContext) DropKeyspace() IDropKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDropKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDropKeyspaceContext)
}

func (s *CqlContext) DropMaterializedView() IDropMaterializedViewContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDropMaterializedViewContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDropMaterializedViewContext)
}

func (s *CqlContext) DropRole() IDropRoleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDropRoleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDropRoleContext)
}

func (s *CqlContext) DropTable() IDropTableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDropTableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDropTableContext)
}

func (s *CqlContext) DropTrigger() IDropTriggerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDropTriggerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDropTriggerContext)
}

func (s *CqlContext) DropType() IDropTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDropTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDropTypeContext)
}

func (s *CqlContext) DropUser() IDropUserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDropUserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDropUserContext)
}

func (s *CqlContext) Grant() IGrantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IGrantContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IGrantContext)
}

func (s *CqlContext) Insert() IInsertContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInsertContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInsertContext)
}

func (s *CqlContext) ListPermissions() IListPermissionsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IListPermissionsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IListPermissionsContext)
}

func (s *CqlContext) ListRoles() IListRolesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IListRolesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IListRolesContext)
}

func (s *CqlContext) Revoke() IRevokeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRevokeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRevokeContext)
}

func (s *CqlContext) Select_() ISelect_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelect_Context)
}

func (s *CqlContext) Truncate() ITruncateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITruncateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITruncateContext)
}

func (s *CqlContext) Update() IUpdateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUpdateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUpdateContext)
}

func (s *CqlContext) Use_() IUse_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUse_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUse_Context)
}

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

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

func (s *CqlContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCql(s)
	}
}

func (s *CqlContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCql(s)
	}
}

func (p *CqlParser) Cql() (localctx ICqlContext) {
	this := p
	_ = this

	localctx = NewCqlContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 8, CqlParserRULE_cql)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(595)
			p.AlterMaterializedView()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(596)
			p.AlterRole()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(597)
			p.AlterTable()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(598)
			p.AlterType()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(599)
			p.AlterUser()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(600)
			p.ApplyBatch()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(601)
			p.CreateAggregate()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(602)
			p.CreateFunction()
		}

	case 10:
		p.EnterOuterAlt(localctx, 10)
		{
			p.SetState(603)
			p.CreateIndex()
		}

	case 11:
		p.EnterOuterAlt(localctx, 11)
		{
			p.SetState(604)
			p.CreateKeyspace()
		}

	case 12:
		p.EnterOuterAlt(localctx, 12)
		{
			p.SetState(605)
			p.CreateMaterializedView()
		}

	case 13:
		p.EnterOuterAlt(localctx, 13)
		{
			p.SetState(606)
			p.CreateRole()
		}

	case 14:
		p.EnterOuterAlt(localctx, 14)
		{
			p.SetState(607)
			p.CreateTable()
		}

	case 15:
		p.EnterOuterAlt(localctx, 15)
		{
			p.SetState(608)
			p.CreateTrigger()
		}

	case 16:
		p.EnterOuterAlt(localctx, 16)
		{
			p.SetState(609)
			p.CreateType()
		}

	case 17:
		p.EnterOuterAlt(localctx, 17)
		{
			p.SetState(610)
			p.CreateUser()
		}

	case 18:
		p.EnterOuterAlt(localctx, 18)
		{
			p.SetState(611)
			p.Delete_()
		}

	case 19:
		p.EnterOuterAlt(localctx, 19)
		{
			p.SetState(612)
			p.DropAggregate()
		}

	case 20:
		p.EnterOuterAlt(localctx, 20)
		{
			p.SetState(613)
			p.DropFunction()
		}

	case 21:
		p.EnterOuterAlt(localctx, 21)
		{
			p.SetState(614)
			p.DropIndex()
		}

	case 22:
		p.EnterOuterAlt(localctx, 22)
		{
			p.SetState(615)
			p.DropKeyspace()
		}

	case 23:
		p.EnterOuterAlt(localctx, 23)
		{
			p.SetState(616)
			p.DropMaterializedView()
		}

	case 24:
		p.EnterOuterAlt(localctx, 24)
		{
			p.SetState(617)
			p.DropRole()
		}

	case 25:
		p.EnterOuterAlt(localctx, 25)
		{
			p.SetState(618)
			p.DropTable()
		}

	case 26:
		p.EnterOuterAlt(localctx, 26)
		{
			p.SetState(619)
			p.DropTrigger()
		}

	case 27:
		p.EnterOuterAlt(localctx, 27)
		{
			p.SetState(620)
			p.DropType()
		}

	case 28:
		p.EnterOuterAlt(localctx, 28)
		{
			p.SetState(621)
			p.DropUser()
		}

	case 29:
		p.EnterOuterAlt(localctx, 29)
		{
			p.SetState(622)
			p.Grant()
		}

	case 30:
		p.EnterOuterAlt(localctx, 30)
		{
			p.SetState(623)
			p.Insert()
		}

	case 31:
		p.EnterOuterAlt(localctx, 31)
		{
			p.SetState(624)
			p.ListPermissions()
		}

	case 32:
		p.EnterOuterAlt(localctx, 32)
		{
			p.SetState(625)
			p.ListRoles()
		}

	case 33:
		p.EnterOuterAlt(localctx, 33)
		{
			p.SetState(626)
			p.Revoke()
		}

	case 34:
		p.EnterOuterAlt(localctx, 34)
		{
			p.SetState(627)
			p.Select_()
		}

	case 35:
		p.EnterOuterAlt(localctx, 35)
		{
			p.SetState(628)
			p.Truncate()
		}

	case 36:
		p.EnterOuterAlt(localctx, 36)
		{
			p.SetState(629)
			p.Update()
		}

	case 37:
		p.EnterOuterAlt(localctx, 37)
		{
			p.SetState(630)
			p.Use_()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyRevokeContext() *RevokeContext {
	var p = new(RevokeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_revoke
	return p
}

func (*RevokeContext) IsRevokeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_revoke

	return p
}

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

func (s *RevokeContext) KwRevoke() IKwRevokeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwRevokeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwRevokeContext)
}

func (s *RevokeContext) Priviledge() IPriviledgeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPriviledgeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPriviledgeContext)
}

func (s *RevokeContext) KwOn() IKwOnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwOnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwOnContext)
}

func (s *RevokeContext) Resource() IResourceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResourceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IResourceContext)
}

func (s *RevokeContext) KwFrom() IKwFromContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwFromContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwFromContext)
}

func (s *RevokeContext) Role() IRoleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRoleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRoleContext)
}

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

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

func (s *RevokeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterRevoke(s)
	}
}

func (s *RevokeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitRevoke(s)
	}
}

func (p *CqlParser) Revoke() (localctx IRevokeContext) {
	this := p
	_ = this

	localctx = NewRevokeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 10, CqlParserRULE_revoke)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(633)
		p.KwRevoke()
	}
	{
		p.SetState(634)
		p.Priviledge()
	}
	{
		p.SetState(635)
		p.KwOn()
	}
	{
		p.SetState(636)
		p.Resource()
	}
	{
		p.SetState(637)
		p.KwFrom()
	}
	{
		p.SetState(638)
		p.Role()
	}

	return localctx
}

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

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

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

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

func NewEmptyListUsersContext() *ListUsersContext {
	var p = new(ListUsersContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_listUsers
	return p
}

func (*ListUsersContext) IsListUsersContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_listUsers

	return p
}

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

func (s *ListUsersContext) KwList() IKwListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwListContext)
}

func (s *ListUsersContext) KwUsers() IKwUsersContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwUsersContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwUsersContext)
}

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

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

func (s *ListUsersContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterListUsers(s)
	}
}

func (s *ListUsersContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitListUsers(s)
	}
}

func (p *CqlParser) ListUsers() (localctx IListUsersContext) {
	this := p
	_ = this

	localctx = NewListUsersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 12, CqlParserRULE_listUsers)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(640)
		p.KwList()
	}
	{
		p.SetState(641)
		p.KwUsers()
	}

	return localctx
}

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

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

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

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

func NewEmptyListRolesContext() *ListRolesContext {
	var p = new(ListRolesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_listRoles
	return p
}

func (*ListRolesContext) IsListRolesContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_listRoles

	return p
}

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

func (s *ListRolesContext) KwList() IKwListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwListContext)
}

func (s *ListRolesContext) KwRoles() IKwRolesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwRolesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwRolesContext)
}

func (s *ListRolesContext) KwOf() IKwOfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwOfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwOfContext)
}

func (s *ListRolesContext) Role() IRoleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRoleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRoleContext)
}

func (s *ListRolesContext) KwNorecursive() IKwNorecursiveContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwNorecursiveContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwNorecursiveContext)
}

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

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

func (s *ListRolesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterListRoles(s)
	}
}

func (s *ListRolesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitListRoles(s)
	}
}

func (p *CqlParser) ListRoles() (localctx IListRolesContext) {
	this := p
	_ = this

	localctx = NewListRolesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 14, CqlParserRULE_listRoles)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(643)
		p.KwList()
	}
	{
		p.SetState(644)
		p.KwRoles()
	}
	p.SetState(648)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_OF {
		{
			p.SetState(645)
			p.KwOf()
		}
		{
			p.SetState(646)
			p.Role()
		}

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

	if _la == CqlParserK_NORECURSIVE {
		{
			p.SetState(650)
			p.KwNorecursive()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyListPermissionsContext() *ListPermissionsContext {
	var p = new(ListPermissionsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_listPermissions
	return p
}

func (*ListPermissionsContext) IsListPermissionsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_listPermissions

	return p
}

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

func (s *ListPermissionsContext) KwList() IKwListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwListContext)
}

func (s *ListPermissionsContext) Priviledge() IPriviledgeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPriviledgeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPriviledgeContext)
}

func (s *ListPermissionsContext) KwOn() IKwOnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwOnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwOnContext)
}

func (s *ListPermissionsContext) Resource() IResourceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResourceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IResourceContext)
}

func (s *ListPermissionsContext) KwOf() IKwOfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwOfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwOfContext)
}

func (s *ListPermissionsContext) Role() IRoleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRoleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRoleContext)
}

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

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

func (s *ListPermissionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterListPermissions(s)
	}
}

func (s *ListPermissionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitListPermissions(s)
	}
}

func (p *CqlParser) ListPermissions() (localctx IListPermissionsContext) {
	this := p
	_ = this

	localctx = NewListPermissionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, CqlParserRULE_listPermissions)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(653)
		p.KwList()
	}
	{
		p.SetState(654)
		p.Priviledge()
	}
	p.SetState(658)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_ON {
		{
			p.SetState(655)
			p.KwOn()
		}
		{
			p.SetState(656)
			p.Resource()
		}

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

	if _la == CqlParserK_OF {
		{
			p.SetState(660)
			p.KwOf()
		}
		{
			p.SetState(661)
			p.Role()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyGrantContext() *GrantContext {
	var p = new(GrantContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_grant
	return p
}

func (*GrantContext) IsGrantContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_grant

	return p
}

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

func (s *GrantContext) KwGrant() IKwGrantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwGrantContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwGrantContext)
}

func (s *GrantContext) Priviledge() IPriviledgeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPriviledgeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPriviledgeContext)
}

func (s *GrantContext) KwOn() IKwOnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwOnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwOnContext)
}

func (s *GrantContext) Resource() IResourceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResourceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IResourceContext)
}

func (s *GrantContext) KwTo() IKwToContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwToContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwToContext)
}

func (s *GrantContext) Role() IRoleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRoleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRoleContext)
}

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

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

func (s *GrantContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterGrant(s)
	}
}

func (s *GrantContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitGrant(s)
	}
}

func (p *CqlParser) Grant() (localctx IGrantContext) {
	this := p
	_ = this

	localctx = NewGrantContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, CqlParserRULE_grant)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(665)
		p.KwGrant()
	}
	{
		p.SetState(666)
		p.Priviledge()
	}
	{
		p.SetState(667)
		p.KwOn()
	}
	{
		p.SetState(668)
		p.Resource()
	}
	{
		p.SetState(669)
		p.KwTo()
	}
	{
		p.SetState(670)
		p.Role()
	}

	return localctx
}

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

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

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

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

func NewEmptyPriviledgeContext() *PriviledgeContext {
	var p = new(PriviledgeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_priviledge
	return p
}

func (*PriviledgeContext) IsPriviledgeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_priviledge

	return p
}

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

func (s *PriviledgeContext) KwAll() IKwAllContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAllContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAllContext)
}

func (s *PriviledgeContext) KwAllPermissions() IKwAllPermissionsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAllPermissionsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAllPermissionsContext)
}

func (s *PriviledgeContext) KwAlter() IKwAlterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAlterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAlterContext)
}

func (s *PriviledgeContext) KwAuthorize() IKwAuthorizeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAuthorizeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAuthorizeContext)
}

func (s *PriviledgeContext) KwDescibe() IKwDescibeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDescibeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDescibeContext)
}

func (s *PriviledgeContext) KwExecute() IKwExecuteContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwExecuteContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwExecuteContext)
}

func (s *PriviledgeContext) KwCreate() IKwCreateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwCreateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwCreateContext)
}

func (s *PriviledgeContext) KwDrop() IKwDropContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDropContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDropContext)
}

func (s *PriviledgeContext) KwModify() IKwModifyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwModifyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwModifyContext)
}

func (s *PriviledgeContext) KwSelect() IKwSelectContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwSelectContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwSelectContext)
}

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

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

func (s *PriviledgeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterPriviledge(s)
	}
}

func (s *PriviledgeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitPriviledge(s)
	}
}

func (p *CqlParser) Priviledge() (localctx IPriviledgeContext) {
	this := p
	_ = this

	localctx = NewPriviledgeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 20, CqlParserRULE_priviledge)

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

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

	switch p.GetTokenStream().LA(1) {
	case CqlParserK_ALL:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(674)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 13, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(672)
				p.KwAll()
			}

		case 2:
			{
				p.SetState(673)
				p.KwAllPermissions()
			}

		}

	case CqlParserK_ALTER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(676)
			p.KwAlter()
		}

	case CqlParserK_AUTHORIZE:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(677)
			p.KwAuthorize()
		}

	case CqlParserK_DESCRIBE:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(678)
			p.KwDescibe()
		}

	case CqlParserK_EXECUTE:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(679)
			p.KwExecute()
		}

	case CqlParserK_CREATE:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(680)
			p.KwCreate()
		}

	case CqlParserK_DROP:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(681)
			p.KwDrop()
		}

	case CqlParserK_MODIFY:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(682)
			p.KwModify()
		}

	case CqlParserK_SELECT:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(683)
			p.KwSelect()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyResourceContext() *ResourceContext {
	var p = new(ResourceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_resource
	return p
}

func (*ResourceContext) IsResourceContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_resource

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IKwAllContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IKwFunctionsContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IKwInContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IKwKeyspaceContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IKwFunctionContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IFunction_Context)
}

func (s *ResourceContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IKwKeyspacesContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ITableContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IKwTableContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IKwRolesContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IKwRoleContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IRoleContext)
}

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

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

func (s *ResourceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterResource(s)
	}
}

func (s *ResourceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitResource(s)
	}
}

func (p *CqlParser) Resource() (localctx IResourceContext) {
	this := p
	_ = this

	localctx = NewResourceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 22, CqlParserRULE_resource)
	var _la int

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

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

	p.SetState(724)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 18, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(686)
			p.KwAll()
		}
		{
			p.SetState(687)
			p.KwFunctions()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(689)
			p.KwAll()
		}
		{
			p.SetState(690)
			p.KwFunctions()
		}
		{
			p.SetState(691)
			p.KwIn()
		}
		{
			p.SetState(692)
			p.KwKeyspace()
		}
		{
			p.SetState(693)
			p.Keyspace()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(695)
			p.KwFunction()
		}
		p.SetState(699)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 15, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(696)
				p.Keyspace()
			}
			{
				p.SetState(697)
				p.Match(CqlParserDOT)
			}

		}
		{
			p.SetState(701)
			p.Function_()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(703)
			p.KwAll()
		}
		{
			p.SetState(704)
			p.KwKeyspaces()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(706)
			p.KwKeyspace()
		}
		{
			p.SetState(707)
			p.Keyspace()
		}

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

		if _la == CqlParserK_TABLE {
			{
				p.SetState(709)
				p.KwTable()
			}

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

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 17, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(712)
				p.Keyspace()
			}
			{
				p.SetState(713)
				p.Match(CqlParserDOT)
			}

		}
		{
			p.SetState(717)
			p.Table()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(718)
			p.KwAll()
		}
		{
			p.SetState(719)
			p.KwRoles()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(721)
			p.KwRole()
		}
		{
			p.SetState(722)
			p.Role()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyCreateUserContext() *CreateUserContext {
	var p = new(CreateUserContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_createUser
	return p
}

func (*CreateUserContext) IsCreateUserContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_createUser

	return p
}

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

func (s *CreateUserContext) KwCreate() IKwCreateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwCreateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwCreateContext)
}

func (s *CreateUserContext) KwUser() IKwUserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwUserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwUserContext)
}

func (s *CreateUserContext) User() IUserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUserContext)
}

func (s *CreateUserContext) KwWith() IKwWithContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwWithContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwWithContext)
}

func (s *CreateUserContext) KwPassword() IKwPasswordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwPasswordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwPasswordContext)
}

func (s *CreateUserContext) StringLiteral() IStringLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStringLiteralContext)
}

func (s *CreateUserContext) IfNotExist() IIfNotExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfNotExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfNotExistContext)
}

func (s *CreateUserContext) KwSuperuser() IKwSuperuserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwSuperuserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwSuperuserContext)
}

func (s *CreateUserContext) KwNosuperuser() IKwNosuperuserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwNosuperuserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwNosuperuserContext)
}

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

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

func (s *CreateUserContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCreateUser(s)
	}
}

func (s *CreateUserContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCreateUser(s)
	}
}

func (p *CqlParser) CreateUser() (localctx ICreateUserContext) {
	this := p
	_ = this

	localctx = NewCreateUserContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, CqlParserRULE_createUser)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(726)
		p.KwCreate()
	}
	{
		p.SetState(727)
		p.KwUser()
	}
	p.SetState(729)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(728)
			p.IfNotExist()
		}

	}
	{
		p.SetState(731)
		p.User()
	}
	{
		p.SetState(732)
		p.KwWith()
	}
	{
		p.SetState(733)
		p.KwPassword()
	}
	{
		p.SetState(734)
		p.StringLiteral()
	}
	p.SetState(737)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserK_SUPERUSER:
		{
			p.SetState(735)
			p.KwSuperuser()
		}

	case CqlParserK_NOSUPERUSER:
		{
			p.SetState(736)
			p.KwNosuperuser()
		}

	case CqlParserEOF, CqlParserSEMI, CqlParserMINUSMINUS:

	default:
	}

	return localctx
}

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

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

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

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

func NewEmptyCreateRoleContext() *CreateRoleContext {
	var p = new(CreateRoleContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_createRole
	return p
}

func (*CreateRoleContext) IsCreateRoleContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_createRole

	return p
}

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

func (s *CreateRoleContext) KwCreate() IKwCreateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwCreateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwCreateContext)
}

func (s *CreateRoleContext) KwRole() IKwRoleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwRoleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwRoleContext)
}

func (s *CreateRoleContext) Role() IRoleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRoleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRoleContext)
}

func (s *CreateRoleContext) IfNotExist() IIfNotExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfNotExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfNotExistContext)
}

func (s *CreateRoleContext) RoleWith() IRoleWithContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRoleWithContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRoleWithContext)
}

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

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

func (s *CreateRoleContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCreateRole(s)
	}
}

func (s *CreateRoleContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCreateRole(s)
	}
}

func (p *CqlParser) CreateRole() (localctx ICreateRoleContext) {
	this := p
	_ = this

	localctx = NewCreateRoleContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 26, CqlParserRULE_createRole)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(739)
		p.KwCreate()
	}
	{
		p.SetState(740)
		p.KwRole()
	}
	p.SetState(742)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(741)
			p.IfNotExist()
		}

	}
	{
		p.SetState(744)
		p.Role()
	}
	p.SetState(746)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_WITH {
		{
			p.SetState(745)
			p.RoleWith()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyCreateTypeContext() *CreateTypeContext {
	var p = new(CreateTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_createType
	return p
}

func (*CreateTypeContext) IsCreateTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_createType

	return p
}

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

func (s *CreateTypeContext) KwCreate() IKwCreateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwCreateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwCreateContext)
}

func (s *CreateTypeContext) KwType() IKwTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwTypeContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

func (s *CreateTypeContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *CreateTypeContext) TypeMemberColumnList() ITypeMemberColumnListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeMemberColumnListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITypeMemberColumnListContext)
}

func (s *CreateTypeContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *CreateTypeContext) IfNotExist() IIfNotExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfNotExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfNotExistContext)
}

func (s *CreateTypeContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *CreateTypeContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

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

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

func (s *CreateTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCreateType(s)
	}
}

func (s *CreateTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCreateType(s)
	}
}

func (p *CqlParser) CreateType() (localctx ICreateTypeContext) {
	this := p
	_ = this

	localctx = NewCreateTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, CqlParserRULE_createType)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(748)
		p.KwCreate()
	}
	{
		p.SetState(749)
		p.KwType()
	}
	p.SetState(751)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(750)
			p.IfNotExist()
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 24, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(753)
			p.Keyspace()
		}
		{
			p.SetState(754)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(758)
		p.Type_()
	}
	{
		p.SetState(759)
		p.SyntaxBracketLr()
	}
	{
		p.SetState(760)
		p.TypeMemberColumnList()
	}
	{
		p.SetState(761)
		p.SyntaxBracketRr()
	}

	return localctx
}

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

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

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

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

func NewEmptyTypeMemberColumnListContext() *TypeMemberColumnListContext {
	var p = new(TypeMemberColumnListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_typeMemberColumnList
	return p
}

func (*TypeMemberColumnListContext) IsTypeMemberColumnListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_typeMemberColumnList

	return p
}

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

func (s *TypeMemberColumnListContext) AllColumn() []IColumnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumnContext)(nil)).Elem())
	var tst = make([]IColumnContext, len(ts))

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

	return tst
}

func (s *TypeMemberColumnListContext) Column(i int) IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *TypeMemberColumnListContext) AllDataType() []IDataTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDataTypeContext)(nil)).Elem())
	var tst = make([]IDataTypeContext, len(ts))

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

	return tst
}

func (s *TypeMemberColumnListContext) DataType(i int) IDataTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDataTypeContext)
}

func (s *TypeMemberColumnListContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

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

	return tst
}

func (s *TypeMemberColumnListContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

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

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

func (s *TypeMemberColumnListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterTypeMemberColumnList(s)
	}
}

func (s *TypeMemberColumnListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitTypeMemberColumnList(s)
	}
}

func (p *CqlParser) TypeMemberColumnList() (localctx ITypeMemberColumnListContext) {
	this := p
	_ = this

	localctx = NewTypeMemberColumnListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, CqlParserRULE_typeMemberColumnList)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(763)
		p.Column()
	}
	{
		p.SetState(764)
		p.DataType()
	}
	p.SetState(771)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(765)
			p.SyntaxComma()
		}
		{
			p.SetState(766)
			p.Column()
		}
		{
			p.SetState(767)
			p.DataType()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyCreateTriggerContext() *CreateTriggerContext {
	var p = new(CreateTriggerContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_createTrigger
	return p
}

func (*CreateTriggerContext) IsCreateTriggerContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_createTrigger

	return p
}

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

func (s *CreateTriggerContext) KwCreate() IKwCreateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwCreateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwCreateContext)
}

func (s *CreateTriggerContext) KwTrigger() IKwTriggerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwTriggerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwTriggerContext)
}

func (s *CreateTriggerContext) Trigger() ITriggerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITriggerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITriggerContext)
}

func (s *CreateTriggerContext) KwUsing() IKwUsingContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwUsingContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwUsingContext)
}

func (s *CreateTriggerContext) TriggerClass() ITriggerClassContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITriggerClassContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITriggerClassContext)
}

func (s *CreateTriggerContext) IfNotExist() IIfNotExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfNotExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfNotExistContext)
}

func (s *CreateTriggerContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *CreateTriggerContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

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

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

func (s *CreateTriggerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCreateTrigger(s)
	}
}

func (s *CreateTriggerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCreateTrigger(s)
	}
}

func (p *CqlParser) CreateTrigger() (localctx ICreateTriggerContext) {
	this := p
	_ = this

	localctx = NewCreateTriggerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, CqlParserRULE_createTrigger)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(774)
		p.KwCreate()
	}
	{
		p.SetState(775)
		p.KwTrigger()
	}
	p.SetState(777)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(776)
			p.IfNotExist()
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 27, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(779)
			p.Keyspace()
		}
		{
			p.SetState(780)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(784)
		p.Trigger()
	}
	{
		p.SetState(785)
		p.KwUsing()
	}
	{
		p.SetState(786)
		p.TriggerClass()
	}

	return localctx
}

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

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

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

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

func NewEmptyCreateMaterializedViewContext() *CreateMaterializedViewContext {
	var p = new(CreateMaterializedViewContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_createMaterializedView
	return p
}

func (*CreateMaterializedViewContext) IsCreateMaterializedViewContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_createMaterializedView

	return p
}

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

func (s *CreateMaterializedViewContext) KwCreate() IKwCreateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwCreateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwCreateContext)
}

func (s *CreateMaterializedViewContext) KwMaterialized() IKwMaterializedContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwMaterializedContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwMaterializedContext)
}

func (s *CreateMaterializedViewContext) KwView() IKwViewContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwViewContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwViewContext)
}

func (s *CreateMaterializedViewContext) MaterializedView() IMaterializedViewContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMaterializedViewContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMaterializedViewContext)
}

func (s *CreateMaterializedViewContext) KwAs() IKwAsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAsContext)
}

func (s *CreateMaterializedViewContext) KwSelect() IKwSelectContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwSelectContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwSelectContext)
}

func (s *CreateMaterializedViewContext) AllColumnList() []IColumnListContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumnListContext)(nil)).Elem())
	var tst = make([]IColumnListContext, len(ts))

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

	return tst
}

func (s *CreateMaterializedViewContext) ColumnList(i int) IColumnListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnListContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumnListContext)
}

func (s *CreateMaterializedViewContext) KwFrom() IKwFromContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwFromContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwFromContext)
}

func (s *CreateMaterializedViewContext) Table() ITableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableContext)
}

func (s *CreateMaterializedViewContext) MaterializedViewWhere() IMaterializedViewWhereContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMaterializedViewWhereContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMaterializedViewWhereContext)
}

func (s *CreateMaterializedViewContext) KwPrimary() IKwPrimaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwPrimaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwPrimaryContext)
}

func (s *CreateMaterializedViewContext) KwKey() IKwKeyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwKeyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwKeyContext)
}

func (s *CreateMaterializedViewContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *CreateMaterializedViewContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *CreateMaterializedViewContext) IfNotExist() IIfNotExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfNotExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfNotExistContext)
}

func (s *CreateMaterializedViewContext) AllKeyspace() []IKeyspaceContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem())
	var tst = make([]IKeyspaceContext, len(ts))

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

	return tst
}

func (s *CreateMaterializedViewContext) Keyspace(i int) IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *CreateMaterializedViewContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(CqlParserDOT)
}

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

func (s *CreateMaterializedViewContext) KwWith() IKwWithContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwWithContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwWithContext)
}

func (s *CreateMaterializedViewContext) MaterializedViewOptions() IMaterializedViewOptionsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMaterializedViewOptionsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMaterializedViewOptionsContext)
}

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

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

func (s *CreateMaterializedViewContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCreateMaterializedView(s)
	}
}

func (s *CreateMaterializedViewContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCreateMaterializedView(s)
	}
}

func (p *CqlParser) CreateMaterializedView() (localctx ICreateMaterializedViewContext) {
	this := p
	_ = this

	localctx = NewCreateMaterializedViewContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 34, CqlParserRULE_createMaterializedView)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(788)
		p.KwCreate()
	}
	{
		p.SetState(789)
		p.KwMaterialized()
	}
	{
		p.SetState(790)
		p.KwView()
	}
	p.SetState(792)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(791)
			p.IfNotExist()
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 29, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(794)
			p.Keyspace()
		}
		{
			p.SetState(795)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(799)
		p.MaterializedView()
	}
	{
		p.SetState(800)
		p.KwAs()
	}
	{
		p.SetState(801)
		p.KwSelect()
	}
	{
		p.SetState(802)
		p.ColumnList()
	}
	{
		p.SetState(803)
		p.KwFrom()
	}
	p.SetState(807)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 30, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(804)
			p.Keyspace()
		}
		{
			p.SetState(805)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(809)
		p.Table()
	}
	{
		p.SetState(810)
		p.MaterializedViewWhere()
	}
	{
		p.SetState(811)
		p.KwPrimary()
	}
	{
		p.SetState(812)
		p.KwKey()
	}
	{
		p.SetState(813)
		p.SyntaxBracketLr()
	}
	{
		p.SetState(814)
		p.ColumnList()
	}
	{
		p.SetState(815)
		p.SyntaxBracketRr()
	}
	p.SetState(819)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_WITH {
		{
			p.SetState(816)
			p.KwWith()
		}
		{
			p.SetState(817)
			p.MaterializedViewOptions()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyMaterializedViewWhereContext() *MaterializedViewWhereContext {
	var p = new(MaterializedViewWhereContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_materializedViewWhere
	return p
}

func (*MaterializedViewWhereContext) IsMaterializedViewWhereContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_materializedViewWhere

	return p
}

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

func (s *MaterializedViewWhereContext) KwWhere() IKwWhereContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwWhereContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwWhereContext)
}

func (s *MaterializedViewWhereContext) ColumnNotNullList() IColumnNotNullListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnNotNullListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumnNotNullListContext)
}

func (s *MaterializedViewWhereContext) KwAnd() IKwAndContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAndContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAndContext)
}

func (s *MaterializedViewWhereContext) RelationElements() IRelationElementsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRelationElementsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRelationElementsContext)
}

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

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

func (s *MaterializedViewWhereContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterMaterializedViewWhere(s)
	}
}

func (s *MaterializedViewWhereContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitMaterializedViewWhere(s)
	}
}

func (p *CqlParser) MaterializedViewWhere() (localctx IMaterializedViewWhereContext) {
	this := p
	_ = this

	localctx = NewMaterializedViewWhereContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, CqlParserRULE_materializedViewWhere)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(821)
		p.KwWhere()
	}
	{
		p.SetState(822)
		p.ColumnNotNullList()
	}
	p.SetState(826)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_AND {
		{
			p.SetState(823)
			p.KwAnd()
		}
		{
			p.SetState(824)
			p.RelationElements()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyColumnNotNullListContext() *ColumnNotNullListContext {
	var p = new(ColumnNotNullListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_columnNotNullList
	return p
}

func (*ColumnNotNullListContext) IsColumnNotNullListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_columnNotNullList

	return p
}

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

func (s *ColumnNotNullListContext) AllColumnNotNull() []IColumnNotNullContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumnNotNullContext)(nil)).Elem())
	var tst = make([]IColumnNotNullContext, len(ts))

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

	return tst
}

func (s *ColumnNotNullListContext) ColumnNotNull(i int) IColumnNotNullContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnNotNullContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumnNotNullContext)
}

func (s *ColumnNotNullListContext) AllKwAnd() []IKwAndContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IKwAndContext)(nil)).Elem())
	var tst = make([]IKwAndContext, len(ts))

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

	return tst
}

func (s *ColumnNotNullListContext) KwAnd(i int) IKwAndContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAndContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IKwAndContext)
}

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

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

func (s *ColumnNotNullListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterColumnNotNullList(s)
	}
}

func (s *ColumnNotNullListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitColumnNotNullList(s)
	}
}

func (p *CqlParser) ColumnNotNullList() (localctx IColumnNotNullListContext) {
	this := p
	_ = this

	localctx = NewColumnNotNullListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, CqlParserRULE_columnNotNullList)

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

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

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(829)
				p.KwAnd()
			}
			{
				p.SetState(830)
				p.ColumnNotNull()
			}

		}
		p.SetState(836)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 33, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyColumnNotNullContext() *ColumnNotNullContext {
	var p = new(ColumnNotNullContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_columnNotNull
	return p
}

func (*ColumnNotNullContext) IsColumnNotNullContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_columnNotNull

	return p
}

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

func (s *ColumnNotNullContext) Column() IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *ColumnNotNullContext) KwIs() IKwIsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwIsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwIsContext)
}

func (s *ColumnNotNullContext) KwNot() IKwNotContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwNotContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwNotContext)
}

func (s *ColumnNotNullContext) KwNull() IKwNullContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwNullContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwNullContext)
}

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

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

func (s *ColumnNotNullContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterColumnNotNull(s)
	}
}

func (s *ColumnNotNullContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitColumnNotNull(s)
	}
}

func (p *CqlParser) ColumnNotNull() (localctx IColumnNotNullContext) {
	this := p
	_ = this

	localctx = NewColumnNotNullContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, CqlParserRULE_columnNotNull)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(837)
		p.Column()
	}
	{
		p.SetState(838)
		p.KwIs()
	}
	{
		p.SetState(839)
		p.KwNot()
	}
	{
		p.SetState(840)
		p.KwNull()
	}

	return localctx
}

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

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

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

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

func NewEmptyMaterializedViewOptionsContext() *MaterializedViewOptionsContext {
	var p = new(MaterializedViewOptionsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_materializedViewOptions
	return p
}

func (*MaterializedViewOptionsContext) IsMaterializedViewOptionsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_materializedViewOptions

	return p
}

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

func (s *MaterializedViewOptionsContext) TableOptions() ITableOptionsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableOptionsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableOptionsContext)
}

func (s *MaterializedViewOptionsContext) KwAnd() IKwAndContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAndContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAndContext)
}

func (s *MaterializedViewOptionsContext) ClusteringOrder() IClusteringOrderContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClusteringOrderContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClusteringOrderContext)
}

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

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

func (s *MaterializedViewOptionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterMaterializedViewOptions(s)
	}
}

func (s *MaterializedViewOptionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitMaterializedViewOptions(s)
	}
}

func (p *CqlParser) MaterializedViewOptions() (localctx IMaterializedViewOptionsContext) {
	this := p
	_ = this

	localctx = NewMaterializedViewOptionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, CqlParserRULE_materializedViewOptions)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(843)
			p.TableOptions()
		}
		{
			p.SetState(844)
			p.KwAnd()
		}
		{
			p.SetState(845)
			p.ClusteringOrder()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(847)
			p.ClusteringOrder()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyCreateKeyspaceContext() *CreateKeyspaceContext {
	var p = new(CreateKeyspaceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_createKeyspace
	return p
}

func (*CreateKeyspaceContext) IsCreateKeyspaceContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_createKeyspace

	return p
}

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

func (s *CreateKeyspaceContext) KwCreate() IKwCreateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwCreateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwCreateContext)
}

func (s *CreateKeyspaceContext) KwKeyspace() IKwKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwKeyspaceContext)
}

func (s *CreateKeyspaceContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *CreateKeyspaceContext) KwWith() IKwWithContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwWithContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwWithContext)
}

func (s *CreateKeyspaceContext) KwReplication() IKwReplicationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwReplicationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwReplicationContext)
}

func (s *CreateKeyspaceContext) OPERATOR_EQ() antlr.TerminalNode {
	return s.GetToken(CqlParserOPERATOR_EQ, 0)
}

func (s *CreateKeyspaceContext) SyntaxBracketLc() ISyntaxBracketLcContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLcContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLcContext)
}

func (s *CreateKeyspaceContext) ReplicationList() IReplicationListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReplicationListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReplicationListContext)
}

func (s *CreateKeyspaceContext) SyntaxBracketRc() ISyntaxBracketRcContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRcContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRcContext)
}

func (s *CreateKeyspaceContext) IfNotExist() IIfNotExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfNotExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfNotExistContext)
}

func (s *CreateKeyspaceContext) KwAnd() IKwAndContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAndContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAndContext)
}

func (s *CreateKeyspaceContext) DurableWrites() IDurableWritesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDurableWritesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDurableWritesContext)
}

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

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

func (s *CreateKeyspaceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCreateKeyspace(s)
	}
}

func (s *CreateKeyspaceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCreateKeyspace(s)
	}
}

func (p *CqlParser) CreateKeyspace() (localctx ICreateKeyspaceContext) {
	this := p
	_ = this

	localctx = NewCreateKeyspaceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, CqlParserRULE_createKeyspace)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(850)
		p.KwCreate()
	}
	{
		p.SetState(851)
		p.KwKeyspace()
	}
	p.SetState(853)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(852)
			p.IfNotExist()
		}

	}
	{
		p.SetState(855)
		p.Keyspace()
	}
	{
		p.SetState(856)
		p.KwWith()
	}
	{
		p.SetState(857)
		p.KwReplication()
	}
	{
		p.SetState(858)
		p.Match(CqlParserOPERATOR_EQ)
	}
	{
		p.SetState(859)
		p.SyntaxBracketLc()
	}
	{
		p.SetState(860)
		p.ReplicationList()
	}
	{
		p.SetState(861)
		p.SyntaxBracketRc()
	}
	p.SetState(865)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_AND {
		{
			p.SetState(862)
			p.KwAnd()
		}
		{
			p.SetState(863)
			p.DurableWrites()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyCreateFunctionContext() *CreateFunctionContext {
	var p = new(CreateFunctionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_createFunction
	return p
}

func (*CreateFunctionContext) IsCreateFunctionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_createFunction

	return p
}

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

func (s *CreateFunctionContext) KwCreate() IKwCreateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwCreateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwCreateContext)
}

func (s *CreateFunctionContext) KwFunction() IKwFunctionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwFunctionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwFunctionContext)
}

func (s *CreateFunctionContext) Function_() IFunction_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunction_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunction_Context)
}

func (s *CreateFunctionContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *CreateFunctionContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *CreateFunctionContext) ReturnMode() IReturnModeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReturnModeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReturnModeContext)
}

func (s *CreateFunctionContext) KwReturns() IKwReturnsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwReturnsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwReturnsContext)
}

func (s *CreateFunctionContext) DataType() IDataTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDataTypeContext)
}

func (s *CreateFunctionContext) KwLanguage() IKwLanguageContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwLanguageContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwLanguageContext)
}

func (s *CreateFunctionContext) Language() ILanguageContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILanguageContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILanguageContext)
}

func (s *CreateFunctionContext) KwAs() IKwAsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAsContext)
}

func (s *CreateFunctionContext) CodeBlock() ICodeBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICodeBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICodeBlockContext)
}

func (s *CreateFunctionContext) OrReplace() IOrReplaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrReplaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOrReplaceContext)
}

func (s *CreateFunctionContext) IfNotExist() IIfNotExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfNotExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfNotExistContext)
}

func (s *CreateFunctionContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *CreateFunctionContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

func (s *CreateFunctionContext) ParamList() IParamListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParamListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParamListContext)
}

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

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

func (s *CreateFunctionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCreateFunction(s)
	}
}

func (s *CreateFunctionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCreateFunction(s)
	}
}

func (p *CqlParser) CreateFunction() (localctx ICreateFunctionContext) {
	this := p
	_ = this

	localctx = NewCreateFunctionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, CqlParserRULE_createFunction)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(867)
		p.KwCreate()
	}
	p.SetState(869)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_OR {
		{
			p.SetState(868)
			p.OrReplace()
		}

	}
	{
		p.SetState(871)
		p.KwFunction()
	}
	p.SetState(873)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(872)
			p.IfNotExist()
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 39, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(875)
			p.Keyspace()
		}
		{
			p.SetState(876)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(880)
		p.Function_()
	}
	{
		p.SetState(881)
		p.SyntaxBracketLr()
	}
	p.SetState(883)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserOBJECT_NAME {
		{
			p.SetState(882)
			p.ParamList()
		}

	}
	{
		p.SetState(885)
		p.SyntaxBracketRr()
	}
	{
		p.SetState(886)
		p.ReturnMode()
	}
	{
		p.SetState(887)
		p.KwReturns()
	}
	{
		p.SetState(888)
		p.DataType()
	}
	{
		p.SetState(889)
		p.KwLanguage()
	}
	{
		p.SetState(890)
		p.Language()
	}
	{
		p.SetState(891)
		p.KwAs()
	}
	{
		p.SetState(892)
		p.CodeBlock()
	}

	return localctx
}

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

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

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

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

func NewEmptyCodeBlockContext() *CodeBlockContext {
	var p = new(CodeBlockContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_codeBlock
	return p
}

func (*CodeBlockContext) IsCodeBlockContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_codeBlock

	return p
}

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

func (s *CodeBlockContext) CODE_BLOCK() antlr.TerminalNode {
	return s.GetToken(CqlParserCODE_BLOCK, 0)
}

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

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

func (s *CodeBlockContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCodeBlock(s)
	}
}

func (s *CodeBlockContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCodeBlock(s)
	}
}

func (p *CqlParser) CodeBlock() (localctx ICodeBlockContext) {
	this := p
	_ = this

	localctx = NewCodeBlockContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, CqlParserRULE_codeBlock)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(894)
		p.Match(CqlParserCODE_BLOCK)
	}

	return localctx
}

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

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

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

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

func NewEmptyParamListContext() *ParamListContext {
	var p = new(ParamListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_paramList
	return p
}

func (*ParamListContext) IsParamListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_paramList

	return p
}

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

func (s *ParamListContext) AllParam() []IParamContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IParamContext)(nil)).Elem())
	var tst = make([]IParamContext, len(ts))

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

	return tst
}

func (s *ParamListContext) Param(i int) IParamContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParamContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IParamContext)
}

func (s *ParamListContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

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

	return tst
}

func (s *ParamListContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

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

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

func (s *ParamListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterParamList(s)
	}
}

func (s *ParamListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitParamList(s)
	}
}

func (p *CqlParser) ParamList() (localctx IParamListContext) {
	this := p
	_ = this

	localctx = NewParamListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 50, CqlParserRULE_paramList)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(896)
		p.Param()
	}
	p.SetState(902)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(897)
			p.SyntaxComma()
		}
		{
			p.SetState(898)
			p.Param()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyReturnModeContext() *ReturnModeContext {
	var p = new(ReturnModeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_returnMode
	return p
}

func (*ReturnModeContext) IsReturnModeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_returnMode

	return p
}

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

func (s *ReturnModeContext) KwOn() IKwOnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwOnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwOnContext)
}

func (s *ReturnModeContext) AllKwNull() []IKwNullContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IKwNullContext)(nil)).Elem())
	var tst = make([]IKwNullContext, len(ts))

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

	return tst
}

func (s *ReturnModeContext) KwNull(i int) IKwNullContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwNullContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IKwNullContext)
}

func (s *ReturnModeContext) KwInput() IKwInputContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwInputContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwInputContext)
}

func (s *ReturnModeContext) KwCalled() IKwCalledContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwCalledContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwCalledContext)
}

func (s *ReturnModeContext) KwReturns() IKwReturnsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwReturnsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwReturnsContext)
}

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

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

func (s *ReturnModeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterReturnMode(s)
	}
}

func (s *ReturnModeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitReturnMode(s)
	}
}

func (p *CqlParser) ReturnMode() (localctx IReturnModeContext) {
	this := p
	_ = this

	localctx = NewReturnModeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, CqlParserRULE_returnMode)

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

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

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

	switch p.GetTokenStream().LA(1) {
	case CqlParserK_CALLED:
		{
			p.SetState(905)
			p.KwCalled()
		}

	case CqlParserK_RETURNS:
		{
			p.SetState(906)
			p.KwReturns()
		}
		{
			p.SetState(907)
			p.KwNull()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(911)
		p.KwOn()
	}
	{
		p.SetState(912)
		p.KwNull()
	}
	{
		p.SetState(913)
		p.KwInput()
	}

	return localctx
}

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

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

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

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

func NewEmptyCreateAggregateContext() *CreateAggregateContext {
	var p = new(CreateAggregateContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_createAggregate
	return p
}

func (*CreateAggregateContext) IsCreateAggregateContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_createAggregate

	return p
}

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

func (s *CreateAggregateContext) KwCreate() IKwCreateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwCreateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwCreateContext)
}

func (s *CreateAggregateContext) KwAggregate() IKwAggregateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAggregateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAggregateContext)
}

func (s *CreateAggregateContext) Aggregate() IAggregateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAggregateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAggregateContext)
}

func (s *CreateAggregateContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *CreateAggregateContext) AllDataType() []IDataTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDataTypeContext)(nil)).Elem())
	var tst = make([]IDataTypeContext, len(ts))

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

	return tst
}

func (s *CreateAggregateContext) DataType(i int) IDataTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDataTypeContext)
}

func (s *CreateAggregateContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *CreateAggregateContext) KwSfunc() IKwSfuncContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwSfuncContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwSfuncContext)
}

func (s *CreateAggregateContext) AllFunction_() []IFunction_Context {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFunction_Context)(nil)).Elem())
	var tst = make([]IFunction_Context, len(ts))

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

	return tst
}

func (s *CreateAggregateContext) Function_(i int) IFunction_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunction_Context)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IFunction_Context)
}

func (s *CreateAggregateContext) KwStype() IKwStypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwStypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwStypeContext)
}

func (s *CreateAggregateContext) KwFinalfunc() IKwFinalfuncContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwFinalfuncContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwFinalfuncContext)
}

func (s *CreateAggregateContext) KwInitcond() IKwInitcondContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwInitcondContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwInitcondContext)
}

func (s *CreateAggregateContext) InitCondDefinition() IInitCondDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitCondDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInitCondDefinitionContext)
}

func (s *CreateAggregateContext) OrReplace() IOrReplaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrReplaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOrReplaceContext)
}

func (s *CreateAggregateContext) IfNotExist() IIfNotExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfNotExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfNotExistContext)
}

func (s *CreateAggregateContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *CreateAggregateContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

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

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

func (s *CreateAggregateContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCreateAggregate(s)
	}
}

func (s *CreateAggregateContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCreateAggregate(s)
	}
}

func (p *CqlParser) CreateAggregate() (localctx ICreateAggregateContext) {
	this := p
	_ = this

	localctx = NewCreateAggregateContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 54, CqlParserRULE_createAggregate)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(915)
		p.KwCreate()
	}
	p.SetState(917)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_OR {
		{
			p.SetState(916)
			p.OrReplace()
		}

	}
	{
		p.SetState(919)
		p.KwAggregate()
	}
	p.SetState(921)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(920)
			p.IfNotExist()
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 45, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(923)
			p.Keyspace()
		}
		{
			p.SetState(924)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(928)
		p.Aggregate()
	}
	{
		p.SetState(929)
		p.SyntaxBracketLr()
	}
	{
		p.SetState(930)
		p.DataType()
	}
	{
		p.SetState(931)
		p.SyntaxBracketRr()
	}
	{
		p.SetState(932)
		p.KwSfunc()
	}
	{
		p.SetState(933)
		p.Function_()
	}
	{
		p.SetState(934)
		p.KwStype()
	}
	{
		p.SetState(935)
		p.DataType()
	}
	{
		p.SetState(936)
		p.KwFinalfunc()
	}
	{
		p.SetState(937)
		p.Function_()
	}
	{
		p.SetState(938)
		p.KwInitcond()
	}
	{
		p.SetState(939)
		p.InitCondDefinition()
	}

	return localctx
}

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

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

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

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

func NewEmptyInitCondDefinitionContext() *InitCondDefinitionContext {
	var p = new(InitCondDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_initCondDefinition
	return p
}

func (*InitCondDefinitionContext) IsInitCondDefinitionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_initCondDefinition

	return p
}

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

func (s *InitCondDefinitionContext) Constant() IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

func (s *InitCondDefinitionContext) InitCondList() IInitCondListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitCondListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInitCondListContext)
}

func (s *InitCondDefinitionContext) InitCondListNested() IInitCondListNestedContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitCondListNestedContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInitCondListNestedContext)
}

func (s *InitCondDefinitionContext) InitCondHash() IInitCondHashContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitCondHashContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInitCondHashContext)
}

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

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

func (s *InitCondDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterInitCondDefinition(s)
	}
}

func (s *InitCondDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitInitCondDefinition(s)
	}
}

func (p *CqlParser) InitCondDefinition() (localctx IInitCondDefinitionContext) {
	this := p
	_ = this

	localctx = NewInitCondDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, CqlParserRULE_initCondDefinition)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(942)
			p.InitCondList()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(943)
			p.InitCondListNested()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(944)
			p.InitCondHash()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyInitCondHashContext() *InitCondHashContext {
	var p = new(InitCondHashContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_initCondHash
	return p
}

func (*InitCondHashContext) IsInitCondHashContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_initCondHash

	return p
}

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

func (s *InitCondHashContext) SyntaxBracketLc() ISyntaxBracketLcContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLcContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLcContext)
}

func (s *InitCondHashContext) AllInitCondHashItem() []IInitCondHashItemContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInitCondHashItemContext)(nil)).Elem())
	var tst = make([]IInitCondHashItemContext, len(ts))

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

	return tst
}

func (s *InitCondHashContext) InitCondHashItem(i int) IInitCondHashItemContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitCondHashItemContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInitCondHashItemContext)
}

func (s *InitCondHashContext) SyntaxBracketRc() ISyntaxBracketRcContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRcContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRcContext)
}

func (s *InitCondHashContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

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

	return tst
}

func (s *InitCondHashContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

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

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

func (s *InitCondHashContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterInitCondHash(s)
	}
}

func (s *InitCondHashContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitInitCondHash(s)
	}
}

func (p *CqlParser) InitCondHash() (localctx IInitCondHashContext) {
	this := p
	_ = this

	localctx = NewInitCondHashContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, CqlParserRULE_initCondHash)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(947)
		p.SyntaxBracketLc()
	}
	{
		p.SetState(948)
		p.InitCondHashItem()
	}
	p.SetState(954)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(949)
			p.SyntaxComma()
		}
		{
			p.SetState(950)
			p.InitCondHashItem()
		}

		p.SetState(956)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(957)
		p.SyntaxBracketRc()
	}

	return localctx
}

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

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

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

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

func NewEmptyInitCondHashItemContext() *InitCondHashItemContext {
	var p = new(InitCondHashItemContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_initCondHashItem
	return p
}

func (*InitCondHashItemContext) IsInitCondHashItemContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_initCondHashItem

	return p
}

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

func (s *InitCondHashItemContext) HashKey() IHashKeyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IHashKeyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IHashKeyContext)
}

func (s *InitCondHashItemContext) COLON() antlr.TerminalNode {
	return s.GetToken(CqlParserCOLON, 0)
}

func (s *InitCondHashItemContext) InitCondDefinition() IInitCondDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitCondDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInitCondDefinitionContext)
}

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

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

func (s *InitCondHashItemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterInitCondHashItem(s)
	}
}

func (s *InitCondHashItemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitInitCondHashItem(s)
	}
}

func (p *CqlParser) InitCondHashItem() (localctx IInitCondHashItemContext) {
	this := p
	_ = this

	localctx = NewInitCondHashItemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 60, CqlParserRULE_initCondHashItem)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(959)
		p.HashKey()
	}
	{
		p.SetState(960)
		p.Match(CqlParserCOLON)
	}
	{
		p.SetState(961)
		p.InitCondDefinition()
	}

	return localctx
}

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

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

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

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

func NewEmptyInitCondListNestedContext() *InitCondListNestedContext {
	var p = new(InitCondListNestedContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_initCondListNested
	return p
}

func (*InitCondListNestedContext) IsInitCondListNestedContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_initCondListNested

	return p
}

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

func (s *InitCondListNestedContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *InitCondListNestedContext) AllInitCondList() []IInitCondListContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInitCondListContext)(nil)).Elem())
	var tst = make([]IInitCondListContext, len(ts))

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

	return tst
}

func (s *InitCondListNestedContext) InitCondList(i int) IInitCondListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitCondListContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInitCondListContext)
}

func (s *InitCondListNestedContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *InitCondListNestedContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

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

	return tst
}

func (s *InitCondListNestedContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *InitCondListNestedContext) AllConstant() []IConstantContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IConstantContext)(nil)).Elem())
	var tst = make([]IConstantContext, len(ts))

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

	return tst
}

func (s *InitCondListNestedContext) Constant(i int) IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

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

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

func (s *InitCondListNestedContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterInitCondListNested(s)
	}
}

func (s *InitCondListNestedContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitInitCondListNested(s)
	}
}

func (p *CqlParser) InitCondListNested() (localctx IInitCondListNestedContext) {
	this := p
	_ = this

	localctx = NewInitCondListNestedContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 62, CqlParserRULE_initCondListNested)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(963)
		p.SyntaxBracketLr()
	}
	{
		p.SetState(964)
		p.InitCondList()
	}
	p.SetState(971)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserLR_BRACKET || _la == CqlParserCOMMA {
		p.SetState(969)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case CqlParserCOMMA:
			{
				p.SetState(965)
				p.SyntaxComma()
			}
			{
				p.SetState(966)
				p.Constant()
			}

		case CqlParserLR_BRACKET:
			{
				p.SetState(968)
				p.InitCondList()
			}

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

		p.SetState(973)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(974)
		p.SyntaxBracketRr()
	}

	return localctx
}

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

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

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

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

func NewEmptyInitCondListContext() *InitCondListContext {
	var p = new(InitCondListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_initCondList
	return p
}

func (*InitCondListContext) IsInitCondListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_initCondList

	return p
}

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

func (s *InitCondListContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *InitCondListContext) AllConstant() []IConstantContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IConstantContext)(nil)).Elem())
	var tst = make([]IConstantContext, len(ts))

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

	return tst
}

func (s *InitCondListContext) Constant(i int) IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

func (s *InitCondListContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *InitCondListContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

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

	return tst
}

func (s *InitCondListContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

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

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

func (s *InitCondListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterInitCondList(s)
	}
}

func (s *InitCondListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitInitCondList(s)
	}
}

func (p *CqlParser) InitCondList() (localctx IInitCondListContext) {
	this := p
	_ = this

	localctx = NewInitCondListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 64, CqlParserRULE_initCondList)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(976)
		p.SyntaxBracketLr()
	}
	{
		p.SetState(977)
		p.Constant()
	}
	p.SetState(983)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(978)
			p.SyntaxComma()
		}
		{
			p.SetState(979)
			p.Constant()
		}

		p.SetState(985)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(986)
		p.SyntaxBracketRr()
	}

	return localctx
}

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

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

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

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

func NewEmptyOrReplaceContext() *OrReplaceContext {
	var p = new(OrReplaceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_orReplace
	return p
}

func (*OrReplaceContext) IsOrReplaceContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_orReplace

	return p
}

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

func (s *OrReplaceContext) KwOr() IKwOrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwOrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwOrContext)
}

func (s *OrReplaceContext) KwReplace() IKwReplaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwReplaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwReplaceContext)
}

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

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

func (s *OrReplaceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterOrReplace(s)
	}
}

func (s *OrReplaceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitOrReplace(s)
	}
}

func (p *CqlParser) OrReplace() (localctx IOrReplaceContext) {
	this := p
	_ = this

	localctx = NewOrReplaceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, CqlParserRULE_orReplace)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(988)
		p.KwOr()
	}
	{
		p.SetState(989)
		p.KwReplace()
	}

	return localctx
}

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

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

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

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

func NewEmptyAlterUserContext() *AlterUserContext {
	var p = new(AlterUserContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterUser
	return p
}

func (*AlterUserContext) IsAlterUserContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterUser

	return p
}

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

func (s *AlterUserContext) KwAlter() IKwAlterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAlterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAlterContext)
}

func (s *AlterUserContext) KwUser() IKwUserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwUserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwUserContext)
}

func (s *AlterUserContext) User() IUserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUserContext)
}

func (s *AlterUserContext) KwWith() IKwWithContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwWithContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwWithContext)
}

func (s *AlterUserContext) UserPassword() IUserPasswordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUserPasswordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUserPasswordContext)
}

func (s *AlterUserContext) UserSuperUser() IUserSuperUserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUserSuperUserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUserSuperUserContext)
}

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

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

func (s *AlterUserContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterUser(s)
	}
}

func (s *AlterUserContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterUser(s)
	}
}

func (p *CqlParser) AlterUser() (localctx IAlterUserContext) {
	this := p
	_ = this

	localctx = NewAlterUserContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, CqlParserRULE_alterUser)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(991)
		p.KwAlter()
	}
	{
		p.SetState(992)
		p.KwUser()
	}
	{
		p.SetState(993)
		p.User()
	}
	{
		p.SetState(994)
		p.KwWith()
	}
	{
		p.SetState(995)
		p.UserPassword()
	}
	p.SetState(997)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_NOSUPERUSER || _la == CqlParserK_SUPERUSER {
		{
			p.SetState(996)
			p.UserSuperUser()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyUserPasswordContext() *UserPasswordContext {
	var p = new(UserPasswordContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_userPassword
	return p
}

func (*UserPasswordContext) IsUserPasswordContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_userPassword

	return p
}

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

func (s *UserPasswordContext) KwPassword() IKwPasswordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwPasswordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwPasswordContext)
}

func (s *UserPasswordContext) StringLiteral() IStringLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStringLiteralContext)
}

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

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

func (s *UserPasswordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterUserPassword(s)
	}
}

func (s *UserPasswordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitUserPassword(s)
	}
}

func (p *CqlParser) UserPassword() (localctx IUserPasswordContext) {
	this := p
	_ = this

	localctx = NewUserPasswordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, CqlParserRULE_userPassword)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(999)
		p.KwPassword()
	}
	{
		p.SetState(1000)
		p.StringLiteral()
	}

	return localctx
}

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

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

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

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

func NewEmptyUserSuperUserContext() *UserSuperUserContext {
	var p = new(UserSuperUserContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_userSuperUser
	return p
}

func (*UserSuperUserContext) IsUserSuperUserContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_userSuperUser

	return p
}

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

func (s *UserSuperUserContext) KwSuperuser() IKwSuperuserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwSuperuserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwSuperuserContext)
}

func (s *UserSuperUserContext) KwNosuperuser() IKwNosuperuserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwNosuperuserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwNosuperuserContext)
}

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

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

func (s *UserSuperUserContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterUserSuperUser(s)
	}
}

func (s *UserSuperUserContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitUserSuperUser(s)
	}
}

func (p *CqlParser) UserSuperUser() (localctx IUserSuperUserContext) {
	this := p
	_ = this

	localctx = NewUserSuperUserContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, CqlParserRULE_userSuperUser)

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

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

	switch p.GetTokenStream().LA(1) {
	case CqlParserK_SUPERUSER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1002)
			p.KwSuperuser()
		}

	case CqlParserK_NOSUPERUSER:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1003)
			p.KwNosuperuser()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAlterTypeContext() *AlterTypeContext {
	var p = new(AlterTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterType
	return p
}

func (*AlterTypeContext) IsAlterTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterType

	return p
}

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

func (s *AlterTypeContext) KwAlter() IKwAlterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAlterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAlterContext)
}

func (s *AlterTypeContext) KwType() IKwTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwTypeContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

func (s *AlterTypeContext) AlterTypeOperation() IAlterTypeOperationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTypeOperationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTypeOperationContext)
}

func (s *AlterTypeContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *AlterTypeContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

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

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

func (s *AlterTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterType(s)
	}
}

func (s *AlterTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterType(s)
	}
}

func (p *CqlParser) AlterType() (localctx IAlterTypeContext) {
	this := p
	_ = this

	localctx = NewAlterTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, CqlParserRULE_alterType)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1006)
		p.KwAlter()
	}
	{
		p.SetState(1007)
		p.KwType()
	}
	p.SetState(1011)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 53, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1008)
			p.Keyspace()
		}
		{
			p.SetState(1009)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1013)
		p.Type_()
	}
	{
		p.SetState(1014)
		p.AlterTypeOperation()
	}

	return localctx
}

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

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

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

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

func NewEmptyAlterTypeOperationContext() *AlterTypeOperationContext {
	var p = new(AlterTypeOperationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTypeOperation
	return p
}

func (*AlterTypeOperationContext) IsAlterTypeOperationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTypeOperation

	return p
}

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

func (s *AlterTypeOperationContext) AlterTypeAlterType() IAlterTypeAlterTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTypeAlterTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTypeAlterTypeContext)
}

func (s *AlterTypeOperationContext) AlterTypeAdd() IAlterTypeAddContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTypeAddContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTypeAddContext)
}

func (s *AlterTypeOperationContext) AlterTypeRename() IAlterTypeRenameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTypeRenameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTypeRenameContext)
}

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

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

func (s *AlterTypeOperationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTypeOperation(s)
	}
}

func (s *AlterTypeOperationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTypeOperation(s)
	}
}

func (p *CqlParser) AlterTypeOperation() (localctx IAlterTypeOperationContext) {
	this := p
	_ = this

	localctx = NewAlterTypeOperationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 76, CqlParserRULE_alterTypeOperation)

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

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

	p.SetState(1019)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserK_ALTER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1016)
			p.AlterTypeAlterType()
		}

	case CqlParserK_ADD:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1017)
			p.AlterTypeAdd()
		}

	case CqlParserK_RENAME:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1018)
			p.AlterTypeRename()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAlterTypeRenameContext() *AlterTypeRenameContext {
	var p = new(AlterTypeRenameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTypeRename
	return p
}

func (*AlterTypeRenameContext) IsAlterTypeRenameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTypeRename

	return p
}

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

func (s *AlterTypeRenameContext) KwRename() IKwRenameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwRenameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwRenameContext)
}

func (s *AlterTypeRenameContext) AlterTypeRenameList() IAlterTypeRenameListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTypeRenameListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTypeRenameListContext)
}

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

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

func (s *AlterTypeRenameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTypeRename(s)
	}
}

func (s *AlterTypeRenameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTypeRename(s)
	}
}

func (p *CqlParser) AlterTypeRename() (localctx IAlterTypeRenameContext) {
	this := p
	_ = this

	localctx = NewAlterTypeRenameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, CqlParserRULE_alterTypeRename)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1021)
		p.KwRename()
	}
	{
		p.SetState(1022)
		p.AlterTypeRenameList()
	}

	return localctx
}

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

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

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

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

func NewEmptyAlterTypeRenameListContext() *AlterTypeRenameListContext {
	var p = new(AlterTypeRenameListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTypeRenameList
	return p
}

func (*AlterTypeRenameListContext) IsAlterTypeRenameListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTypeRenameList

	return p
}

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

func (s *AlterTypeRenameListContext) AllAlterTypeRenameItem() []IAlterTypeRenameItemContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAlterTypeRenameItemContext)(nil)).Elem())
	var tst = make([]IAlterTypeRenameItemContext, len(ts))

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

	return tst
}

func (s *AlterTypeRenameListContext) AlterTypeRenameItem(i int) IAlterTypeRenameItemContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTypeRenameItemContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAlterTypeRenameItemContext)
}

func (s *AlterTypeRenameListContext) AllKwAnd() []IKwAndContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IKwAndContext)(nil)).Elem())
	var tst = make([]IKwAndContext, len(ts))

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

	return tst
}

func (s *AlterTypeRenameListContext) KwAnd(i int) IKwAndContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAndContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IKwAndContext)
}

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

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

func (s *AlterTypeRenameListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTypeRenameList(s)
	}
}

func (s *AlterTypeRenameListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTypeRenameList(s)
	}
}

func (p *CqlParser) AlterTypeRenameList() (localctx IAlterTypeRenameListContext) {
	this := p
	_ = this

	localctx = NewAlterTypeRenameListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, CqlParserRULE_alterTypeRenameList)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1024)
		p.AlterTypeRenameItem()
	}
	p.SetState(1030)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserK_AND {
		{
			p.SetState(1025)
			p.KwAnd()
		}
		{
			p.SetState(1026)
			p.AlterTypeRenameItem()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAlterTypeRenameItemContext() *AlterTypeRenameItemContext {
	var p = new(AlterTypeRenameItemContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTypeRenameItem
	return p
}

func (*AlterTypeRenameItemContext) IsAlterTypeRenameItemContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTypeRenameItem

	return p
}

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

func (s *AlterTypeRenameItemContext) AllColumn() []IColumnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumnContext)(nil)).Elem())
	var tst = make([]IColumnContext, len(ts))

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

	return tst
}

func (s *AlterTypeRenameItemContext) Column(i int) IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *AlterTypeRenameItemContext) KwTo() IKwToContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwToContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwToContext)
}

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

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

func (s *AlterTypeRenameItemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTypeRenameItem(s)
	}
}

func (s *AlterTypeRenameItemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTypeRenameItem(s)
	}
}

func (p *CqlParser) AlterTypeRenameItem() (localctx IAlterTypeRenameItemContext) {
	this := p
	_ = this

	localctx = NewAlterTypeRenameItemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, CqlParserRULE_alterTypeRenameItem)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1033)
		p.Column()
	}
	{
		p.SetState(1034)
		p.KwTo()
	}
	{
		p.SetState(1035)
		p.Column()
	}

	return localctx
}

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

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

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

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

func NewEmptyAlterTypeAddContext() *AlterTypeAddContext {
	var p = new(AlterTypeAddContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTypeAdd
	return p
}

func (*AlterTypeAddContext) IsAlterTypeAddContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTypeAdd

	return p
}

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

func (s *AlterTypeAddContext) KwAdd() IKwAddContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAddContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAddContext)
}

func (s *AlterTypeAddContext) AllColumn() []IColumnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumnContext)(nil)).Elem())
	var tst = make([]IColumnContext, len(ts))

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

	return tst
}

func (s *AlterTypeAddContext) Column(i int) IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *AlterTypeAddContext) AllDataType() []IDataTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDataTypeContext)(nil)).Elem())
	var tst = make([]IDataTypeContext, len(ts))

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

	return tst
}

func (s *AlterTypeAddContext) DataType(i int) IDataTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDataTypeContext)
}

func (s *AlterTypeAddContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

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

	return tst
}

func (s *AlterTypeAddContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

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

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

func (s *AlterTypeAddContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTypeAdd(s)
	}
}

func (s *AlterTypeAddContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTypeAdd(s)
	}
}

func (p *CqlParser) AlterTypeAdd() (localctx IAlterTypeAddContext) {
	this := p
	_ = this

	localctx = NewAlterTypeAddContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 84, CqlParserRULE_alterTypeAdd)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1037)
		p.KwAdd()
	}
	{
		p.SetState(1038)
		p.Column()
	}
	{
		p.SetState(1039)
		p.DataType()
	}
	p.SetState(1046)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(1040)
			p.SyntaxComma()
		}
		{
			p.SetState(1041)
			p.Column()
		}
		{
			p.SetState(1042)
			p.DataType()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAlterTypeAlterTypeContext() *AlterTypeAlterTypeContext {
	var p = new(AlterTypeAlterTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTypeAlterType
	return p
}

func (*AlterTypeAlterTypeContext) IsAlterTypeAlterTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTypeAlterType

	return p
}

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

func (s *AlterTypeAlterTypeContext) KwAlter() IKwAlterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAlterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAlterContext)
}

func (s *AlterTypeAlterTypeContext) Column() IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *AlterTypeAlterTypeContext) KwType() IKwTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwTypeContext)
}

func (s *AlterTypeAlterTypeContext) DataType() IDataTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDataTypeContext)
}

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

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

func (s *AlterTypeAlterTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTypeAlterType(s)
	}
}

func (s *AlterTypeAlterTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTypeAlterType(s)
	}
}

func (p *CqlParser) AlterTypeAlterType() (localctx IAlterTypeAlterTypeContext) {
	this := p
	_ = this

	localctx = NewAlterTypeAlterTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, CqlParserRULE_alterTypeAlterType)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1049)
		p.KwAlter()
	}
	{
		p.SetState(1050)
		p.Column()
	}
	{
		p.SetState(1051)
		p.KwType()
	}
	{
		p.SetState(1052)
		p.DataType()
	}

	return localctx
}

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

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

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

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

func NewEmptyAlterTableContext() *AlterTableContext {
	var p = new(AlterTableContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTable
	return p
}

func (*AlterTableContext) IsAlterTableContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTable

	return p
}

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

func (s *AlterTableContext) KwAlter() IKwAlterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAlterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAlterContext)
}

func (s *AlterTableContext) KwTable() IKwTableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwTableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwTableContext)
}

func (s *AlterTableContext) Table() ITableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableContext)
}

func (s *AlterTableContext) AlterTableOperation() IAlterTableOperationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTableOperationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTableOperationContext)
}

func (s *AlterTableContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *AlterTableContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

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

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

func (s *AlterTableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTable(s)
	}
}

func (s *AlterTableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTable(s)
	}
}

func (p *CqlParser) AlterTable() (localctx IAlterTableContext) {
	this := p
	_ = this

	localctx = NewAlterTableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, CqlParserRULE_alterTable)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1054)
		p.KwAlter()
	}
	{
		p.SetState(1055)
		p.KwTable()
	}
	p.SetState(1059)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 57, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1056)
			p.Keyspace()
		}
		{
			p.SetState(1057)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1061)
		p.Table()
	}
	{
		p.SetState(1062)
		p.AlterTableOperation()
	}

	return localctx
}

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

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

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

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

func NewEmptyAlterTableOperationContext() *AlterTableOperationContext {
	var p = new(AlterTableOperationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTableOperation
	return p
}

func (*AlterTableOperationContext) IsAlterTableOperationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTableOperation

	return p
}

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

func (s *AlterTableOperationContext) AlterTableAdd() IAlterTableAddContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTableAddContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTableAddContext)
}

func (s *AlterTableOperationContext) AlterTableDropColumns() IAlterTableDropColumnsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTableDropColumnsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTableDropColumnsContext)
}

func (s *AlterTableOperationContext) AlterTableDropCompactStorage() IAlterTableDropCompactStorageContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTableDropCompactStorageContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTableDropCompactStorageContext)
}

func (s *AlterTableOperationContext) AlterTableRename() IAlterTableRenameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTableRenameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTableRenameContext)
}

func (s *AlterTableOperationContext) AlterTableWith() IAlterTableWithContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTableWithContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTableWithContext)
}

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

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

func (s *AlterTableOperationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTableOperation(s)
	}
}

func (s *AlterTableOperationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTableOperation(s)
	}
}

func (p *CqlParser) AlterTableOperation() (localctx IAlterTableOperationContext) {
	this := p
	_ = this

	localctx = NewAlterTableOperationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, CqlParserRULE_alterTableOperation)

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

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

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1065)
			p.AlterTableDropColumns()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1066)
			p.AlterTableDropColumns()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1067)
			p.AlterTableDropCompactStorage()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1068)
			p.AlterTableRename()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1069)
			p.AlterTableWith()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyAlterTableWithContext() *AlterTableWithContext {
	var p = new(AlterTableWithContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTableWith
	return p
}

func (*AlterTableWithContext) IsAlterTableWithContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTableWith

	return p
}

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

func (s *AlterTableWithContext) KwWith() IKwWithContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwWithContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwWithContext)
}

func (s *AlterTableWithContext) TableOptions() ITableOptionsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableOptionsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableOptionsContext)
}

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

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

func (s *AlterTableWithContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTableWith(s)
	}
}

func (s *AlterTableWithContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTableWith(s)
	}
}

func (p *CqlParser) AlterTableWith() (localctx IAlterTableWithContext) {
	this := p
	_ = this

	localctx = NewAlterTableWithContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, CqlParserRULE_alterTableWith)

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

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.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.KwWith()
	}
	{
		p.SetState(1073)
		p.TableOptions()
	}

	return localctx
}

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

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

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

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

func NewEmptyAlterTableRenameContext() *AlterTableRenameContext {
	var p = new(AlterTableRenameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTableRename
	return p
}

func (*AlterTableRenameContext) IsAlterTableRenameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTableRename

	return p
}

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

func (s *AlterTableRenameContext) KwRename() IKwRenameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwRenameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwRenameContext)
}

func (s *AlterTableRenameContext) AllColumn() []IColumnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumnContext)(nil)).Elem())
	var tst = make([]IColumnContext, len(ts))

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

	return tst
}

func (s *AlterTableRenameContext) Column(i int) IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *AlterTableRenameContext) KwTo() IKwToContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwToContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwToContext)
}

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

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

func (s *AlterTableRenameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTableRename(s)
	}
}

func (s *AlterTableRenameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTableRename(s)
	}
}

func (p *CqlParser) AlterTableRename() (localctx IAlterTableRenameContext) {
	this := p
	_ = this

	localctx = NewAlterTableRenameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, CqlParserRULE_alterTableRename)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1075)
		p.KwRename()
	}
	{
		p.SetState(1076)
		p.Column()
	}
	{
		p.SetState(1077)
		p.KwTo()
	}
	{
		p.SetState(1078)
		p.Column()
	}

	return localctx
}

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

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

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

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

func NewEmptyAlterTableDropCompactStorageContext() *AlterTableDropCompactStorageContext {
	var p = new(AlterTableDropCompactStorageContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTableDropCompactStorage
	return p
}

func (*AlterTableDropCompactStorageContext) IsAlterTableDropCompactStorageContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTableDropCompactStorage

	return p
}

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

func (s *AlterTableDropCompactStorageContext) KwDrop() IKwDropContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDropContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDropContext)
}

func (s *AlterTableDropCompactStorageContext) KwCompact() IKwCompactContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwCompactContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwCompactContext)
}

func (s *AlterTableDropCompactStorageContext) KwStorage() IKwStorageContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwStorageContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwStorageContext)
}

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

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

func (s *AlterTableDropCompactStorageContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTableDropCompactStorage(s)
	}
}

func (s *AlterTableDropCompactStorageContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTableDropCompactStorage(s)
	}
}

func (p *CqlParser) AlterTableDropCompactStorage() (localctx IAlterTableDropCompactStorageContext) {
	this := p
	_ = this

	localctx = NewAlterTableDropCompactStorageContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 96, CqlParserRULE_alterTableDropCompactStorage)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1080)
		p.KwDrop()
	}
	{
		p.SetState(1081)
		p.KwCompact()
	}
	{
		p.SetState(1082)
		p.KwStorage()
	}

	return localctx
}

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

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

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

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

func NewEmptyAlterTableDropColumnsContext() *AlterTableDropColumnsContext {
	var p = new(AlterTableDropColumnsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTableDropColumns
	return p
}

func (*AlterTableDropColumnsContext) IsAlterTableDropColumnsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTableDropColumns

	return p
}

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

func (s *AlterTableDropColumnsContext) KwDrop() IKwDropContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDropContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDropContext)
}

func (s *AlterTableDropColumnsContext) AlterTableDropColumnList() IAlterTableDropColumnListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTableDropColumnListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTableDropColumnListContext)
}

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

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

func (s *AlterTableDropColumnsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTableDropColumns(s)
	}
}

func (s *AlterTableDropColumnsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTableDropColumns(s)
	}
}

func (p *CqlParser) AlterTableDropColumns() (localctx IAlterTableDropColumnsContext) {
	this := p
	_ = this

	localctx = NewAlterTableDropColumnsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 98, CqlParserRULE_alterTableDropColumns)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1084)
		p.KwDrop()
	}
	{
		p.SetState(1085)
		p.AlterTableDropColumnList()
	}

	return localctx
}

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

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

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

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

func NewEmptyAlterTableDropColumnListContext() *AlterTableDropColumnListContext {
	var p = new(AlterTableDropColumnListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTableDropColumnList
	return p
}

func (*AlterTableDropColumnListContext) IsAlterTableDropColumnListContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTableDropColumnList

	return p
}

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

func (s *AlterTableDropColumnListContext) AllColumn() []IColumnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumnContext)(nil)).Elem())
	var tst = make([]IColumnContext, len(ts))

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

	return tst
}

func (s *AlterTableDropColumnListContext) Column(i int) IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *AlterTableDropColumnListContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

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

	return tst
}

func (s *AlterTableDropColumnListContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

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

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

func (s *AlterTableDropColumnListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTableDropColumnList(s)
	}
}

func (s *AlterTableDropColumnListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTableDropColumnList(s)
	}
}

func (p *CqlParser) AlterTableDropColumnList() (localctx IAlterTableDropColumnListContext) {
	this := p
	_ = this

	localctx = NewAlterTableDropColumnListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, CqlParserRULE_alterTableDropColumnList)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1087)
		p.Column()
	}
	p.SetState(1093)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(1088)
			p.SyntaxComma()
		}
		{
			p.SetState(1089)
			p.Column()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAlterTableAddContext() *AlterTableAddContext {
	var p = new(AlterTableAddContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTableAdd
	return p
}

func (*AlterTableAddContext) IsAlterTableAddContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTableAdd

	return p
}

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

func (s *AlterTableAddContext) KwAdd() IKwAddContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAddContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAddContext)
}

func (s *AlterTableAddContext) AlterTableColumnDefinition() IAlterTableColumnDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlterTableColumnDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlterTableColumnDefinitionContext)
}

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

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

func (s *AlterTableAddContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTableAdd(s)
	}
}

func (s *AlterTableAddContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTableAdd(s)
	}
}

func (p *CqlParser) AlterTableAdd() (localctx IAlterTableAddContext) {
	this := p
	_ = this

	localctx = NewAlterTableAddContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, CqlParserRULE_alterTableAdd)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1096)
		p.KwAdd()
	}
	{
		p.SetState(1097)
		p.AlterTableColumnDefinition()
	}

	return localctx
}

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

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

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

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

func NewEmptyAlterTableColumnDefinitionContext() *AlterTableColumnDefinitionContext {
	var p = new(AlterTableColumnDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterTableColumnDefinition
	return p
}

func (*AlterTableColumnDefinitionContext) IsAlterTableColumnDefinitionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterTableColumnDefinition

	return p
}

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

func (s *AlterTableColumnDefinitionContext) AllColumn() []IColumnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumnContext)(nil)).Elem())
	var tst = make([]IColumnContext, len(ts))

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

	return tst
}

func (s *AlterTableColumnDefinitionContext) Column(i int) IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *AlterTableColumnDefinitionContext) AllDataType() []IDataTypeContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDataTypeContext)(nil)).Elem())
	var tst = make([]IDataTypeContext, len(ts))

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

	return tst
}

func (s *AlterTableColumnDefinitionContext) DataType(i int) IDataTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDataTypeContext)
}

func (s *AlterTableColumnDefinitionContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

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

	return tst
}

func (s *AlterTableColumnDefinitionContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

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

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

func (s *AlterTableColumnDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterTableColumnDefinition(s)
	}
}

func (s *AlterTableColumnDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterTableColumnDefinition(s)
	}
}

func (p *CqlParser) AlterTableColumnDefinition() (localctx IAlterTableColumnDefinitionContext) {
	this := p
	_ = this

	localctx = NewAlterTableColumnDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 104, CqlParserRULE_alterTableColumnDefinition)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1099)
		p.Column()
	}
	{
		p.SetState(1100)
		p.DataType()
	}
	p.SetState(1107)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(1101)
			p.SyntaxComma()
		}
		{
			p.SetState(1102)
			p.Column()
		}
		{
			p.SetState(1103)
			p.DataType()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAlterRoleContext() *AlterRoleContext {
	var p = new(AlterRoleContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterRole
	return p
}

func (*AlterRoleContext) IsAlterRoleContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterRole

	return p
}

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

func (s *AlterRoleContext) KwAlter() IKwAlterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAlterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAlterContext)
}

func (s *AlterRoleContext) KwRole() IKwRoleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwRoleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwRoleContext)
}

func (s *AlterRoleContext) Role() IRoleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRoleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRoleContext)
}

func (s *AlterRoleContext) RoleWith() IRoleWithContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRoleWithContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRoleWithContext)
}

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

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

func (s *AlterRoleContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterRole(s)
	}
}

func (s *AlterRoleContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterRole(s)
	}
}

func (p *CqlParser) AlterRole() (localctx IAlterRoleContext) {
	this := p
	_ = this

	localctx = NewAlterRoleContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, CqlParserRULE_alterRole)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1110)
		p.KwAlter()
	}
	{
		p.SetState(1111)
		p.KwRole()
	}
	{
		p.SetState(1112)
		p.Role()
	}
	p.SetState(1114)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_WITH {
		{
			p.SetState(1113)
			p.RoleWith()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyRoleWithContext() *RoleWithContext {
	var p = new(RoleWithContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_roleWith
	return p
}

func (*RoleWithContext) IsRoleWithContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_roleWith

	return p
}

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

func (s *RoleWithContext) KwWith() IKwWithContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwWithContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwWithContext)
}

func (s *RoleWithContext) AllRoleWithOptions() []IRoleWithOptionsContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IRoleWithOptionsContext)(nil)).Elem())
	var tst = make([]IRoleWithOptionsContext, len(ts))

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

	return tst
}

func (s *RoleWithContext) RoleWithOptions(i int) IRoleWithOptionsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRoleWithOptionsContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IRoleWithOptionsContext)
}

func (s *RoleWithContext) AllKwAnd() []IKwAndContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IKwAndContext)(nil)).Elem())
	var tst = make([]IKwAndContext, len(ts))

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

	return tst
}

func (s *RoleWithContext) KwAnd(i int) IKwAndContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAndContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IKwAndContext)
}

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

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

func (s *RoleWithContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterRoleWith(s)
	}
}

func (s *RoleWithContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitRoleWith(s)
	}
}

func (p *CqlParser) RoleWith() (localctx IRoleWithContext) {
	this := p
	_ = this

	localctx = NewRoleWithContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, CqlParserRULE_roleWith)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1116)
		p.KwWith()
	}

	{
		p.SetState(1117)
		p.RoleWithOptions()
	}
	p.SetState(1123)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserK_AND {
		{
			p.SetState(1118)
			p.KwAnd()
		}
		{
			p.SetState(1119)
			p.RoleWithOptions()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyRoleWithOptionsContext() *RoleWithOptionsContext {
	var p = new(RoleWithOptionsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_roleWithOptions
	return p
}

func (*RoleWithOptionsContext) IsRoleWithOptionsContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_roleWithOptions

	return p
}

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

func (s *RoleWithOptionsContext) KwPassword() IKwPasswordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwPasswordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwPasswordContext)
}

func (s *RoleWithOptionsContext) OPERATOR_EQ() antlr.TerminalNode {
	return s.GetToken(CqlParserOPERATOR_EQ, 0)
}

func (s *RoleWithOptionsContext) StringLiteral() IStringLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStringLiteralContext)
}

func (s *RoleWithOptionsContext) KwLogin() IKwLoginContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwLoginContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwLoginContext)
}

func (s *RoleWithOptionsContext) BooleanLiteral() IBooleanLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBooleanLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBooleanLiteralContext)
}

func (s *RoleWithOptionsContext) KwSuperuser() IKwSuperuserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwSuperuserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwSuperuserContext)
}

func (s *RoleWithOptionsContext) KwOptions() IKwOptionsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwOptionsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwOptionsContext)
}

func (s *RoleWithOptionsContext) OptionHash() IOptionHashContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOptionHashContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOptionHashContext)
}

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

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

func (s *RoleWithOptionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterRoleWithOptions(s)
	}
}

func (s *RoleWithOptionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitRoleWithOptions(s)
	}
}

func (p *CqlParser) RoleWithOptions() (localctx IRoleWithOptionsContext) {
	this := p
	_ = this

	localctx = NewRoleWithOptionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, CqlParserRULE_roleWithOptions)

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

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

	switch p.GetTokenStream().LA(1) {
	case CqlParserK_PASSWORD:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1126)
			p.KwPassword()
		}
		{
			p.SetState(1127)
			p.Match(CqlParserOPERATOR_EQ)
		}
		{
			p.SetState(1128)
			p.StringLiteral()
		}

	case CqlParserK_LOGIN:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1130)
			p.KwLogin()
		}
		{
			p.SetState(1131)
			p.Match(CqlParserOPERATOR_EQ)
		}
		{
			p.SetState(1132)
			p.BooleanLiteral()
		}

	case CqlParserK_SUPERUSER:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1134)
			p.KwSuperuser()
		}
		{
			p.SetState(1135)
			p.Match(CqlParserOPERATOR_EQ)
		}
		{
			p.SetState(1136)
			p.BooleanLiteral()
		}

	case CqlParserK_OPTIONS:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1138)
			p.KwOptions()
		}
		{
			p.SetState(1139)
			p.Match(CqlParserOPERATOR_EQ)
		}
		{
			p.SetState(1140)
			p.OptionHash()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyAlterMaterializedViewContext() *AlterMaterializedViewContext {
	var p = new(AlterMaterializedViewContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterMaterializedView
	return p
}

func (*AlterMaterializedViewContext) IsAlterMaterializedViewContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterMaterializedView

	return p
}

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

func (s *AlterMaterializedViewContext) KwAlter() IKwAlterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAlterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAlterContext)
}

func (s *AlterMaterializedViewContext) KwMaterialized() IKwMaterializedContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwMaterializedContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwMaterializedContext)
}

func (s *AlterMaterializedViewContext) KwView() IKwViewContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwViewContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwViewContext)
}

func (s *AlterMaterializedViewContext) MaterializedView() IMaterializedViewContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMaterializedViewContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMaterializedViewContext)
}

func (s *AlterMaterializedViewContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *AlterMaterializedViewContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

func (s *AlterMaterializedViewContext) KwWith() IKwWithContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwWithContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwWithContext)
}

func (s *AlterMaterializedViewContext) TableOptions() ITableOptionsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableOptionsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableOptionsContext)
}

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

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

func (s *AlterMaterializedViewContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterMaterializedView(s)
	}
}

func (s *AlterMaterializedViewContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterMaterializedView(s)
	}
}

func (p *CqlParser) AlterMaterializedView() (localctx IAlterMaterializedViewContext) {
	this := p
	_ = this

	localctx = NewAlterMaterializedViewContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 112, CqlParserRULE_alterMaterializedView)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1144)
		p.KwAlter()
	}
	{
		p.SetState(1145)
		p.KwMaterialized()
	}
	{
		p.SetState(1146)
		p.KwView()
	}
	p.SetState(1150)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 64, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1147)
			p.Keyspace()
		}
		{
			p.SetState(1148)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1152)
		p.MaterializedView()
	}
	p.SetState(1156)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_WITH {
		{
			p.SetState(1153)
			p.KwWith()
		}
		{
			p.SetState(1154)
			p.TableOptions()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyDropUserContext() *DropUserContext {
	var p = new(DropUserContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_dropUser
	return p
}

func (*DropUserContext) IsDropUserContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_dropUser

	return p
}

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

func (s *DropUserContext) KwDrop() IKwDropContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDropContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDropContext)
}

func (s *DropUserContext) KwUser() IKwUserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwUserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwUserContext)
}

func (s *DropUserContext) User() IUserContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUserContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUserContext)
}

func (s *DropUserContext) IfExist() IIfExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfExistContext)
}

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

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

func (s *DropUserContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDropUser(s)
	}
}

func (s *DropUserContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDropUser(s)
	}
}

func (p *CqlParser) DropUser() (localctx IDropUserContext) {
	this := p
	_ = this

	localctx = NewDropUserContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 114, CqlParserRULE_dropUser)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1158)
		p.KwDrop()
	}
	{
		p.SetState(1159)
		p.KwUser()
	}
	p.SetState(1161)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(1160)
			p.IfExist()
		}

	}
	{
		p.SetState(1163)
		p.User()
	}

	return localctx
}

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

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

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

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

func NewEmptyDropTypeContext() *DropTypeContext {
	var p = new(DropTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_dropType
	return p
}

func (*DropTypeContext) IsDropTypeContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_dropType

	return p
}

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

func (s *DropTypeContext) KwDrop() IKwDropContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDropContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDropContext)
}

func (s *DropTypeContext) KwType() IKwTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwTypeContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IType_Context)
}

func (s *DropTypeContext) IfExist() IIfExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfExistContext)
}

func (s *DropTypeContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *DropTypeContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

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

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

func (s *DropTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDropType(s)
	}
}

func (s *DropTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDropType(s)
	}
}

func (p *CqlParser) DropType() (localctx IDropTypeContext) {
	this := p
	_ = this

	localctx = NewDropTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, CqlParserRULE_dropType)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1165)
		p.KwDrop()
	}
	{
		p.SetState(1166)
		p.KwType()
	}
	p.SetState(1168)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(1167)
			p.IfExist()
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 68, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1170)
			p.Keyspace()
		}
		{
			p.SetState(1171)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1175)
		p.Type_()
	}

	return localctx
}

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

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

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

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

func NewEmptyDropMaterializedViewContext() *DropMaterializedViewContext {
	var p = new(DropMaterializedViewContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_dropMaterializedView
	return p
}

func (*DropMaterializedViewContext) IsDropMaterializedViewContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_dropMaterializedView

	return p
}

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

func (s *DropMaterializedViewContext) KwDrop() IKwDropContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDropContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDropContext)
}

func (s *DropMaterializedViewContext) KwMaterialized() IKwMaterializedContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwMaterializedContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwMaterializedContext)
}

func (s *DropMaterializedViewContext) KwView() IKwViewContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwViewContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwViewContext)
}

func (s *DropMaterializedViewContext) MaterializedView() IMaterializedViewContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMaterializedViewContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IMaterializedViewContext)
}

func (s *DropMaterializedViewContext) IfExist() IIfExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfExistContext)
}

func (s *DropMaterializedViewContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *DropMaterializedViewContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

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

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

func (s *DropMaterializedViewContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDropMaterializedView(s)
	}
}

func (s *DropMaterializedViewContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDropMaterializedView(s)
	}
}

func (p *CqlParser) DropMaterializedView() (localctx IDropMaterializedViewContext) {
	this := p
	_ = this

	localctx = NewDropMaterializedViewContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, CqlParserRULE_dropMaterializedView)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1177)
		p.KwDrop()
	}
	{
		p.SetState(1178)
		p.KwMaterialized()
	}
	{
		p.SetState(1179)
		p.KwView()
	}
	p.SetState(1181)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(1180)
			p.IfExist()
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 70, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1183)
			p.Keyspace()
		}
		{
			p.SetState(1184)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1188)
		p.MaterializedView()
	}

	return localctx
}

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

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

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

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

func NewEmptyDropAggregateContext() *DropAggregateContext {
	var p = new(DropAggregateContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_dropAggregate
	return p
}

func (*DropAggregateContext) IsDropAggregateContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_dropAggregate

	return p
}

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

func (s *DropAggregateContext) KwDrop() IKwDropContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDropContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDropContext)
}

func (s *DropAggregateContext) KwAggregate() IKwAggregateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAggregateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAggregateContext)
}

func (s *DropAggregateContext) Aggregate() IAggregateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAggregateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAggregateContext)
}

func (s *DropAggregateContext) IfExist() IIfExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfExistContext)
}

func (s *DropAggregateContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *DropAggregateContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

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

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

func (s *DropAggregateContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDropAggregate(s)
	}
}

func (s *DropAggregateContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDropAggregate(s)
	}
}

func (p *CqlParser) DropAggregate() (localctx IDropAggregateContext) {
	this := p
	_ = this

	localctx = NewDropAggregateContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, CqlParserRULE_dropAggregate)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1190)
		p.KwDrop()
	}
	{
		p.SetState(1191)
		p.KwAggregate()
	}
	p.SetState(1193)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(1192)
			p.IfExist()
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 72, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1195)
			p.Keyspace()
		}
		{
			p.SetState(1196)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1200)
		p.Aggregate()
	}

	return localctx
}

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

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

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

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

func NewEmptyDropFunctionContext() *DropFunctionContext {
	var p = new(DropFunctionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_dropFunction
	return p
}

func (*DropFunctionContext) IsDropFunctionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_dropFunction

	return p
}

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

func (s *DropFunctionContext) KwDrop() IKwDropContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDropContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDropContext)
}

func (s *DropFunctionContext) KwFunction() IKwFunctionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwFunctionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwFunctionContext)
}

func (s *DropFunctionContext) Function_() IFunction_Context {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunction_Context)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunction_Context)
}

func (s *DropFunctionContext) IfExist() IIfExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfExistContext)
}

func (s *DropFunctionContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *DropFunctionContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

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

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

func (s *DropFunctionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDropFunction(s)
	}
}

func (s *DropFunctionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDropFunction(s)
	}
}

func (p *CqlParser) DropFunction() (localctx IDropFunctionContext) {
	this := p
	_ = this

	localctx = NewDropFunctionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 122, CqlParserRULE_dropFunction)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1202)
		p.KwDrop()
	}
	{
		p.SetState(1203)
		p.KwFunction()
	}
	p.SetState(1205)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(1204)
			p.IfExist()
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 74, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1207)
			p.Keyspace()
		}
		{
			p.SetState(1208)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1212)
		p.Function_()
	}

	return localctx
}

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

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

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

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

func NewEmptyDropTriggerContext() *DropTriggerContext {
	var p = new(DropTriggerContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_dropTrigger
	return p
}

func (*DropTriggerContext) IsDropTriggerContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_dropTrigger

	return p
}

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

func (s *DropTriggerContext) KwDrop() IKwDropContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDropContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDropContext)
}

func (s *DropTriggerContext) KwTrigger() IKwTriggerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwTriggerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwTriggerContext)
}

func (s *DropTriggerContext) Trigger() ITriggerContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITriggerContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITriggerContext)
}

func (s *DropTriggerContext) KwOn() IKwOnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwOnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwOnContext)
}

func (s *DropTriggerContext) Table() ITableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableContext)
}

func (s *DropTriggerContext) IfExist() IIfExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfExistContext)
}

func (s *DropTriggerContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *DropTriggerContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

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

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

func (s *DropTriggerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDropTrigger(s)
	}
}

func (s *DropTriggerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDropTrigger(s)
	}
}

func (p *CqlParser) DropTrigger() (localctx IDropTriggerContext) {
	this := p
	_ = this

	localctx = NewDropTriggerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 124, CqlParserRULE_dropTrigger)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1214)
		p.KwDrop()
	}
	{
		p.SetState(1215)
		p.KwTrigger()
	}
	p.SetState(1217)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(1216)
			p.IfExist()
		}

	}
	{
		p.SetState(1219)
		p.Trigger()
	}
	{
		p.SetState(1220)
		p.KwOn()
	}
	p.SetState(1224)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 76, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1221)
			p.Keyspace()
		}
		{
			p.SetState(1222)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1226)
		p.Table()
	}

	return localctx
}

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

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

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

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

func NewEmptyDropRoleContext() *DropRoleContext {
	var p = new(DropRoleContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_dropRole
	return p
}

func (*DropRoleContext) IsDropRoleContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_dropRole

	return p
}

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

func (s *DropRoleContext) KwDrop() IKwDropContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDropContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDropContext)
}

func (s *DropRoleContext) KwRole() IKwRoleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwRoleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwRoleContext)
}

func (s *DropRoleContext) Role() IRoleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRoleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRoleContext)
}

func (s *DropRoleContext) IfExist() IIfExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfExistContext)
}

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

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

func (s *DropRoleContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDropRole(s)
	}
}

func (s *DropRoleContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDropRole(s)
	}
}

func (p *CqlParser) DropRole() (localctx IDropRoleContext) {
	this := p
	_ = this

	localctx = NewDropRoleContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 126, CqlParserRULE_dropRole)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1228)
		p.KwDrop()
	}
	{
		p.SetState(1229)
		p.KwRole()
	}
	p.SetState(1231)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(1230)
			p.IfExist()
		}

	}
	{
		p.SetState(1233)
		p.Role()
	}

	return localctx
}

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

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

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

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

func NewEmptyDropTableContext() *DropTableContext {
	var p = new(DropTableContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_dropTable
	return p
}

func (*DropTableContext) IsDropTableContext() {}

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

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

	p.parser = parser
	p.RuleIndex = CqlParserRULE_dropTable

	return p
}

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

func (s *DropTableContext) KwDrop() IKwDropContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDropContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDropContext)
}

func (s *DropTableContext) KwTable() IKwTableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwTableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwTableContext)
}

func (s *DropTableContext) Table() ITableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableContext)
}

func (s *DropTableContext) IfExist() IIfExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfExistContext)
}

func (s *DropTableContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *DropTableContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

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

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

func (s *DropTableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDropTable(s)
	}
}

func (s *DropTableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDropTable(s)
	}
}

func (p *CqlParser) DropTable() (localctx IDropTableContext) {
	this := p
	_ = this

	localctx = NewDropTableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 128, CqlParserRULE_dropTable)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1235)
		p.KwDrop()
	}
	{
		p.SetState(1236)
		p.KwTable()
	}
	p.SetState(1238)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(1237)
			p.IfExist()
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 79, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1240)
			p.Keyspace()
		}
		{
			p.SetState(1241)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1245)
		p.Table()
	}

	return localctx
}

// IDropKeyspaceContext is an interface to support dynamic dispatch.
type IDropKeyspaceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDropKeyspaceContext differentiates from other interfaces.
	IsDropKeyspaceContext()
}

type DropKeyspaceContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDropKeyspaceContext() *DropKeyspaceContext {
	var p = new(DropKeyspaceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_dropKeyspace
	return p
}

func (*DropKeyspaceContext) IsDropKeyspaceContext() {}

func NewDropKeyspaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropKeyspaceContext {
	var p = new(DropKeyspaceContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_dropKeyspace

	return p
}

func (s *DropKeyspaceContext) GetParser() antlr.Parser { return s.parser }

func (s *DropKeyspaceContext) KwDrop() IKwDropContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDropContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDropContext)
}

func (s *DropKeyspaceContext) KwKeyspace() IKwKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwKeyspaceContext)
}

func (s *DropKeyspaceContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *DropKeyspaceContext) IfExist() IIfExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfExistContext)
}

func (s *DropKeyspaceContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DropKeyspaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DropKeyspaceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDropKeyspace(s)
	}
}

func (s *DropKeyspaceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDropKeyspace(s)
	}
}

func (p *CqlParser) DropKeyspace() (localctx IDropKeyspaceContext) {
	this := p
	_ = this

	localctx = NewDropKeyspaceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 130, CqlParserRULE_dropKeyspace)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1247)
		p.KwDrop()
	}
	{
		p.SetState(1248)
		p.KwKeyspace()
	}
	p.SetState(1250)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(1249)
			p.IfExist()
		}

	}
	{
		p.SetState(1252)
		p.Keyspace()
	}

	return localctx
}

// IDropIndexContext is an interface to support dynamic dispatch.
type IDropIndexContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDropIndexContext differentiates from other interfaces.
	IsDropIndexContext()
}

type DropIndexContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDropIndexContext() *DropIndexContext {
	var p = new(DropIndexContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_dropIndex
	return p
}

func (*DropIndexContext) IsDropIndexContext() {}

func NewDropIndexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropIndexContext {
	var p = new(DropIndexContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_dropIndex

	return p
}

func (s *DropIndexContext) GetParser() antlr.Parser { return s.parser }

func (s *DropIndexContext) KwDrop() IKwDropContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDropContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDropContext)
}

func (s *DropIndexContext) KwIndex() IKwIndexContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwIndexContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwIndexContext)
}

func (s *DropIndexContext) IndexName() IIndexNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndexNameContext)
}

func (s *DropIndexContext) IfExist() IIfExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfExistContext)
}

func (s *DropIndexContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *DropIndexContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

func (s *DropIndexContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DropIndexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DropIndexContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDropIndex(s)
	}
}

func (s *DropIndexContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDropIndex(s)
	}
}

func (p *CqlParser) DropIndex() (localctx IDropIndexContext) {
	this := p
	_ = this

	localctx = NewDropIndexContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 132, CqlParserRULE_dropIndex)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1254)
		p.KwDrop()
	}
	{
		p.SetState(1255)
		p.KwIndex()
	}
	p.SetState(1257)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(1256)
			p.IfExist()
		}

	}
	p.SetState(1262)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 82, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1259)
			p.Keyspace()
		}
		{
			p.SetState(1260)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1264)
		p.IndexName()
	}

	return localctx
}

// ICreateTableContext is an interface to support dynamic dispatch.
type ICreateTableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCreateTableContext differentiates from other interfaces.
	IsCreateTableContext()
}

type CreateTableContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateTableContext() *CreateTableContext {
	var p = new(CreateTableContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_createTable
	return p
}

func (*CreateTableContext) IsCreateTableContext() {}

func NewCreateTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateTableContext {
	var p = new(CreateTableContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_createTable

	return p
}

func (s *CreateTableContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateTableContext) KwCreate() IKwCreateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwCreateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwCreateContext)
}

func (s *CreateTableContext) KwTable() IKwTableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwTableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwTableContext)
}

func (s *CreateTableContext) Table() ITableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableContext)
}

func (s *CreateTableContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *CreateTableContext) ColumnDefinitionList() IColumnDefinitionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnDefinitionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumnDefinitionListContext)
}

func (s *CreateTableContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *CreateTableContext) IfNotExist() IIfNotExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfNotExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfNotExistContext)
}

func (s *CreateTableContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *CreateTableContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

func (s *CreateTableContext) WithElement() IWithElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWithElementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWithElementContext)
}

func (s *CreateTableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateTableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCreateTable(s)
	}
}

func (s *CreateTableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCreateTable(s)
	}
}

func (p *CqlParser) CreateTable() (localctx ICreateTableContext) {
	this := p
	_ = this

	localctx = NewCreateTableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 134, CqlParserRULE_createTable)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1266)
		p.KwCreate()
	}
	{
		p.SetState(1267)
		p.KwTable()
	}
	p.SetState(1269)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(1268)
			p.IfNotExist()
		}

	}
	p.SetState(1274)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 84, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1271)
			p.Keyspace()
		}
		{
			p.SetState(1272)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1276)
		p.Table()
	}
	{
		p.SetState(1277)
		p.SyntaxBracketLr()
	}
	{
		p.SetState(1278)
		p.ColumnDefinitionList()
	}
	{
		p.SetState(1279)
		p.SyntaxBracketRr()
	}
	p.SetState(1281)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_WITH {
		{
			p.SetState(1280)
			p.WithElement()
		}

	}

	return localctx
}

// IWithElementContext is an interface to support dynamic dispatch.
type IWithElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWithElementContext differentiates from other interfaces.
	IsWithElementContext()
}

type WithElementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWithElementContext() *WithElementContext {
	var p = new(WithElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_withElement
	return p
}

func (*WithElementContext) IsWithElementContext() {}

func NewWithElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WithElementContext {
	var p = new(WithElementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_withElement

	return p
}

func (s *WithElementContext) GetParser() antlr.Parser { return s.parser }

func (s *WithElementContext) KwWith() IKwWithContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwWithContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwWithContext)
}

func (s *WithElementContext) TableOptions() ITableOptionsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableOptionsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableOptionsContext)
}

func (s *WithElementContext) ClusteringOrder() IClusteringOrderContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClusteringOrderContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClusteringOrderContext)
}

func (s *WithElementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *WithElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *WithElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterWithElement(s)
	}
}

func (s *WithElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitWithElement(s)
	}
}

func (p *CqlParser) WithElement() (localctx IWithElementContext) {
	this := p
	_ = this

	localctx = NewWithElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 136, CqlParserRULE_withElement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1283)
		p.KwWith()
	}
	p.SetState(1285)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserOBJECT_NAME {
		{
			p.SetState(1284)
			p.TableOptions()
		}

	}
	p.SetState(1288)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_CLUSTERING {
		{
			p.SetState(1287)
			p.ClusteringOrder()
		}

	}

	return localctx
}

// IClusteringOrderContext is an interface to support dynamic dispatch.
type IClusteringOrderContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClusteringOrderContext differentiates from other interfaces.
	IsClusteringOrderContext()
}

type ClusteringOrderContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClusteringOrderContext() *ClusteringOrderContext {
	var p = new(ClusteringOrderContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_clusteringOrder
	return p
}

func (*ClusteringOrderContext) IsClusteringOrderContext() {}

func NewClusteringOrderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClusteringOrderContext {
	var p = new(ClusteringOrderContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_clusteringOrder

	return p
}

func (s *ClusteringOrderContext) GetParser() antlr.Parser { return s.parser }

func (s *ClusteringOrderContext) KwClustering() IKwClusteringContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwClusteringContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwClusteringContext)
}

func (s *ClusteringOrderContext) KwOrder() IKwOrderContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwOrderContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwOrderContext)
}

func (s *ClusteringOrderContext) KwBy() IKwByContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwByContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwByContext)
}

func (s *ClusteringOrderContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *ClusteringOrderContext) Column() IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *ClusteringOrderContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *ClusteringOrderContext) OrderDirection() IOrderDirectionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrderDirectionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOrderDirectionContext)
}

func (s *ClusteringOrderContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClusteringOrderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClusteringOrderContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterClusteringOrder(s)
	}
}

func (s *ClusteringOrderContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitClusteringOrder(s)
	}
}

func (p *CqlParser) ClusteringOrder() (localctx IClusteringOrderContext) {
	this := p
	_ = this

	localctx = NewClusteringOrderContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 138, CqlParserRULE_clusteringOrder)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1290)
		p.KwClustering()
	}
	{
		p.SetState(1291)
		p.KwOrder()
	}
	{
		p.SetState(1292)
		p.KwBy()
	}
	{
		p.SetState(1293)
		p.SyntaxBracketLr()
	}
	{
		p.SetState(1294)
		p.Column()
	}
	p.SetState(1296)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_ASC || _la == CqlParserK_DESC {
		{
			p.SetState(1295)
			p.OrderDirection()
		}

	}
	{
		p.SetState(1298)
		p.SyntaxBracketRr()
	}

	return localctx
}

// ITableOptionsContext is an interface to support dynamic dispatch.
type ITableOptionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTableOptionsContext differentiates from other interfaces.
	IsTableOptionsContext()
}

type TableOptionsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTableOptionsContext() *TableOptionsContext {
	var p = new(TableOptionsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_tableOptions
	return p
}

func (*TableOptionsContext) IsTableOptionsContext() {}

func NewTableOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableOptionsContext {
	var p = new(TableOptionsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_tableOptions

	return p
}

func (s *TableOptionsContext) GetParser() antlr.Parser { return s.parser }

func (s *TableOptionsContext) AllTableOptionItem() []ITableOptionItemContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITableOptionItemContext)(nil)).Elem())
	var tst = make([]ITableOptionItemContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ITableOptionItemContext)
		}
	}

	return tst
}

func (s *TableOptionsContext) TableOptionItem(i int) ITableOptionItemContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableOptionItemContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITableOptionItemContext)
}

func (s *TableOptionsContext) AllKwAnd() []IKwAndContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IKwAndContext)(nil)).Elem())
	var tst = make([]IKwAndContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IKwAndContext)
		}
	}

	return tst
}

func (s *TableOptionsContext) KwAnd(i int) IKwAndContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAndContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IKwAndContext)
}

func (s *TableOptionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TableOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TableOptionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterTableOptions(s)
	}
}

func (s *TableOptionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitTableOptions(s)
	}
}

func (p *CqlParser) TableOptions() (localctx ITableOptionsContext) {
	this := p
	_ = this

	localctx = NewTableOptionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 140, CqlParserRULE_tableOptions)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != 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(1300)
		p.TableOptionItem()
	}
	p.SetState(1306)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 89, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1301)
				p.KwAnd()
			}
			{
				p.SetState(1302)
				p.TableOptionItem()
			}

		}
		p.SetState(1308)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 89, p.GetParserRuleContext())
	}

	return localctx
}

// ITableOptionItemContext is an interface to support dynamic dispatch.
type ITableOptionItemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTableOptionItemContext differentiates from other interfaces.
	IsTableOptionItemContext()
}

type TableOptionItemContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTableOptionItemContext() *TableOptionItemContext {
	var p = new(TableOptionItemContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_tableOptionItem
	return p
}

func (*TableOptionItemContext) IsTableOptionItemContext() {}

func NewTableOptionItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableOptionItemContext {
	var p = new(TableOptionItemContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_tableOptionItem

	return p
}

func (s *TableOptionItemContext) GetParser() antlr.Parser { return s.parser }

func (s *TableOptionItemContext) TableOptionName() ITableOptionNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableOptionNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableOptionNameContext)
}

func (s *TableOptionItemContext) OPERATOR_EQ() antlr.TerminalNode {
	return s.GetToken(CqlParserOPERATOR_EQ, 0)
}

func (s *TableOptionItemContext) TableOptionValue() ITableOptionValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableOptionValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableOptionValueContext)
}

func (s *TableOptionItemContext) OptionHash() IOptionHashContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOptionHashContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOptionHashContext)
}

func (s *TableOptionItemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TableOptionItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TableOptionItemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterTableOptionItem(s)
	}
}

func (s *TableOptionItemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitTableOptionItem(s)
	}
}

func (p *CqlParser) TableOptionItem() (localctx ITableOptionItemContext) {
	this := p
	_ = this

	localctx = NewTableOptionItemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 142, CqlParserRULE_tableOptionItem)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1317)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 90, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1309)
			p.TableOptionName()
		}
		{
			p.SetState(1310)
			p.Match(CqlParserOPERATOR_EQ)
		}
		{
			p.SetState(1311)
			p.TableOptionValue()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1313)
			p.TableOptionName()
		}
		{
			p.SetState(1314)
			p.Match(CqlParserOPERATOR_EQ)
		}
		{
			p.SetState(1315)
			p.OptionHash()
		}

	}

	return localctx
}

// ITableOptionNameContext is an interface to support dynamic dispatch.
type ITableOptionNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTableOptionNameContext differentiates from other interfaces.
	IsTableOptionNameContext()
}

type TableOptionNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTableOptionNameContext() *TableOptionNameContext {
	var p = new(TableOptionNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_tableOptionName
	return p
}

func (*TableOptionNameContext) IsTableOptionNameContext() {}

func NewTableOptionNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableOptionNameContext {
	var p = new(TableOptionNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_tableOptionName

	return p
}

func (s *TableOptionNameContext) GetParser() antlr.Parser { return s.parser }

func (s *TableOptionNameContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *TableOptionNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TableOptionNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TableOptionNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterTableOptionName(s)
	}
}

func (s *TableOptionNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitTableOptionName(s)
	}
}

func (p *CqlParser) TableOptionName() (localctx ITableOptionNameContext) {
	this := p
	_ = this

	localctx = NewTableOptionNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 144, CqlParserRULE_tableOptionName)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1319)
		p.Match(CqlParserOBJECT_NAME)
	}

	return localctx
}

// ITableOptionValueContext is an interface to support dynamic dispatch.
type ITableOptionValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTableOptionValueContext differentiates from other interfaces.
	IsTableOptionValueContext()
}

type TableOptionValueContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTableOptionValueContext() *TableOptionValueContext {
	var p = new(TableOptionValueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_tableOptionValue
	return p
}

func (*TableOptionValueContext) IsTableOptionValueContext() {}

func NewTableOptionValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableOptionValueContext {
	var p = new(TableOptionValueContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_tableOptionValue

	return p
}

func (s *TableOptionValueContext) GetParser() antlr.Parser { return s.parser }

func (s *TableOptionValueContext) StringLiteral() IStringLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStringLiteralContext)
}

func (s *TableOptionValueContext) FloatLiteral() IFloatLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFloatLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFloatLiteralContext)
}

func (s *TableOptionValueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TableOptionValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TableOptionValueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterTableOptionValue(s)
	}
}

func (s *TableOptionValueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitTableOptionValue(s)
	}
}

func (p *CqlParser) TableOptionValue() (localctx ITableOptionValueContext) {
	this := p
	_ = this

	localctx = NewTableOptionValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 146, CqlParserRULE_tableOptionValue)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1323)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserSTRING_LITERAL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1321)
			p.StringLiteral()
		}

	case CqlParserDECIMAL_LITERAL, CqlParserFLOAT_LITERAL:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1322)
			p.FloatLiteral()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IOptionHashContext is an interface to support dynamic dispatch.
type IOptionHashContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOptionHashContext differentiates from other interfaces.
	IsOptionHashContext()
}

type OptionHashContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptionHashContext() *OptionHashContext {
	var p = new(OptionHashContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_optionHash
	return p
}

func (*OptionHashContext) IsOptionHashContext() {}

func NewOptionHashContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionHashContext {
	var p = new(OptionHashContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_optionHash

	return p
}

func (s *OptionHashContext) GetParser() antlr.Parser { return s.parser }

func (s *OptionHashContext) SyntaxBracketLc() ISyntaxBracketLcContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLcContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLcContext)
}

func (s *OptionHashContext) AllOptionHashItem() []IOptionHashItemContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IOptionHashItemContext)(nil)).Elem())
	var tst = make([]IOptionHashItemContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IOptionHashItemContext)
		}
	}

	return tst
}

func (s *OptionHashContext) OptionHashItem(i int) IOptionHashItemContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOptionHashItemContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IOptionHashItemContext)
}

func (s *OptionHashContext) SyntaxBracketRc() ISyntaxBracketRcContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRcContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRcContext)
}

func (s *OptionHashContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *OptionHashContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *OptionHashContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptionHashContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptionHashContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterOptionHash(s)
	}
}

func (s *OptionHashContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitOptionHash(s)
	}
}

func (p *CqlParser) OptionHash() (localctx IOptionHashContext) {
	this := p
	_ = this

	localctx = NewOptionHashContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 148, CqlParserRULE_optionHash)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1325)
		p.SyntaxBracketLc()
	}
	{
		p.SetState(1326)
		p.OptionHashItem()
	}
	p.SetState(1332)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(1327)
			p.SyntaxComma()
		}
		{
			p.SetState(1328)
			p.OptionHashItem()
		}

		p.SetState(1334)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1335)
		p.SyntaxBracketRc()
	}

	return localctx
}

// IOptionHashItemContext is an interface to support dynamic dispatch.
type IOptionHashItemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOptionHashItemContext differentiates from other interfaces.
	IsOptionHashItemContext()
}

type OptionHashItemContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptionHashItemContext() *OptionHashItemContext {
	var p = new(OptionHashItemContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_optionHashItem
	return p
}

func (*OptionHashItemContext) IsOptionHashItemContext() {}

func NewOptionHashItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionHashItemContext {
	var p = new(OptionHashItemContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_optionHashItem

	return p
}

func (s *OptionHashItemContext) GetParser() antlr.Parser { return s.parser }

func (s *OptionHashItemContext) OptionHashKey() IOptionHashKeyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOptionHashKeyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOptionHashKeyContext)
}

func (s *OptionHashItemContext) COLON() antlr.TerminalNode {
	return s.GetToken(CqlParserCOLON, 0)
}

func (s *OptionHashItemContext) OptionHashValue() IOptionHashValueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOptionHashValueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOptionHashValueContext)
}

func (s *OptionHashItemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptionHashItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptionHashItemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterOptionHashItem(s)
	}
}

func (s *OptionHashItemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitOptionHashItem(s)
	}
}

func (p *CqlParser) OptionHashItem() (localctx IOptionHashItemContext) {
	this := p
	_ = this

	localctx = NewOptionHashItemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 150, CqlParserRULE_optionHashItem)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1337)
		p.OptionHashKey()
	}
	{
		p.SetState(1338)
		p.Match(CqlParserCOLON)
	}
	{
		p.SetState(1339)
		p.OptionHashValue()
	}

	return localctx
}

// IOptionHashKeyContext is an interface to support dynamic dispatch.
type IOptionHashKeyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOptionHashKeyContext differentiates from other interfaces.
	IsOptionHashKeyContext()
}

type OptionHashKeyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptionHashKeyContext() *OptionHashKeyContext {
	var p = new(OptionHashKeyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_optionHashKey
	return p
}

func (*OptionHashKeyContext) IsOptionHashKeyContext() {}

func NewOptionHashKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionHashKeyContext {
	var p = new(OptionHashKeyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_optionHashKey

	return p
}

func (s *OptionHashKeyContext) GetParser() antlr.Parser { return s.parser }

func (s *OptionHashKeyContext) StringLiteral() IStringLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStringLiteralContext)
}

func (s *OptionHashKeyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptionHashKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptionHashKeyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterOptionHashKey(s)
	}
}

func (s *OptionHashKeyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitOptionHashKey(s)
	}
}

func (p *CqlParser) OptionHashKey() (localctx IOptionHashKeyContext) {
	this := p
	_ = this

	localctx = NewOptionHashKeyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 152, CqlParserRULE_optionHashKey)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1341)
		p.StringLiteral()
	}

	return localctx
}

// IOptionHashValueContext is an interface to support dynamic dispatch.
type IOptionHashValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOptionHashValueContext differentiates from other interfaces.
	IsOptionHashValueContext()
}

type OptionHashValueContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOptionHashValueContext() *OptionHashValueContext {
	var p = new(OptionHashValueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_optionHashValue
	return p
}

func (*OptionHashValueContext) IsOptionHashValueContext() {}

func NewOptionHashValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionHashValueContext {
	var p = new(OptionHashValueContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_optionHashValue

	return p
}

func (s *OptionHashValueContext) GetParser() antlr.Parser { return s.parser }

func (s *OptionHashValueContext) StringLiteral() IStringLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStringLiteralContext)
}

func (s *OptionHashValueContext) FloatLiteral() IFloatLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFloatLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFloatLiteralContext)
}

func (s *OptionHashValueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OptionHashValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OptionHashValueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterOptionHashValue(s)
	}
}

func (s *OptionHashValueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitOptionHashValue(s)
	}
}

func (p *CqlParser) OptionHashValue() (localctx IOptionHashValueContext) {
	this := p
	_ = this

	localctx = NewOptionHashValueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 154, CqlParserRULE_optionHashValue)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1345)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserSTRING_LITERAL:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1343)
			p.StringLiteral()
		}

	case CqlParserDECIMAL_LITERAL, CqlParserFLOAT_LITERAL:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1344)
			p.FloatLiteral()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IColumnDefinitionListContext is an interface to support dynamic dispatch.
type IColumnDefinitionListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsColumnDefinitionListContext differentiates from other interfaces.
	IsColumnDefinitionListContext()
}

type ColumnDefinitionListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColumnDefinitionListContext() *ColumnDefinitionListContext {
	var p = new(ColumnDefinitionListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_columnDefinitionList
	return p
}

func (*ColumnDefinitionListContext) IsColumnDefinitionListContext() {}

func NewColumnDefinitionListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnDefinitionListContext {
	var p = new(ColumnDefinitionListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_columnDefinitionList

	return p
}

func (s *ColumnDefinitionListContext) GetParser() antlr.Parser { return s.parser }

func (s *ColumnDefinitionListContext) AllColumnDefinition() []IColumnDefinitionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumnDefinitionContext)(nil)).Elem())
	var tst = make([]IColumnDefinitionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IColumnDefinitionContext)
		}
	}

	return tst
}

func (s *ColumnDefinitionListContext) ColumnDefinition(i int) IColumnDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnDefinitionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumnDefinitionContext)
}

func (s *ColumnDefinitionListContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *ColumnDefinitionListContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *ColumnDefinitionListContext) PrimaryKeyElement() IPrimaryKeyElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryKeyElementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryKeyElementContext)
}

func (s *ColumnDefinitionListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ColumnDefinitionListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ColumnDefinitionListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterColumnDefinitionList(s)
	}
}

func (s *ColumnDefinitionListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitColumnDefinitionList(s)
	}
}

func (p *CqlParser) ColumnDefinitionList() (localctx IColumnDefinitionListContext) {
	this := p
	_ = this

	localctx = NewColumnDefinitionListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 156, CqlParserRULE_columnDefinitionList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != 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(1347)
		p.ColumnDefinition()
	}

	p.SetState(1353)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 94, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1348)
				p.SyntaxComma()
			}
			{
				p.SetState(1349)
				p.ColumnDefinition()
			}

		}
		p.SetState(1355)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 94, p.GetParserRuleContext())
	}
	p.SetState(1359)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserCOMMA {
		{
			p.SetState(1356)
			p.SyntaxComma()
		}
		{
			p.SetState(1357)
			p.PrimaryKeyElement()
		}

	}

	return localctx
}

// IColumnDefinitionContext is an interface to support dynamic dispatch.
type IColumnDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsColumnDefinitionContext differentiates from other interfaces.
	IsColumnDefinitionContext()
}

type ColumnDefinitionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColumnDefinitionContext() *ColumnDefinitionContext {
	var p = new(ColumnDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_columnDefinition
	return p
}

func (*ColumnDefinitionContext) IsColumnDefinitionContext() {}

func NewColumnDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnDefinitionContext {
	var p = new(ColumnDefinitionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_columnDefinition

	return p
}

func (s *ColumnDefinitionContext) GetParser() antlr.Parser { return s.parser }

func (s *ColumnDefinitionContext) Column() IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *ColumnDefinitionContext) DataType() IDataTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDataTypeContext)
}

func (s *ColumnDefinitionContext) PrimaryKeyColumn() IPrimaryKeyColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryKeyColumnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryKeyColumnContext)
}

func (s *ColumnDefinitionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ColumnDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ColumnDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterColumnDefinition(s)
	}
}

func (s *ColumnDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitColumnDefinition(s)
	}
}

func (p *CqlParser) ColumnDefinition() (localctx IColumnDefinitionContext) {
	this := p
	_ = this

	localctx = NewColumnDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 158, CqlParserRULE_columnDefinition)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1361)
		p.Column()
	}
	{
		p.SetState(1362)
		p.DataType()
	}
	p.SetState(1364)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_PRIMARY {
		{
			p.SetState(1363)
			p.PrimaryKeyColumn()
		}

	}

	return localctx
}

// IPrimaryKeyColumnContext is an interface to support dynamic dispatch.
type IPrimaryKeyColumnContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimaryKeyColumnContext differentiates from other interfaces.
	IsPrimaryKeyColumnContext()
}

type PrimaryKeyColumnContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimaryKeyColumnContext() *PrimaryKeyColumnContext {
	var p = new(PrimaryKeyColumnContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_primaryKeyColumn
	return p
}

func (*PrimaryKeyColumnContext) IsPrimaryKeyColumnContext() {}

func NewPrimaryKeyColumnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryKeyColumnContext {
	var p = new(PrimaryKeyColumnContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_primaryKeyColumn

	return p
}

func (s *PrimaryKeyColumnContext) GetParser() antlr.Parser { return s.parser }

func (s *PrimaryKeyColumnContext) KwPrimary() IKwPrimaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwPrimaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwPrimaryContext)
}

func (s *PrimaryKeyColumnContext) KwKey() IKwKeyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwKeyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwKeyContext)
}

func (s *PrimaryKeyColumnContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimaryKeyColumnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimaryKeyColumnContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterPrimaryKeyColumn(s)
	}
}

func (s *PrimaryKeyColumnContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitPrimaryKeyColumn(s)
	}
}

func (p *CqlParser) PrimaryKeyColumn() (localctx IPrimaryKeyColumnContext) {
	this := p
	_ = this

	localctx = NewPrimaryKeyColumnContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 160, CqlParserRULE_primaryKeyColumn)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1366)
		p.KwPrimary()
	}
	{
		p.SetState(1367)
		p.KwKey()
	}

	return localctx
}

// IPrimaryKeyElementContext is an interface to support dynamic dispatch.
type IPrimaryKeyElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimaryKeyElementContext differentiates from other interfaces.
	IsPrimaryKeyElementContext()
}

type PrimaryKeyElementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimaryKeyElementContext() *PrimaryKeyElementContext {
	var p = new(PrimaryKeyElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_primaryKeyElement
	return p
}

func (*PrimaryKeyElementContext) IsPrimaryKeyElementContext() {}

func NewPrimaryKeyElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryKeyElementContext {
	var p = new(PrimaryKeyElementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_primaryKeyElement

	return p
}

func (s *PrimaryKeyElementContext) GetParser() antlr.Parser { return s.parser }

func (s *PrimaryKeyElementContext) KwPrimary() IKwPrimaryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwPrimaryContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwPrimaryContext)
}

func (s *PrimaryKeyElementContext) KwKey() IKwKeyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwKeyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwKeyContext)
}

func (s *PrimaryKeyElementContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *PrimaryKeyElementContext) PrimaryKeyDefinition() IPrimaryKeyDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPrimaryKeyDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPrimaryKeyDefinitionContext)
}

func (s *PrimaryKeyElementContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *PrimaryKeyElementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimaryKeyElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimaryKeyElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterPrimaryKeyElement(s)
	}
}

func (s *PrimaryKeyElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitPrimaryKeyElement(s)
	}
}

func (p *CqlParser) PrimaryKeyElement() (localctx IPrimaryKeyElementContext) {
	this := p
	_ = this

	localctx = NewPrimaryKeyElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 162, CqlParserRULE_primaryKeyElement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1369)
		p.KwPrimary()
	}
	{
		p.SetState(1370)
		p.KwKey()
	}
	{
		p.SetState(1371)
		p.SyntaxBracketLr()
	}
	{
		p.SetState(1372)
		p.PrimaryKeyDefinition()
	}
	{
		p.SetState(1373)
		p.SyntaxBracketRr()
	}

	return localctx
}

// IPrimaryKeyDefinitionContext is an interface to support dynamic dispatch.
type IPrimaryKeyDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimaryKeyDefinitionContext differentiates from other interfaces.
	IsPrimaryKeyDefinitionContext()
}

type PrimaryKeyDefinitionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPrimaryKeyDefinitionContext() *PrimaryKeyDefinitionContext {
	var p = new(PrimaryKeyDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_primaryKeyDefinition
	return p
}

func (*PrimaryKeyDefinitionContext) IsPrimaryKeyDefinitionContext() {}

func NewPrimaryKeyDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryKeyDefinitionContext {
	var p = new(PrimaryKeyDefinitionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_primaryKeyDefinition

	return p
}

func (s *PrimaryKeyDefinitionContext) GetParser() antlr.Parser { return s.parser }

func (s *PrimaryKeyDefinitionContext) SinglePrimaryKey() ISinglePrimaryKeyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISinglePrimaryKeyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISinglePrimaryKeyContext)
}

func (s *PrimaryKeyDefinitionContext) CompoundKey() ICompoundKeyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompoundKeyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICompoundKeyContext)
}

func (s *PrimaryKeyDefinitionContext) CompositeKey() ICompositeKeyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompositeKeyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICompositeKeyContext)
}

func (s *PrimaryKeyDefinitionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PrimaryKeyDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PrimaryKeyDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterPrimaryKeyDefinition(s)
	}
}

func (s *PrimaryKeyDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitPrimaryKeyDefinition(s)
	}
}

func (p *CqlParser) PrimaryKeyDefinition() (localctx IPrimaryKeyDefinitionContext) {
	this := p
	_ = this

	localctx = NewPrimaryKeyDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 164, CqlParserRULE_primaryKeyDefinition)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1378)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 97, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1375)
			p.SinglePrimaryKey()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1376)
			p.CompoundKey()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1377)
			p.CompositeKey()
		}

	}

	return localctx
}

// ISinglePrimaryKeyContext is an interface to support dynamic dispatch.
type ISinglePrimaryKeyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSinglePrimaryKeyContext differentiates from other interfaces.
	IsSinglePrimaryKeyContext()
}

type SinglePrimaryKeyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySinglePrimaryKeyContext() *SinglePrimaryKeyContext {
	var p = new(SinglePrimaryKeyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_singlePrimaryKey
	return p
}

func (*SinglePrimaryKeyContext) IsSinglePrimaryKeyContext() {}

func NewSinglePrimaryKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SinglePrimaryKeyContext {
	var p = new(SinglePrimaryKeyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_singlePrimaryKey

	return p
}

func (s *SinglePrimaryKeyContext) GetParser() antlr.Parser { return s.parser }

func (s *SinglePrimaryKeyContext) Column() IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *SinglePrimaryKeyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SinglePrimaryKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SinglePrimaryKeyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterSinglePrimaryKey(s)
	}
}

func (s *SinglePrimaryKeyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitSinglePrimaryKey(s)
	}
}

func (p *CqlParser) SinglePrimaryKey() (localctx ISinglePrimaryKeyContext) {
	this := p
	_ = this

	localctx = NewSinglePrimaryKeyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 166, CqlParserRULE_singlePrimaryKey)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1380)
		p.Column()
	}

	return localctx
}

// ICompoundKeyContext is an interface to support dynamic dispatch.
type ICompoundKeyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCompoundKeyContext differentiates from other interfaces.
	IsCompoundKeyContext()
}

type CompoundKeyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCompoundKeyContext() *CompoundKeyContext {
	var p = new(CompoundKeyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_compoundKey
	return p
}

func (*CompoundKeyContext) IsCompoundKeyContext() {}

func NewCompoundKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompoundKeyContext {
	var p = new(CompoundKeyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_compoundKey

	return p
}

func (s *CompoundKeyContext) GetParser() antlr.Parser { return s.parser }

func (s *CompoundKeyContext) PartitionKey() IPartitionKeyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPartitionKeyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPartitionKeyContext)
}

func (s *CompoundKeyContext) SyntaxComma() ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *CompoundKeyContext) ClusteringKeyList() IClusteringKeyListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClusteringKeyListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClusteringKeyListContext)
}

func (s *CompoundKeyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CompoundKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CompoundKeyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCompoundKey(s)
	}
}

func (s *CompoundKeyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCompoundKey(s)
	}
}

func (p *CqlParser) CompoundKey() (localctx ICompoundKeyContext) {
	this := p
	_ = this

	localctx = NewCompoundKeyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 168, CqlParserRULE_compoundKey)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1382)
		p.PartitionKey()
	}

	{
		p.SetState(1383)
		p.SyntaxComma()
	}
	{
		p.SetState(1384)
		p.ClusteringKeyList()
	}

	return localctx
}

// ICompositeKeyContext is an interface to support dynamic dispatch.
type ICompositeKeyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCompositeKeyContext differentiates from other interfaces.
	IsCompositeKeyContext()
}

type CompositeKeyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCompositeKeyContext() *CompositeKeyContext {
	var p = new(CompositeKeyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_compositeKey
	return p
}

func (*CompositeKeyContext) IsCompositeKeyContext() {}

func NewCompositeKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompositeKeyContext {
	var p = new(CompositeKeyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_compositeKey

	return p
}

func (s *CompositeKeyContext) GetParser() antlr.Parser { return s.parser }

func (s *CompositeKeyContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *CompositeKeyContext) PartitionKeyList() IPartitionKeyListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPartitionKeyListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPartitionKeyListContext)
}

func (s *CompositeKeyContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *CompositeKeyContext) SyntaxComma() ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *CompositeKeyContext) ClusteringKeyList() IClusteringKeyListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClusteringKeyListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IClusteringKeyListContext)
}

func (s *CompositeKeyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CompositeKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CompositeKeyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCompositeKey(s)
	}
}

func (s *CompositeKeyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCompositeKey(s)
	}
}

func (p *CqlParser) CompositeKey() (localctx ICompositeKeyContext) {
	this := p
	_ = this

	localctx = NewCompositeKeyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 170, CqlParserRULE_compositeKey)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1386)
		p.SyntaxBracketLr()
	}
	{
		p.SetState(1387)
		p.PartitionKeyList()
	}
	{
		p.SetState(1388)
		p.SyntaxBracketRr()
	}

	{
		p.SetState(1389)
		p.SyntaxComma()
	}
	{
		p.SetState(1390)
		p.ClusteringKeyList()
	}

	return localctx
}

// IPartitionKeyListContext is an interface to support dynamic dispatch.
type IPartitionKeyListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPartitionKeyListContext differentiates from other interfaces.
	IsPartitionKeyListContext()
}

type PartitionKeyListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPartitionKeyListContext() *PartitionKeyListContext {
	var p = new(PartitionKeyListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_partitionKeyList
	return p
}

func (*PartitionKeyListContext) IsPartitionKeyListContext() {}

func NewPartitionKeyListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionKeyListContext {
	var p = new(PartitionKeyListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_partitionKeyList

	return p
}

func (s *PartitionKeyListContext) GetParser() antlr.Parser { return s.parser }

func (s *PartitionKeyListContext) AllPartitionKey() []IPartitionKeyContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IPartitionKeyContext)(nil)).Elem())
	var tst = make([]IPartitionKeyContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IPartitionKeyContext)
		}
	}

	return tst
}

func (s *PartitionKeyListContext) PartitionKey(i int) IPartitionKeyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPartitionKeyContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IPartitionKeyContext)
}

func (s *PartitionKeyListContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *PartitionKeyListContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *PartitionKeyListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PartitionKeyListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PartitionKeyListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterPartitionKeyList(s)
	}
}

func (s *PartitionKeyListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitPartitionKeyList(s)
	}
}

func (p *CqlParser) PartitionKeyList() (localctx IPartitionKeyListContext) {
	this := p
	_ = this

	localctx = NewPartitionKeyListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 172, CqlParserRULE_partitionKeyList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1392)
		p.PartitionKey()
	}

	p.SetState(1398)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(1393)
			p.SyntaxComma()
		}
		{
			p.SetState(1394)
			p.PartitionKey()
		}

		p.SetState(1400)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IClusteringKeyListContext is an interface to support dynamic dispatch.
type IClusteringKeyListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClusteringKeyListContext differentiates from other interfaces.
	IsClusteringKeyListContext()
}

type ClusteringKeyListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClusteringKeyListContext() *ClusteringKeyListContext {
	var p = new(ClusteringKeyListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_clusteringKeyList
	return p
}

func (*ClusteringKeyListContext) IsClusteringKeyListContext() {}

func NewClusteringKeyListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClusteringKeyListContext {
	var p = new(ClusteringKeyListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_clusteringKeyList

	return p
}

func (s *ClusteringKeyListContext) GetParser() antlr.Parser { return s.parser }

func (s *ClusteringKeyListContext) AllClusteringKey() []IClusteringKeyContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IClusteringKeyContext)(nil)).Elem())
	var tst = make([]IClusteringKeyContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IClusteringKeyContext)
		}
	}

	return tst
}

func (s *ClusteringKeyListContext) ClusteringKey(i int) IClusteringKeyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IClusteringKeyContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IClusteringKeyContext)
}

func (s *ClusteringKeyListContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *ClusteringKeyListContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *ClusteringKeyListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClusteringKeyListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClusteringKeyListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterClusteringKeyList(s)
	}
}

func (s *ClusteringKeyListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitClusteringKeyList(s)
	}
}

func (p *CqlParser) ClusteringKeyList() (localctx IClusteringKeyListContext) {
	this := p
	_ = this

	localctx = NewClusteringKeyListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 174, CqlParserRULE_clusteringKeyList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1401)
		p.ClusteringKey()
	}

	p.SetState(1407)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(1402)
			p.SyntaxComma()
		}
		{
			p.SetState(1403)
			p.ClusteringKey()
		}

		p.SetState(1409)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IPartitionKeyContext is an interface to support dynamic dispatch.
type IPartitionKeyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPartitionKeyContext differentiates from other interfaces.
	IsPartitionKeyContext()
}

type PartitionKeyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPartitionKeyContext() *PartitionKeyContext {
	var p = new(PartitionKeyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_partitionKey
	return p
}

func (*PartitionKeyContext) IsPartitionKeyContext() {}

func NewPartitionKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionKeyContext {
	var p = new(PartitionKeyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_partitionKey

	return p
}

func (s *PartitionKeyContext) GetParser() antlr.Parser { return s.parser }

func (s *PartitionKeyContext) Column() IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *PartitionKeyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PartitionKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PartitionKeyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterPartitionKey(s)
	}
}

func (s *PartitionKeyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitPartitionKey(s)
	}
}

func (p *CqlParser) PartitionKey() (localctx IPartitionKeyContext) {
	this := p
	_ = this

	localctx = NewPartitionKeyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 176, CqlParserRULE_partitionKey)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1410)
		p.Column()
	}

	return localctx
}

// IClusteringKeyContext is an interface to support dynamic dispatch.
type IClusteringKeyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClusteringKeyContext differentiates from other interfaces.
	IsClusteringKeyContext()
}

type ClusteringKeyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyClusteringKeyContext() *ClusteringKeyContext {
	var p = new(ClusteringKeyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_clusteringKey
	return p
}

func (*ClusteringKeyContext) IsClusteringKeyContext() {}

func NewClusteringKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClusteringKeyContext {
	var p = new(ClusteringKeyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_clusteringKey

	return p
}

func (s *ClusteringKeyContext) GetParser() antlr.Parser { return s.parser }

func (s *ClusteringKeyContext) Column() IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *ClusteringKeyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ClusteringKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ClusteringKeyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterClusteringKey(s)
	}
}

func (s *ClusteringKeyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitClusteringKey(s)
	}
}

func (p *CqlParser) ClusteringKey() (localctx IClusteringKeyContext) {
	this := p
	_ = this

	localctx = NewClusteringKeyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 178, CqlParserRULE_clusteringKey)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1412)
		p.Column()
	}

	return localctx
}

// IApplyBatchContext is an interface to support dynamic dispatch.
type IApplyBatchContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsApplyBatchContext differentiates from other interfaces.
	IsApplyBatchContext()
}

type ApplyBatchContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyApplyBatchContext() *ApplyBatchContext {
	var p = new(ApplyBatchContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_applyBatch
	return p
}

func (*ApplyBatchContext) IsApplyBatchContext() {}

func NewApplyBatchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ApplyBatchContext {
	var p = new(ApplyBatchContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_applyBatch

	return p
}

func (s *ApplyBatchContext) GetParser() antlr.Parser { return s.parser }

func (s *ApplyBatchContext) KwApply() IKwApplyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwApplyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwApplyContext)
}

func (s *ApplyBatchContext) KwBatch() IKwBatchContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwBatchContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwBatchContext)
}

func (s *ApplyBatchContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ApplyBatchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ApplyBatchContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterApplyBatch(s)
	}
}

func (s *ApplyBatchContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitApplyBatch(s)
	}
}

func (p *CqlParser) ApplyBatch() (localctx IApplyBatchContext) {
	this := p
	_ = this

	localctx = NewApplyBatchContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 180, CqlParserRULE_applyBatch)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1414)
		p.KwApply()
	}
	{
		p.SetState(1415)
		p.KwBatch()
	}

	return localctx
}

// IBeginBatchContext is an interface to support dynamic dispatch.
type IBeginBatchContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBeginBatchContext differentiates from other interfaces.
	IsBeginBatchContext()
}

type BeginBatchContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBeginBatchContext() *BeginBatchContext {
	var p = new(BeginBatchContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_beginBatch
	return p
}

func (*BeginBatchContext) IsBeginBatchContext() {}

func NewBeginBatchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BeginBatchContext {
	var p = new(BeginBatchContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_beginBatch

	return p
}

func (s *BeginBatchContext) GetParser() antlr.Parser { return s.parser }

func (s *BeginBatchContext) KwBegin() IKwBeginContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwBeginContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwBeginContext)
}

func (s *BeginBatchContext) KwBatch() IKwBatchContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwBatchContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwBatchContext)
}

func (s *BeginBatchContext) BatchType() IBatchTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBatchTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBatchTypeContext)
}

func (s *BeginBatchContext) UsingTimestampSpec() IUsingTimestampSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUsingTimestampSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUsingTimestampSpecContext)
}

func (s *BeginBatchContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BeginBatchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BeginBatchContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterBeginBatch(s)
	}
}

func (s *BeginBatchContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitBeginBatch(s)
	}
}

func (p *CqlParser) BeginBatch() (localctx IBeginBatchContext) {
	this := p
	_ = this

	localctx = NewBeginBatchContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 182, CqlParserRULE_beginBatch)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1417)
		p.KwBegin()
	}
	p.SetState(1419)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_LOGGED || _la == CqlParserK_UNLOGGED {
		{
			p.SetState(1418)
			p.BatchType()
		}

	}
	{
		p.SetState(1421)
		p.KwBatch()
	}
	p.SetState(1423)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_USING {
		{
			p.SetState(1422)
			p.UsingTimestampSpec()
		}

	}

	return localctx
}

// IBatchTypeContext is an interface to support dynamic dispatch.
type IBatchTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBatchTypeContext differentiates from other interfaces.
	IsBatchTypeContext()
}

type BatchTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBatchTypeContext() *BatchTypeContext {
	var p = new(BatchTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_batchType
	return p
}

func (*BatchTypeContext) IsBatchTypeContext() {}

func NewBatchTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BatchTypeContext {
	var p = new(BatchTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_batchType

	return p
}

func (s *BatchTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *BatchTypeContext) KwLogged() IKwLoggedContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwLoggedContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwLoggedContext)
}

func (s *BatchTypeContext) KwUnlogged() IKwUnloggedContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwUnloggedContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwUnloggedContext)
}

func (s *BatchTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BatchTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BatchTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterBatchType(s)
	}
}

func (s *BatchTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitBatchType(s)
	}
}

func (p *CqlParser) BatchType() (localctx IBatchTypeContext) {
	this := p
	_ = this

	localctx = NewBatchTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 184, CqlParserRULE_batchType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1427)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserK_LOGGED:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1425)
			p.KwLogged()
		}

	case CqlParserK_UNLOGGED:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1426)
			p.KwUnlogged()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IAlterKeyspaceContext is an interface to support dynamic dispatch.
type IAlterKeyspaceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlterKeyspaceContext differentiates from other interfaces.
	IsAlterKeyspaceContext()
}

type AlterKeyspaceContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAlterKeyspaceContext() *AlterKeyspaceContext {
	var p = new(AlterKeyspaceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_alterKeyspace
	return p
}

func (*AlterKeyspaceContext) IsAlterKeyspaceContext() {}

func NewAlterKeyspaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterKeyspaceContext {
	var p = new(AlterKeyspaceContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_alterKeyspace

	return p
}

func (s *AlterKeyspaceContext) GetParser() antlr.Parser { return s.parser }

func (s *AlterKeyspaceContext) KwAlter() IKwAlterContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAlterContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAlterContext)
}

func (s *AlterKeyspaceContext) KwKeyspace() IKwKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwKeyspaceContext)
}

func (s *AlterKeyspaceContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *AlterKeyspaceContext) KwWith() IKwWithContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwWithContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwWithContext)
}

func (s *AlterKeyspaceContext) KwReplication() IKwReplicationContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwReplicationContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwReplicationContext)
}

func (s *AlterKeyspaceContext) OPERATOR_EQ() antlr.TerminalNode {
	return s.GetToken(CqlParserOPERATOR_EQ, 0)
}

func (s *AlterKeyspaceContext) SyntaxBracketLc() ISyntaxBracketLcContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLcContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLcContext)
}

func (s *AlterKeyspaceContext) ReplicationList() IReplicationListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReplicationListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReplicationListContext)
}

func (s *AlterKeyspaceContext) SyntaxBracketRc() ISyntaxBracketRcContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRcContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRcContext)
}

func (s *AlterKeyspaceContext) KwAnd() IKwAndContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAndContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAndContext)
}

func (s *AlterKeyspaceContext) DurableWrites() IDurableWritesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDurableWritesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDurableWritesContext)
}

func (s *AlterKeyspaceContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AlterKeyspaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AlterKeyspaceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAlterKeyspace(s)
	}
}

func (s *AlterKeyspaceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAlterKeyspace(s)
	}
}

func (p *CqlParser) AlterKeyspace() (localctx IAlterKeyspaceContext) {
	this := p
	_ = this

	localctx = NewAlterKeyspaceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 186, CqlParserRULE_alterKeyspace)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1429)
		p.KwAlter()
	}
	{
		p.SetState(1430)
		p.KwKeyspace()
	}
	{
		p.SetState(1431)
		p.Keyspace()
	}
	{
		p.SetState(1432)
		p.KwWith()
	}
	{
		p.SetState(1433)
		p.KwReplication()
	}
	{
		p.SetState(1434)
		p.Match(CqlParserOPERATOR_EQ)
	}
	{
		p.SetState(1435)
		p.SyntaxBracketLc()
	}
	{
		p.SetState(1436)
		p.ReplicationList()
	}
	{
		p.SetState(1437)
		p.SyntaxBracketRc()
	}
	p.SetState(1441)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_AND {
		{
			p.SetState(1438)
			p.KwAnd()
		}
		{
			p.SetState(1439)
			p.DurableWrites()
		}

	}

	return localctx
}

// IReplicationListContext is an interface to support dynamic dispatch.
type IReplicationListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsReplicationListContext differentiates from other interfaces.
	IsReplicationListContext()
}

type ReplicationListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReplicationListContext() *ReplicationListContext {
	var p = new(ReplicationListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_replicationList
	return p
}

func (*ReplicationListContext) IsReplicationListContext() {}

func NewReplicationListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplicationListContext {
	var p = new(ReplicationListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_replicationList

	return p
}

func (s *ReplicationListContext) GetParser() antlr.Parser { return s.parser }

func (s *ReplicationListContext) AllReplicationListItem() []IReplicationListItemContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IReplicationListItemContext)(nil)).Elem())
	var tst = make([]IReplicationListItemContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IReplicationListItemContext)
		}
	}

	return tst
}

func (s *ReplicationListContext) ReplicationListItem(i int) IReplicationListItemContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReplicationListItemContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IReplicationListItemContext)
}

func (s *ReplicationListContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *ReplicationListContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *ReplicationListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ReplicationListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ReplicationListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterReplicationList(s)
	}
}

func (s *ReplicationListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitReplicationList(s)
	}
}

func (p *CqlParser) ReplicationList() (localctx IReplicationListContext) {
	this := p
	_ = this

	localctx = NewReplicationListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 188, CqlParserRULE_replicationList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1443)
		p.ReplicationListItem()
	}

	p.SetState(1449)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(1444)
			p.SyntaxComma()
		}
		{
			p.SetState(1445)
			p.ReplicationListItem()
		}

		p.SetState(1451)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IReplicationListItemContext is an interface to support dynamic dispatch.
type IReplicationListItemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsReplicationListItemContext differentiates from other interfaces.
	IsReplicationListItemContext()
}

type ReplicationListItemContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyReplicationListItemContext() *ReplicationListItemContext {
	var p = new(ReplicationListItemContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_replicationListItem
	return p
}

func (*ReplicationListItemContext) IsReplicationListItemContext() {}

func NewReplicationListItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplicationListItemContext {
	var p = new(ReplicationListItemContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_replicationListItem

	return p
}

func (s *ReplicationListItemContext) GetParser() antlr.Parser { return s.parser }

func (s *ReplicationListItemContext) AllSTRING_LITERAL() []antlr.TerminalNode {
	return s.GetTokens(CqlParserSTRING_LITERAL)
}

func (s *ReplicationListItemContext) STRING_LITERAL(i int) antlr.TerminalNode {
	return s.GetToken(CqlParserSTRING_LITERAL, i)
}

func (s *ReplicationListItemContext) COLON() antlr.TerminalNode {
	return s.GetToken(CqlParserCOLON, 0)
}

func (s *ReplicationListItemContext) DECIMAL_LITERAL() antlr.TerminalNode {
	return s.GetToken(CqlParserDECIMAL_LITERAL, 0)
}

func (s *ReplicationListItemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ReplicationListItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ReplicationListItemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterReplicationListItem(s)
	}
}

func (s *ReplicationListItemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitReplicationListItem(s)
	}
}

func (p *CqlParser) ReplicationListItem() (localctx IReplicationListItemContext) {
	this := p
	_ = this

	localctx = NewReplicationListItemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 190, CqlParserRULE_replicationListItem)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1458)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 105, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1452)
			p.Match(CqlParserSTRING_LITERAL)
		}
		{
			p.SetState(1453)
			p.Match(CqlParserCOLON)
		}
		{
			p.SetState(1454)
			p.Match(CqlParserSTRING_LITERAL)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1455)
			p.Match(CqlParserSTRING_LITERAL)
		}
		{
			p.SetState(1456)
			p.Match(CqlParserCOLON)
		}
		{
			p.SetState(1457)
			p.Match(CqlParserDECIMAL_LITERAL)
		}

	}

	return localctx
}

// IDurableWritesContext is an interface to support dynamic dispatch.
type IDurableWritesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDurableWritesContext differentiates from other interfaces.
	IsDurableWritesContext()
}

type DurableWritesContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDurableWritesContext() *DurableWritesContext {
	var p = new(DurableWritesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_durableWrites
	return p
}

func (*DurableWritesContext) IsDurableWritesContext() {}

func NewDurableWritesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DurableWritesContext {
	var p = new(DurableWritesContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_durableWrites

	return p
}

func (s *DurableWritesContext) GetParser() antlr.Parser { return s.parser }

func (s *DurableWritesContext) KwDurableWrites() IKwDurableWritesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDurableWritesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDurableWritesContext)
}

func (s *DurableWritesContext) OPERATOR_EQ() antlr.TerminalNode {
	return s.GetToken(CqlParserOPERATOR_EQ, 0)
}

func (s *DurableWritesContext) BooleanLiteral() IBooleanLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBooleanLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBooleanLiteralContext)
}

func (s *DurableWritesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DurableWritesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DurableWritesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDurableWrites(s)
	}
}

func (s *DurableWritesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDurableWrites(s)
	}
}

func (p *CqlParser) DurableWrites() (localctx IDurableWritesContext) {
	this := p
	_ = this

	localctx = NewDurableWritesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 192, CqlParserRULE_durableWrites)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1460)
		p.KwDurableWrites()
	}
	{
		p.SetState(1461)
		p.Match(CqlParserOPERATOR_EQ)
	}
	{
		p.SetState(1462)
		p.BooleanLiteral()
	}

	return localctx
}

// IUse_Context is an interface to support dynamic dispatch.
type IUse_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUse_Context differentiates from other interfaces.
	IsUse_Context()
}

type Use_Context struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUse_Context() *Use_Context {
	var p = new(Use_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_use_
	return p
}

func (*Use_Context) IsUse_Context() {}

func NewUse_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Use_Context {
	var p = new(Use_Context)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_use_

	return p
}

func (s *Use_Context) GetParser() antlr.Parser { return s.parser }

func (s *Use_Context) KwUse() IKwUseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwUseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwUseContext)
}

func (s *Use_Context) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *Use_Context) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Use_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Use_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterUse_(s)
	}
}

func (s *Use_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitUse_(s)
	}
}

func (p *CqlParser) Use_() (localctx IUse_Context) {
	this := p
	_ = this

	localctx = NewUse_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 194, CqlParserRULE_use_)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1464)
		p.KwUse()
	}
	{
		p.SetState(1465)
		p.Keyspace()
	}

	return localctx
}

// ITruncateContext is an interface to support dynamic dispatch.
type ITruncateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTruncateContext differentiates from other interfaces.
	IsTruncateContext()
}

type TruncateContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTruncateContext() *TruncateContext {
	var p = new(TruncateContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_truncate
	return p
}

func (*TruncateContext) IsTruncateContext() {}

func NewTruncateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TruncateContext {
	var p = new(TruncateContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_truncate

	return p
}

func (s *TruncateContext) GetParser() antlr.Parser { return s.parser }

func (s *TruncateContext) KwTruncate() IKwTruncateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwTruncateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwTruncateContext)
}

func (s *TruncateContext) Table() ITableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableContext)
}

func (s *TruncateContext) KwTable() IKwTableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwTableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwTableContext)
}

func (s *TruncateContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *TruncateContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

func (s *TruncateContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TruncateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TruncateContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterTruncate(s)
	}
}

func (s *TruncateContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitTruncate(s)
	}
}

func (p *CqlParser) Truncate() (localctx ITruncateContext) {
	this := p
	_ = this

	localctx = NewTruncateContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 196, CqlParserRULE_truncate)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1467)
		p.KwTruncate()
	}
	p.SetState(1469)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_TABLE {
		{
			p.SetState(1468)
			p.KwTable()
		}

	}
	p.SetState(1474)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 107, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1471)
			p.Keyspace()
		}
		{
			p.SetState(1472)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1476)
		p.Table()
	}

	return localctx
}

// ICreateIndexContext is an interface to support dynamic dispatch.
type ICreateIndexContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCreateIndexContext differentiates from other interfaces.
	IsCreateIndexContext()
}

type CreateIndexContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCreateIndexContext() *CreateIndexContext {
	var p = new(CreateIndexContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_createIndex
	return p
}

func (*CreateIndexContext) IsCreateIndexContext() {}

func NewCreateIndexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateIndexContext {
	var p = new(CreateIndexContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_createIndex

	return p
}

func (s *CreateIndexContext) GetParser() antlr.Parser { return s.parser }

func (s *CreateIndexContext) KwCreate() IKwCreateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwCreateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwCreateContext)
}

func (s *CreateIndexContext) KwIndex() IKwIndexContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwIndexContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwIndexContext)
}

func (s *CreateIndexContext) KwOn() IKwOnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwOnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwOnContext)
}

func (s *CreateIndexContext) Table() ITableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableContext)
}

func (s *CreateIndexContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *CreateIndexContext) IndexColumnSpec() IIndexColumnSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexColumnSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndexColumnSpecContext)
}

func (s *CreateIndexContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *CreateIndexContext) IfNotExist() IIfNotExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfNotExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfNotExistContext)
}

func (s *CreateIndexContext) IndexName() IIndexNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndexNameContext)
}

func (s *CreateIndexContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *CreateIndexContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

func (s *CreateIndexContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *CreateIndexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *CreateIndexContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterCreateIndex(s)
	}
}

func (s *CreateIndexContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitCreateIndex(s)
	}
}

func (p *CqlParser) CreateIndex() (localctx ICreateIndexContext) {
	this := p
	_ = this

	localctx = NewCreateIndexContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 198, CqlParserRULE_createIndex)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1478)
		p.KwCreate()
	}
	{
		p.SetState(1479)
		p.KwIndex()
	}
	p.SetState(1481)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(1480)
			p.IfNotExist()
		}

	}
	p.SetState(1484)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserSTRING_LITERAL || _la == CqlParserOBJECT_NAME {
		{
			p.SetState(1483)
			p.IndexName()
		}

	}
	{
		p.SetState(1486)
		p.KwOn()
	}
	p.SetState(1490)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 110, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1487)
			p.Keyspace()
		}
		{
			p.SetState(1488)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1492)
		p.Table()
	}
	{
		p.SetState(1493)
		p.SyntaxBracketLr()
	}
	{
		p.SetState(1494)
		p.IndexColumnSpec()
	}
	{
		p.SetState(1495)
		p.SyntaxBracketRr()
	}

	return localctx
}

// IIndexNameContext is an interface to support dynamic dispatch.
type IIndexNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIndexNameContext differentiates from other interfaces.
	IsIndexNameContext()
}

type IndexNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndexNameContext() *IndexNameContext {
	var p = new(IndexNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_indexName
	return p
}

func (*IndexNameContext) IsIndexNameContext() {}

func NewIndexNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexNameContext {
	var p = new(IndexNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_indexName

	return p
}

func (s *IndexNameContext) GetParser() antlr.Parser { return s.parser }

func (s *IndexNameContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *IndexNameContext) StringLiteral() IStringLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStringLiteralContext)
}

func (s *IndexNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IndexNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IndexNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterIndexName(s)
	}
}

func (s *IndexNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitIndexName(s)
	}
}

func (p *CqlParser) IndexName() (localctx IIndexNameContext) {
	this := p
	_ = this

	localctx = NewIndexNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 200, CqlParserRULE_indexName)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1499)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserOBJECT_NAME:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1497)
			p.Match(CqlParserOBJECT_NAME)
		}

	case CqlParserSTRING_LITERAL:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1498)
			p.StringLiteral()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IIndexColumnSpecContext is an interface to support dynamic dispatch.
type IIndexColumnSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIndexColumnSpecContext differentiates from other interfaces.
	IsIndexColumnSpecContext()
}

type IndexColumnSpecContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndexColumnSpecContext() *IndexColumnSpecContext {
	var p = new(IndexColumnSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_indexColumnSpec
	return p
}

func (*IndexColumnSpecContext) IsIndexColumnSpecContext() {}

func NewIndexColumnSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexColumnSpecContext {
	var p = new(IndexColumnSpecContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_indexColumnSpec

	return p
}

func (s *IndexColumnSpecContext) GetParser() antlr.Parser { return s.parser }

func (s *IndexColumnSpecContext) Column() IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *IndexColumnSpecContext) IndexKeysSpec() IIndexKeysSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexKeysSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndexKeysSpecContext)
}

func (s *IndexColumnSpecContext) IndexEntriesSSpec() IIndexEntriesSSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexEntriesSSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndexEntriesSSpecContext)
}

func (s *IndexColumnSpecContext) IndexFullSpec() IIndexFullSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexFullSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndexFullSpecContext)
}

func (s *IndexColumnSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IndexColumnSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IndexColumnSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterIndexColumnSpec(s)
	}
}

func (s *IndexColumnSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitIndexColumnSpec(s)
	}
}

func (p *CqlParser) IndexColumnSpec() (localctx IIndexColumnSpecContext) {
	this := p
	_ = this

	localctx = NewIndexColumnSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 202, CqlParserRULE_indexColumnSpec)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1505)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserDQUOTE, CqlParserOBJECT_NAME:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1501)
			p.Column()
		}

	case CqlParserK_KEYS:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1502)
			p.IndexKeysSpec()
		}

	case CqlParserK_ENTRIES:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1503)
			p.IndexEntriesSSpec()
		}

	case CqlParserK_FULL:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1504)
			p.IndexFullSpec()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IIndexKeysSpecContext is an interface to support dynamic dispatch.
type IIndexKeysSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIndexKeysSpecContext differentiates from other interfaces.
	IsIndexKeysSpecContext()
}

type IndexKeysSpecContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndexKeysSpecContext() *IndexKeysSpecContext {
	var p = new(IndexKeysSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_indexKeysSpec
	return p
}

func (*IndexKeysSpecContext) IsIndexKeysSpecContext() {}

func NewIndexKeysSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexKeysSpecContext {
	var p = new(IndexKeysSpecContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_indexKeysSpec

	return p
}

func (s *IndexKeysSpecContext) GetParser() antlr.Parser { return s.parser }

func (s *IndexKeysSpecContext) KwKeys() IKwKeysContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwKeysContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwKeysContext)
}

func (s *IndexKeysSpecContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *IndexKeysSpecContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *IndexKeysSpecContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *IndexKeysSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IndexKeysSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IndexKeysSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterIndexKeysSpec(s)
	}
}

func (s *IndexKeysSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitIndexKeysSpec(s)
	}
}

func (p *CqlParser) IndexKeysSpec() (localctx IIndexKeysSpecContext) {
	this := p
	_ = this

	localctx = NewIndexKeysSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 204, CqlParserRULE_indexKeysSpec)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1507)
		p.KwKeys()
	}
	{
		p.SetState(1508)
		p.SyntaxBracketLr()
	}
	{
		p.SetState(1509)
		p.Match(CqlParserOBJECT_NAME)
	}
	{
		p.SetState(1510)
		p.SyntaxBracketRr()
	}

	return localctx
}

// IIndexEntriesSSpecContext is an interface to support dynamic dispatch.
type IIndexEntriesSSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIndexEntriesSSpecContext differentiates from other interfaces.
	IsIndexEntriesSSpecContext()
}

type IndexEntriesSSpecContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndexEntriesSSpecContext() *IndexEntriesSSpecContext {
	var p = new(IndexEntriesSSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_indexEntriesSSpec
	return p
}

func (*IndexEntriesSSpecContext) IsIndexEntriesSSpecContext() {}

func NewIndexEntriesSSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexEntriesSSpecContext {
	var p = new(IndexEntriesSSpecContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_indexEntriesSSpec

	return p
}

func (s *IndexEntriesSSpecContext) GetParser() antlr.Parser { return s.parser }

func (s *IndexEntriesSSpecContext) KwEntries() IKwEntriesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwEntriesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwEntriesContext)
}

func (s *IndexEntriesSSpecContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *IndexEntriesSSpecContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *IndexEntriesSSpecContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *IndexEntriesSSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IndexEntriesSSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IndexEntriesSSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterIndexEntriesSSpec(s)
	}
}

func (s *IndexEntriesSSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitIndexEntriesSSpec(s)
	}
}

func (p *CqlParser) IndexEntriesSSpec() (localctx IIndexEntriesSSpecContext) {
	this := p
	_ = this

	localctx = NewIndexEntriesSSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 206, CqlParserRULE_indexEntriesSSpec)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1512)
		p.KwEntries()
	}
	{
		p.SetState(1513)
		p.SyntaxBracketLr()
	}
	{
		p.SetState(1514)
		p.Match(CqlParserOBJECT_NAME)
	}
	{
		p.SetState(1515)
		p.SyntaxBracketRr()
	}

	return localctx
}

// IIndexFullSpecContext is an interface to support dynamic dispatch.
type IIndexFullSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIndexFullSpecContext differentiates from other interfaces.
	IsIndexFullSpecContext()
}

type IndexFullSpecContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndexFullSpecContext() *IndexFullSpecContext {
	var p = new(IndexFullSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_indexFullSpec
	return p
}

func (*IndexFullSpecContext) IsIndexFullSpecContext() {}

func NewIndexFullSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexFullSpecContext {
	var p = new(IndexFullSpecContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_indexFullSpec

	return p
}

func (s *IndexFullSpecContext) GetParser() antlr.Parser { return s.parser }

func (s *IndexFullSpecContext) KwFull() IKwFullContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwFullContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwFullContext)
}

func (s *IndexFullSpecContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *IndexFullSpecContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *IndexFullSpecContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *IndexFullSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IndexFullSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IndexFullSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterIndexFullSpec(s)
	}
}

func (s *IndexFullSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitIndexFullSpec(s)
	}
}

func (p *CqlParser) IndexFullSpec() (localctx IIndexFullSpecContext) {
	this := p
	_ = this

	localctx = NewIndexFullSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 208, CqlParserRULE_indexFullSpec)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1517)
		p.KwFull()
	}
	{
		p.SetState(1518)
		p.SyntaxBracketLr()
	}
	{
		p.SetState(1519)
		p.Match(CqlParserOBJECT_NAME)
	}
	{
		p.SetState(1520)
		p.SyntaxBracketRr()
	}

	return localctx
}

// IDelete_Context is an interface to support dynamic dispatch.
type IDelete_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDelete_Context differentiates from other interfaces.
	IsDelete_Context()
}

type Delete_Context struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDelete_Context() *Delete_Context {
	var p = new(Delete_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_delete_
	return p
}

func (*Delete_Context) IsDelete_Context() {}

func NewDelete_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_Context {
	var p = new(Delete_Context)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_delete_

	return p
}

func (s *Delete_Context) GetParser() antlr.Parser { return s.parser }

func (s *Delete_Context) KwDelete() IKwDeleteContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDeleteContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDeleteContext)
}

func (s *Delete_Context) FromSpec() IFromSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFromSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFromSpecContext)
}

func (s *Delete_Context) WhereSpec() IWhereSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWhereSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWhereSpecContext)
}

func (s *Delete_Context) BeginBatch() IBeginBatchContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBeginBatchContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBeginBatchContext)
}

func (s *Delete_Context) DeleteColumnList() IDeleteColumnListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeleteColumnListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDeleteColumnListContext)
}

func (s *Delete_Context) UsingTimestampSpec() IUsingTimestampSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUsingTimestampSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUsingTimestampSpecContext)
}

func (s *Delete_Context) IfExist() IIfExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfExistContext)
}

func (s *Delete_Context) IfSpec() IIfSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfSpecContext)
}

func (s *Delete_Context) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Delete_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Delete_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDelete_(s)
	}
}

func (s *Delete_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDelete_(s)
	}
}

func (p *CqlParser) Delete_() (localctx IDelete_Context) {
	this := p
	_ = this

	localctx = NewDelete_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 210, CqlParserRULE_delete_)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1523)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_BEGIN {
		{
			p.SetState(1522)
			p.BeginBatch()
		}

	}
	{
		p.SetState(1525)
		p.KwDelete()
	}
	p.SetState(1527)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserOBJECT_NAME {
		{
			p.SetState(1526)
			p.DeleteColumnList()
		}

	}
	{
		p.SetState(1529)
		p.FromSpec()
	}
	p.SetState(1531)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_USING {
		{
			p.SetState(1530)
			p.UsingTimestampSpec()
		}

	}
	{
		p.SetState(1533)
		p.WhereSpec()
	}
	p.SetState(1536)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 116, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1534)
			p.IfExist()
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 116, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(1535)
			p.IfSpec()
		}

	}

	return localctx
}

// IDeleteColumnListContext is an interface to support dynamic dispatch.
type IDeleteColumnListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDeleteColumnListContext differentiates from other interfaces.
	IsDeleteColumnListContext()
}

type DeleteColumnListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDeleteColumnListContext() *DeleteColumnListContext {
	var p = new(DeleteColumnListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_deleteColumnList
	return p
}

func (*DeleteColumnListContext) IsDeleteColumnListContext() {}

func NewDeleteColumnListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeleteColumnListContext {
	var p = new(DeleteColumnListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_deleteColumnList

	return p
}

func (s *DeleteColumnListContext) GetParser() antlr.Parser { return s.parser }

func (s *DeleteColumnListContext) AllDeleteColumnItem() []IDeleteColumnItemContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDeleteColumnItemContext)(nil)).Elem())
	var tst = make([]IDeleteColumnItemContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IDeleteColumnItemContext)
		}
	}

	return tst
}

func (s *DeleteColumnListContext) DeleteColumnItem(i int) IDeleteColumnItemContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDeleteColumnItemContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDeleteColumnItemContext)
}

func (s *DeleteColumnListContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *DeleteColumnListContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *DeleteColumnListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DeleteColumnListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DeleteColumnListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDeleteColumnList(s)
	}
}

func (s *DeleteColumnListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDeleteColumnList(s)
	}
}

func (p *CqlParser) DeleteColumnList() (localctx IDeleteColumnListContext) {
	this := p
	_ = this

	localctx = NewDeleteColumnListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 212, CqlParserRULE_deleteColumnList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1538)
		p.DeleteColumnItem()
	}

	p.SetState(1544)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(1539)
			p.SyntaxComma()
		}
		{
			p.SetState(1540)
			p.DeleteColumnItem()
		}

		p.SetState(1546)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IDeleteColumnItemContext is an interface to support dynamic dispatch.
type IDeleteColumnItemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDeleteColumnItemContext differentiates from other interfaces.
	IsDeleteColumnItemContext()
}

type DeleteColumnItemContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDeleteColumnItemContext() *DeleteColumnItemContext {
	var p = new(DeleteColumnItemContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_deleteColumnItem
	return p
}

func (*DeleteColumnItemContext) IsDeleteColumnItemContext() {}

func NewDeleteColumnItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeleteColumnItemContext {
	var p = new(DeleteColumnItemContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_deleteColumnItem

	return p
}

func (s *DeleteColumnItemContext) GetParser() antlr.Parser { return s.parser }

func (s *DeleteColumnItemContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *DeleteColumnItemContext) LS_BRACKET() antlr.TerminalNode {
	return s.GetToken(CqlParserLS_BRACKET, 0)
}

func (s *DeleteColumnItemContext) RS_BRACKET() antlr.TerminalNode {
	return s.GetToken(CqlParserRS_BRACKET, 0)
}

func (s *DeleteColumnItemContext) StringLiteral() IStringLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStringLiteralContext)
}

func (s *DeleteColumnItemContext) DecimalLiteral() IDecimalLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDecimalLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDecimalLiteralContext)
}

func (s *DeleteColumnItemContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DeleteColumnItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DeleteColumnItemContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDeleteColumnItem(s)
	}
}

func (s *DeleteColumnItemContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDeleteColumnItem(s)
	}
}

func (p *CqlParser) DeleteColumnItem() (localctx IDeleteColumnItemContext) {
	this := p
	_ = this

	localctx = NewDeleteColumnItemContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 214, CqlParserRULE_deleteColumnItem)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1556)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 119, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1547)
			p.Match(CqlParserOBJECT_NAME)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1548)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1549)
			p.Match(CqlParserLS_BRACKET)
		}
		p.SetState(1552)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case CqlParserSTRING_LITERAL:
			{
				p.SetState(1550)
				p.StringLiteral()
			}

		case CqlParserDECIMAL_LITERAL:
			{
				p.SetState(1551)
				p.DecimalLiteral()
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}
		{
			p.SetState(1554)
			p.Match(CqlParserRS_BRACKET)
		}

	}

	return localctx
}

// IUpdateContext is an interface to support dynamic dispatch.
type IUpdateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUpdateContext differentiates from other interfaces.
	IsUpdateContext()
}

type UpdateContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUpdateContext() *UpdateContext {
	var p = new(UpdateContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_update
	return p
}

func (*UpdateContext) IsUpdateContext() {}

func NewUpdateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdateContext {
	var p = new(UpdateContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_update

	return p
}

func (s *UpdateContext) GetParser() antlr.Parser { return s.parser }

func (s *UpdateContext) KwUpdate() IKwUpdateContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwUpdateContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwUpdateContext)
}

func (s *UpdateContext) Table() ITableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableContext)
}

func (s *UpdateContext) KwSet() IKwSetContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwSetContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwSetContext)
}

func (s *UpdateContext) Assignments() IAssignmentsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentsContext)
}

func (s *UpdateContext) WhereSpec() IWhereSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWhereSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWhereSpecContext)
}

func (s *UpdateContext) BeginBatch() IBeginBatchContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBeginBatchContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBeginBatchContext)
}

func (s *UpdateContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *UpdateContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

func (s *UpdateContext) UsingTtlTimestamp() IUsingTtlTimestampContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUsingTtlTimestampContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUsingTtlTimestampContext)
}

func (s *UpdateContext) IfExist() IIfExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfExistContext)
}

func (s *UpdateContext) IfSpec() IIfSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfSpecContext)
}

func (s *UpdateContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UpdateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UpdateContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterUpdate(s)
	}
}

func (s *UpdateContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitUpdate(s)
	}
}

func (p *CqlParser) Update() (localctx IUpdateContext) {
	this := p
	_ = this

	localctx = NewUpdateContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 216, CqlParserRULE_update)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1559)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_BEGIN {
		{
			p.SetState(1558)
			p.BeginBatch()
		}

	}
	{
		p.SetState(1561)
		p.KwUpdate()
	}
	p.SetState(1565)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 121, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1562)
			p.Keyspace()
		}
		{
			p.SetState(1563)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1567)
		p.Table()
	}
	p.SetState(1569)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_USING {
		{
			p.SetState(1568)
			p.UsingTtlTimestamp()
		}

	}
	{
		p.SetState(1571)
		p.KwSet()
	}
	{
		p.SetState(1572)
		p.Assignments()
	}
	{
		p.SetState(1573)
		p.WhereSpec()
	}
	p.SetState(1576)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 123, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1574)
			p.IfExist()
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 123, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(1575)
			p.IfSpec()
		}

	}

	return localctx
}

// IIfSpecContext is an interface to support dynamic dispatch.
type IIfSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIfSpecContext differentiates from other interfaces.
	IsIfSpecContext()
}

type IfSpecContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIfSpecContext() *IfSpecContext {
	var p = new(IfSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_ifSpec
	return p
}

func (*IfSpecContext) IsIfSpecContext() {}

func NewIfSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfSpecContext {
	var p = new(IfSpecContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_ifSpec

	return p
}

func (s *IfSpecContext) GetParser() antlr.Parser { return s.parser }

func (s *IfSpecContext) KwIf() IKwIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwIfContext)
}

func (s *IfSpecContext) IfConditionList() IIfConditionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfConditionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfConditionListContext)
}

func (s *IfSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IfSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IfSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterIfSpec(s)
	}
}

func (s *IfSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitIfSpec(s)
	}
}

func (p *CqlParser) IfSpec() (localctx IIfSpecContext) {
	this := p
	_ = this

	localctx = NewIfSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 218, CqlParserRULE_ifSpec)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1578)
		p.KwIf()
	}
	{
		p.SetState(1579)
		p.IfConditionList()
	}

	return localctx
}

// IIfConditionListContext is an interface to support dynamic dispatch.
type IIfConditionListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIfConditionListContext differentiates from other interfaces.
	IsIfConditionListContext()
}

type IfConditionListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIfConditionListContext() *IfConditionListContext {
	var p = new(IfConditionListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_ifConditionList
	return p
}

func (*IfConditionListContext) IsIfConditionListContext() {}

func NewIfConditionListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfConditionListContext {
	var p = new(IfConditionListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_ifConditionList

	return p
}

func (s *IfConditionListContext) GetParser() antlr.Parser { return s.parser }

func (s *IfConditionListContext) AllIfCondition() []IIfConditionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIfConditionContext)(nil)).Elem())
	var tst = make([]IIfConditionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IIfConditionContext)
		}
	}

	return tst
}

func (s *IfConditionListContext) IfCondition(i int) IIfConditionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfConditionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIfConditionContext)
}

func (s *IfConditionListContext) AllKwAnd() []IKwAndContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IKwAndContext)(nil)).Elem())
	var tst = make([]IKwAndContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IKwAndContext)
		}
	}

	return tst
}

func (s *IfConditionListContext) KwAnd(i int) IKwAndContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAndContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IKwAndContext)
}

func (s *IfConditionListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IfConditionListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IfConditionListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterIfConditionList(s)
	}
}

func (s *IfConditionListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitIfConditionList(s)
	}
}

func (p *CqlParser) IfConditionList() (localctx IIfConditionListContext) {
	this := p
	_ = this

	localctx = NewIfConditionListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 220, CqlParserRULE_ifConditionList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1581)
		p.IfCondition()
	}

	p.SetState(1587)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserK_AND {
		{
			p.SetState(1582)
			p.KwAnd()
		}
		{
			p.SetState(1583)
			p.IfCondition()
		}

		p.SetState(1589)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IIfConditionContext is an interface to support dynamic dispatch.
type IIfConditionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIfConditionContext differentiates from other interfaces.
	IsIfConditionContext()
}

type IfConditionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIfConditionContext() *IfConditionContext {
	var p = new(IfConditionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_ifCondition
	return p
}

func (*IfConditionContext) IsIfConditionContext() {}

func NewIfConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfConditionContext {
	var p = new(IfConditionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_ifCondition

	return p
}

func (s *IfConditionContext) GetParser() antlr.Parser { return s.parser }

func (s *IfConditionContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *IfConditionContext) OPERATOR_EQ() antlr.TerminalNode {
	return s.GetToken(CqlParserOPERATOR_EQ, 0)
}

func (s *IfConditionContext) Constant() IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

func (s *IfConditionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IfConditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IfConditionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterIfCondition(s)
	}
}

func (s *IfConditionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitIfCondition(s)
	}
}

func (p *CqlParser) IfCondition() (localctx IIfConditionContext) {
	this := p
	_ = this

	localctx = NewIfConditionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 222, CqlParserRULE_ifCondition)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1590)
		p.Match(CqlParserOBJECT_NAME)
	}
	{
		p.SetState(1591)
		p.Match(CqlParserOPERATOR_EQ)
	}
	{
		p.SetState(1592)
		p.Constant()
	}

	return localctx
}

// IAssignmentsContext is an interface to support dynamic dispatch.
type IAssignmentsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssignmentsContext differentiates from other interfaces.
	IsAssignmentsContext()
}

type AssignmentsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssignmentsContext() *AssignmentsContext {
	var p = new(AssignmentsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_assignments
	return p
}

func (*AssignmentsContext) IsAssignmentsContext() {}

func NewAssignmentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentsContext {
	var p = new(AssignmentsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_assignments

	return p
}

func (s *AssignmentsContext) GetParser() antlr.Parser { return s.parser }

func (s *AssignmentsContext) AllAssignmentElement() []IAssignmentElementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAssignmentElementContext)(nil)).Elem())
	var tst = make([]IAssignmentElementContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAssignmentElementContext)
		}
	}

	return tst
}

func (s *AssignmentsContext) AssignmentElement(i int) IAssignmentElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentElementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAssignmentElementContext)
}

func (s *AssignmentsContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *AssignmentsContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *AssignmentsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssignmentsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssignmentsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAssignments(s)
	}
}

func (s *AssignmentsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAssignments(s)
	}
}

func (p *CqlParser) Assignments() (localctx IAssignmentsContext) {
	this := p
	_ = this

	localctx = NewAssignmentsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 224, CqlParserRULE_assignments)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1594)
		p.AssignmentElement()
	}

	p.SetState(1600)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(1595)
			p.SyntaxComma()
		}
		{
			p.SetState(1596)
			p.AssignmentElement()
		}

		p.SetState(1602)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IAssignmentElementContext is an interface to support dynamic dispatch.
type IAssignmentElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssignmentElementContext differentiates from other interfaces.
	IsAssignmentElementContext()
}

type AssignmentElementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssignmentElementContext() *AssignmentElementContext {
	var p = new(AssignmentElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_assignmentElement
	return p
}

func (*AssignmentElementContext) IsAssignmentElementContext() {}

func NewAssignmentElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentElementContext {
	var p = new(AssignmentElementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_assignmentElement

	return p
}

func (s *AssignmentElementContext) GetParser() antlr.Parser { return s.parser }

func (s *AssignmentElementContext) AllOBJECT_NAME() []antlr.TerminalNode {
	return s.GetTokens(CqlParserOBJECT_NAME)
}

func (s *AssignmentElementContext) OBJECT_NAME(i int) antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, i)
}

func (s *AssignmentElementContext) OPERATOR_EQ() antlr.TerminalNode {
	return s.GetToken(CqlParserOPERATOR_EQ, 0)
}

func (s *AssignmentElementContext) Constant() IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

func (s *AssignmentElementContext) AssignmentMap() IAssignmentMapContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentMapContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentMapContext)
}

func (s *AssignmentElementContext) AssignmentSet() IAssignmentSetContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentSetContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentSetContext)
}

func (s *AssignmentElementContext) AssignmentList() IAssignmentListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentListContext)
}

func (s *AssignmentElementContext) DecimalLiteral() IDecimalLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDecimalLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDecimalLiteralContext)
}

func (s *AssignmentElementContext) PLUS() antlr.TerminalNode {
	return s.GetToken(CqlParserPLUS, 0)
}

func (s *AssignmentElementContext) MINUS() antlr.TerminalNode {
	return s.GetToken(CqlParserMINUS, 0)
}

func (s *AssignmentElementContext) SyntaxBracketLs() ISyntaxBracketLsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLsContext)
}

func (s *AssignmentElementContext) SyntaxBracketRs() ISyntaxBracketRsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRsContext)
}

func (s *AssignmentElementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssignmentElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssignmentElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAssignmentElement(s)
	}
}

func (s *AssignmentElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAssignmentElement(s)
	}
}

func (p *CqlParser) AssignmentElement() (localctx IAssignmentElementContext) {
	this := p
	_ = this

	localctx = NewAssignmentElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 226, CqlParserRULE_assignmentElement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1656)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 127, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1603)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1604)
			p.Match(CqlParserOPERATOR_EQ)
		}
		p.SetState(1609)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 126, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1605)
				p.Constant()
			}

		case 2:
			{
				p.SetState(1606)
				p.AssignmentMap()
			}

		case 3:
			{
				p.SetState(1607)
				p.AssignmentSet()
			}

		case 4:
			{
				p.SetState(1608)
				p.AssignmentList()
			}

		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1611)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1612)
			p.Match(CqlParserOPERATOR_EQ)
		}
		{
			p.SetState(1613)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1614)
			_la = p.GetTokenStream().LA(1)

			if !(_la == CqlParserPLUS || _la == CqlParserMINUS) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1615)
			p.DecimalLiteral()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1616)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1617)
			p.Match(CqlParserOPERATOR_EQ)
		}
		{
			p.SetState(1618)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1619)
			_la = p.GetTokenStream().LA(1)

			if !(_la == CqlParserPLUS || _la == CqlParserMINUS) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1620)
			p.AssignmentSet()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1621)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1622)
			p.Match(CqlParserOPERATOR_EQ)
		}
		{
			p.SetState(1623)
			p.AssignmentSet()
		}
		{
			p.SetState(1624)
			_la = p.GetTokenStream().LA(1)

			if !(_la == CqlParserPLUS || _la == CqlParserMINUS) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1625)
			p.Match(CqlParserOBJECT_NAME)
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1627)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1628)
			p.Match(CqlParserOPERATOR_EQ)
		}
		{
			p.SetState(1629)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1630)
			_la = p.GetTokenStream().LA(1)

			if !(_la == CqlParserPLUS || _la == CqlParserMINUS) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1631)
			p.AssignmentMap()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1632)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1633)
			p.Match(CqlParserOPERATOR_EQ)
		}
		{
			p.SetState(1634)
			p.AssignmentMap()
		}
		{
			p.SetState(1635)
			_la = p.GetTokenStream().LA(1)

			if !(_la == CqlParserPLUS || _la == CqlParserMINUS) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1636)
			p.Match(CqlParserOBJECT_NAME)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1638)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1639)
			p.Match(CqlParserOPERATOR_EQ)
		}
		{
			p.SetState(1640)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1641)
			_la = p.GetTokenStream().LA(1)

			if !(_la == CqlParserPLUS || _la == CqlParserMINUS) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1642)
			p.AssignmentList()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(1643)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1644)
			p.Match(CqlParserOPERATOR_EQ)
		}
		{
			p.SetState(1645)
			p.AssignmentList()
		}
		{
			p.SetState(1646)
			_la = p.GetTokenStream().LA(1)

			if !(_la == CqlParserPLUS || _la == CqlParserMINUS) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1647)
			p.Match(CqlParserOBJECT_NAME)
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(1649)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1650)
			p.SyntaxBracketLs()
		}
		{
			p.SetState(1651)
			p.DecimalLiteral()
		}
		{
			p.SetState(1652)
			p.SyntaxBracketRs()
		}
		{
			p.SetState(1653)
			p.Match(CqlParserOPERATOR_EQ)
		}
		{
			p.SetState(1654)
			p.Constant()
		}

	}

	return localctx
}

// IAssignmentSetContext is an interface to support dynamic dispatch.
type IAssignmentSetContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssignmentSetContext differentiates from other interfaces.
	IsAssignmentSetContext()
}

type AssignmentSetContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssignmentSetContext() *AssignmentSetContext {
	var p = new(AssignmentSetContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_assignmentSet
	return p
}

func (*AssignmentSetContext) IsAssignmentSetContext() {}

func NewAssignmentSetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentSetContext {
	var p = new(AssignmentSetContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_assignmentSet

	return p
}

func (s *AssignmentSetContext) GetParser() antlr.Parser { return s.parser }

func (s *AssignmentSetContext) SyntaxBracketLc() ISyntaxBracketLcContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLcContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLcContext)
}

func (s *AssignmentSetContext) SyntaxBracketRc() ISyntaxBracketRcContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRcContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRcContext)
}

func (s *AssignmentSetContext) AllConstant() []IConstantContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IConstantContext)(nil)).Elem())
	var tst = make([]IConstantContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IConstantContext)
		}
	}

	return tst
}

func (s *AssignmentSetContext) Constant(i int) IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

func (s *AssignmentSetContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *AssignmentSetContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *AssignmentSetContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssignmentSetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssignmentSetContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAssignmentSet(s)
	}
}

func (s *AssignmentSetContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAssignmentSet(s)
	}
}

func (p *CqlParser) AssignmentSet() (localctx IAssignmentSetContext) {
	this := p
	_ = this

	localctx = NewAssignmentSetContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 228, CqlParserRULE_assignmentSet)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1658)
		p.SyntaxBracketLc()
	}
	p.SetState(1668)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_FALSE || _la == CqlParserK_NULL || _la == CqlParserK_TRUE || (((_la-163)&-(0x1f+1)) == 0 && ((1<<uint((_la-163)))&((1<<(CqlParserCODE_BLOCK-163))|(1<<(CqlParserSTRING_LITERAL-163))|(1<<(CqlParserDECIMAL_LITERAL-163))|(1<<(CqlParserFLOAT_LITERAL-163))|(1<<(CqlParserHEXADECIMAL_LITERAL-163))|(1<<(CqlParserUUID-163)))) != 0) {
		{
			p.SetState(1659)
			p.Constant()
		}
		p.SetState(1665)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == CqlParserCOMMA {
			{
				p.SetState(1660)
				p.SyntaxComma()
			}
			{
				p.SetState(1661)
				p.Constant()
			}

			p.SetState(1667)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	}
	{
		p.SetState(1670)
		p.SyntaxBracketRc()
	}

	return localctx
}

// IAssignmentMapContext is an interface to support dynamic dispatch.
type IAssignmentMapContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssignmentMapContext differentiates from other interfaces.
	IsAssignmentMapContext()
}

type AssignmentMapContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssignmentMapContext() *AssignmentMapContext {
	var p = new(AssignmentMapContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_assignmentMap
	return p
}

func (*AssignmentMapContext) IsAssignmentMapContext() {}

func NewAssignmentMapContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentMapContext {
	var p = new(AssignmentMapContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_assignmentMap

	return p
}

func (s *AssignmentMapContext) GetParser() antlr.Parser { return s.parser }

func (s *AssignmentMapContext) SyntaxBracketLc() ISyntaxBracketLcContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLcContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLcContext)
}

func (s *AssignmentMapContext) SyntaxBracketRc() ISyntaxBracketRcContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRcContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRcContext)
}

func (s *AssignmentMapContext) AllConstant() []IConstantContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IConstantContext)(nil)).Elem())
	var tst = make([]IConstantContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IConstantContext)
		}
	}

	return tst
}

func (s *AssignmentMapContext) Constant(i int) IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

func (s *AssignmentMapContext) AllSyntaxColon() []ISyntaxColonContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxColonContext)(nil)).Elem())
	var tst = make([]ISyntaxColonContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxColonContext)
		}
	}

	return tst
}

func (s *AssignmentMapContext) SyntaxColon(i int) ISyntaxColonContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxColonContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxColonContext)
}

func (s *AssignmentMapContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *AssignmentMapContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *AssignmentMapContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssignmentMapContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssignmentMapContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAssignmentMap(s)
	}
}

func (s *AssignmentMapContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAssignmentMap(s)
	}
}

func (p *CqlParser) AssignmentMap() (localctx IAssignmentMapContext) {
	this := p
	_ = this

	localctx = NewAssignmentMapContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 230, CqlParserRULE_assignmentMap)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1672)
		p.SyntaxBracketLc()
	}

	{
		p.SetState(1673)
		p.Constant()
	}
	{
		p.SetState(1674)
		p.SyntaxColon()
	}
	{
		p.SetState(1675)
		p.Constant()
	}

	p.SetState(1684)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(1677)
			p.SyntaxComma()
		}
		{
			p.SetState(1678)
			p.Constant()
		}
		{
			p.SetState(1679)
			p.SyntaxColon()
		}
		{
			p.SetState(1680)
			p.Constant()
		}

		p.SetState(1686)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1687)
		p.SyntaxBracketRc()
	}

	return localctx
}

// IAssignmentListContext is an interface to support dynamic dispatch.
type IAssignmentListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssignmentListContext differentiates from other interfaces.
	IsAssignmentListContext()
}

type AssignmentListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssignmentListContext() *AssignmentListContext {
	var p = new(AssignmentListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_assignmentList
	return p
}

func (*AssignmentListContext) IsAssignmentListContext() {}

func NewAssignmentListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentListContext {
	var p = new(AssignmentListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_assignmentList

	return p
}

func (s *AssignmentListContext) GetParser() antlr.Parser { return s.parser }

func (s *AssignmentListContext) SyntaxBracketLs() ISyntaxBracketLsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLsContext)
}

func (s *AssignmentListContext) AllConstant() []IConstantContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IConstantContext)(nil)).Elem())
	var tst = make([]IConstantContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IConstantContext)
		}
	}

	return tst
}

func (s *AssignmentListContext) Constant(i int) IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

func (s *AssignmentListContext) SyntaxBracketRs() ISyntaxBracketRsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRsContext)
}

func (s *AssignmentListContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *AssignmentListContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *AssignmentListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssignmentListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssignmentListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAssignmentList(s)
	}
}

func (s *AssignmentListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAssignmentList(s)
	}
}

func (p *CqlParser) AssignmentList() (localctx IAssignmentListContext) {
	this := p
	_ = this

	localctx = NewAssignmentListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 232, CqlParserRULE_assignmentList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1689)
		p.SyntaxBracketLs()
	}
	{
		p.SetState(1690)
		p.Constant()
	}
	p.SetState(1696)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(1691)
			p.SyntaxComma()
		}
		{
			p.SetState(1692)
			p.Constant()
		}

		p.SetState(1698)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1699)
		p.SyntaxBracketRs()
	}

	return localctx
}

// IAssignmentTupleContext is an interface to support dynamic dispatch.
type IAssignmentTupleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssignmentTupleContext differentiates from other interfaces.
	IsAssignmentTupleContext()
}

type AssignmentTupleContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAssignmentTupleContext() *AssignmentTupleContext {
	var p = new(AssignmentTupleContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_assignmentTuple
	return p
}

func (*AssignmentTupleContext) IsAssignmentTupleContext() {}

func NewAssignmentTupleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentTupleContext {
	var p = new(AssignmentTupleContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_assignmentTuple

	return p
}

func (s *AssignmentTupleContext) GetParser() antlr.Parser { return s.parser }

func (s *AssignmentTupleContext) SyntaxBracketLr() ISyntaxBracketLrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLrContext)
}

func (s *AssignmentTupleContext) SyntaxBracketRr() ISyntaxBracketRrContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRrContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRrContext)
}

func (s *AssignmentTupleContext) AllConstant() []IConstantContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IConstantContext)(nil)).Elem())
	var tst = make([]IConstantContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IConstantContext)
		}
	}

	return tst
}

func (s *AssignmentTupleContext) Constant(i int) IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

func (s *AssignmentTupleContext) AllAssignmentTuple() []IAssignmentTupleContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAssignmentTupleContext)(nil)).Elem())
	var tst = make([]IAssignmentTupleContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAssignmentTupleContext)
		}
	}

	return tst
}

func (s *AssignmentTupleContext) AssignmentTuple(i int) IAssignmentTupleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentTupleContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAssignmentTupleContext)
}

func (s *AssignmentTupleContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *AssignmentTupleContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *AssignmentTupleContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AssignmentTupleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AssignmentTupleContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAssignmentTuple(s)
	}
}

func (s *AssignmentTupleContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAssignmentTuple(s)
	}
}

func (p *CqlParser) AssignmentTuple() (localctx IAssignmentTupleContext) {
	this := p
	_ = this

	localctx = NewAssignmentTupleContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 234, CqlParserRULE_assignmentTuple)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1701)
		p.SyntaxBracketLr()
	}
	p.SetState(1730)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserK_FALSE, CqlParserK_NULL, CqlParserK_TRUE, CqlParserCODE_BLOCK, CqlParserSTRING_LITERAL, CqlParserDECIMAL_LITERAL, CqlParserFLOAT_LITERAL, CqlParserHEXADECIMAL_LITERAL, CqlParserUUID:
		{
			p.SetState(1702)
			p.Constant()
		}
		p.SetState(1719)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 134, p.GetParserRuleContext()) {
		case 1:
			p.SetState(1708)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == CqlParserCOMMA {
				{
					p.SetState(1703)
					p.SyntaxComma()
				}
				{
					p.SetState(1704)
					p.Constant()
				}

				p.SetState(1710)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}

		case 2:
			p.SetState(1716)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == CqlParserCOMMA {
				{
					p.SetState(1711)
					p.SyntaxComma()
				}
				{
					p.SetState(1712)
					p.AssignmentTuple()
				}

				p.SetState(1718)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}

		}

	case CqlParserLR_BRACKET:
		{
			p.SetState(1721)
			p.AssignmentTuple()
		}
		p.SetState(1727)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == CqlParserCOMMA {
			{
				p.SetState(1722)
				p.SyntaxComma()
			}
			{
				p.SetState(1723)
				p.AssignmentTuple()
			}

			p.SetState(1729)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(1732)
		p.SyntaxBracketRr()
	}

	return localctx
}

// IInsertContext is an interface to support dynamic dispatch.
type IInsertContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInsertContext differentiates from other interfaces.
	IsInsertContext()
}

type InsertContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInsertContext() *InsertContext {
	var p = new(InsertContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_insert
	return p
}

func (*InsertContext) IsInsertContext() {}

func NewInsertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertContext {
	var p = new(InsertContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_insert

	return p
}

func (s *InsertContext) GetParser() antlr.Parser { return s.parser }

func (s *InsertContext) KwInsert() IKwInsertContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwInsertContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwInsertContext)
}

func (s *InsertContext) KwInto() IKwIntoContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwIntoContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwIntoContext)
}

func (s *InsertContext) Table() ITableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITableContext)
}

func (s *InsertContext) InsertValuesSpec() IInsertValuesSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInsertValuesSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInsertValuesSpecContext)
}

func (s *InsertContext) BeginBatch() IBeginBatchContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBeginBatchContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBeginBatchContext)
}

func (s *InsertContext) Keyspace() IKeyspaceContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeyspaceContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeyspaceContext)
}

func (s *InsertContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

func (s *InsertContext) InsertColumnSpec() IInsertColumnSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInsertColumnSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInsertColumnSpecContext)
}

func (s *InsertContext) IfNotExist() IIfNotExistContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIfNotExistContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIfNotExistContext)
}

func (s *InsertContext) UsingTtlTimestamp() IUsingTtlTimestampContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUsingTtlTimestampContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUsingTtlTimestampContext)
}

func (s *InsertContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InsertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InsertContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterInsert(s)
	}
}

func (s *InsertContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitInsert(s)
	}
}

func (p *CqlParser) Insert() (localctx IInsertContext) {
	this := p
	_ = this

	localctx = NewInsertContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 236, CqlParserRULE_insert)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1735)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_BEGIN {
		{
			p.SetState(1734)
			p.BeginBatch()
		}

	}
	{
		p.SetState(1737)
		p.KwInsert()
	}
	{
		p.SetState(1738)
		p.KwInto()
	}
	p.SetState(1742)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 138, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1739)
			p.Keyspace()
		}
		{
			p.SetState(1740)
			p.Match(CqlParserDOT)
		}

	}
	{
		p.SetState(1744)
		p.Table()
	}
	p.SetState(1746)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserLR_BRACKET {
		{
			p.SetState(1745)
			p.InsertColumnSpec()
		}

	}
	{
		p.SetState(1748)
		p.InsertValuesSpec()
	}
	p.SetState(1750)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_IF {
		{
			p.SetState(1749)
			p.IfNotExist()
		}

	}
	p.SetState(1753)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_USING {
		{
			p.SetState(1752)
			p.UsingTtlTimestamp()
		}

	}

	return localctx
}

// IUsingTtlTimestampContext is an interface to support dynamic dispatch.
type IUsingTtlTimestampContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUsingTtlTimestampContext differentiates from other interfaces.
	IsUsingTtlTimestampContext()
}

type UsingTtlTimestampContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUsingTtlTimestampContext() *UsingTtlTimestampContext {
	var p = new(UsingTtlTimestampContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_usingTtlTimestamp
	return p
}

func (*UsingTtlTimestampContext) IsUsingTtlTimestampContext() {}

func NewUsingTtlTimestampContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UsingTtlTimestampContext {
	var p = new(UsingTtlTimestampContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_usingTtlTimestamp

	return p
}

func (s *UsingTtlTimestampContext) GetParser() antlr.Parser { return s.parser }

func (s *UsingTtlTimestampContext) KwUsing() IKwUsingContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwUsingContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwUsingContext)
}

func (s *UsingTtlTimestampContext) Ttl() ITtlContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITtlContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITtlContext)
}

func (s *UsingTtlTimestampContext) KwAnd() IKwAndContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAndContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAndContext)
}

func (s *UsingTtlTimestampContext) Timestamp() ITimestampContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITimestampContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITimestampContext)
}

func (s *UsingTtlTimestampContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UsingTtlTimestampContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UsingTtlTimestampContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterUsingTtlTimestamp(s)
	}
}

func (s *UsingTtlTimestampContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitUsingTtlTimestamp(s)
	}
}

func (p *CqlParser) UsingTtlTimestamp() (localctx IUsingTtlTimestampContext) {
	this := p
	_ = this

	localctx = NewUsingTtlTimestampContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 238, CqlParserRULE_usingTtlTimestamp)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1771)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 142, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1755)
			p.KwUsing()
		}
		{
			p.SetState(1756)
			p.Ttl()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1758)
			p.KwUsing()
		}
		{
			p.SetState(1759)
			p.Ttl()
		}
		{
			p.SetState(1760)
			p.KwAnd()
		}
		{
			p.SetState(1761)
			p.Timestamp()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1763)
			p.KwUsing()
		}
		{
			p.SetState(1764)
			p.Timestamp()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1766)
			p.KwUsing()
		}
		{
			p.SetState(1767)
			p.Timestamp()
		}
		{
			p.SetState(1768)
			p.KwAnd()
		}
		{
			p.SetState(1769)
			p.Ttl()
		}

	}

	return localctx
}

// ITimestampContext is an interface to support dynamic dispatch.
type ITimestampContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTimestampContext differentiates from other interfaces.
	IsTimestampContext()
}

type TimestampContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTimestampContext() *TimestampContext {
	var p = new(TimestampContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_timestamp
	return p
}

func (*TimestampContext) IsTimestampContext() {}

func NewTimestampContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TimestampContext {
	var p = new(TimestampContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_timestamp

	return p
}

func (s *TimestampContext) GetParser() antlr.Parser { return s.parser }

func (s *TimestampContext) KwTimestamp() IKwTimestampContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwTimestampContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwTimestampContext)
}

func (s *TimestampContext) DecimalLiteral() IDecimalLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDecimalLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDecimalLiteralContext)
}

func (s *TimestampContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TimestampContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TimestampContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterTimestamp(s)
	}
}

func (s *TimestampContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitTimestamp(s)
	}
}

func (p *CqlParser) Timestamp() (localctx ITimestampContext) {
	this := p
	_ = this

	localctx = NewTimestampContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 240, CqlParserRULE_timestamp)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1773)
		p.KwTimestamp()
	}
	{
		p.SetState(1774)
		p.DecimalLiteral()
	}

	return localctx
}

// ITtlContext is an interface to support dynamic dispatch.
type ITtlContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTtlContext differentiates from other interfaces.
	IsTtlContext()
}

type TtlContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTtlContext() *TtlContext {
	var p = new(TtlContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_ttl
	return p
}

func (*TtlContext) IsTtlContext() {}

func NewTtlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TtlContext {
	var p = new(TtlContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_ttl

	return p
}

func (s *TtlContext) GetParser() antlr.Parser { return s.parser }

func (s *TtlContext) KwTtl() IKwTtlContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwTtlContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwTtlContext)
}

func (s *TtlContext) DecimalLiteral() IDecimalLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDecimalLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDecimalLiteralContext)
}

func (s *TtlContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TtlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TtlContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterTtl(s)
	}
}

func (s *TtlContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitTtl(s)
	}
}

func (p *CqlParser) Ttl() (localctx ITtlContext) {
	this := p
	_ = this

	localctx = NewTtlContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 242, CqlParserRULE_ttl)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1776)
		p.KwTtl()
	}
	{
		p.SetState(1777)
		p.DecimalLiteral()
	}

	return localctx
}

// IUsingTimestampSpecContext is an interface to support dynamic dispatch.
type IUsingTimestampSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUsingTimestampSpecContext differentiates from other interfaces.
	IsUsingTimestampSpecContext()
}

type UsingTimestampSpecContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUsingTimestampSpecContext() *UsingTimestampSpecContext {
	var p = new(UsingTimestampSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_usingTimestampSpec
	return p
}

func (*UsingTimestampSpecContext) IsUsingTimestampSpecContext() {}

func NewUsingTimestampSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UsingTimestampSpecContext {
	var p = new(UsingTimestampSpecContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_usingTimestampSpec

	return p
}

func (s *UsingTimestampSpecContext) GetParser() antlr.Parser { return s.parser }

func (s *UsingTimestampSpecContext) KwUsing() IKwUsingContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwUsingContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwUsingContext)
}

func (s *UsingTimestampSpecContext) Timestamp() ITimestampContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITimestampContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITimestampContext)
}

func (s *UsingTimestampSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UsingTimestampSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UsingTimestampSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterUsingTimestampSpec(s)
	}
}

func (s *UsingTimestampSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitUsingTimestampSpec(s)
	}
}

func (p *CqlParser) UsingTimestampSpec() (localctx IUsingTimestampSpecContext) {
	this := p
	_ = this

	localctx = NewUsingTimestampSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 244, CqlParserRULE_usingTimestampSpec)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1779)
		p.KwUsing()
	}
	{
		p.SetState(1780)
		p.Timestamp()
	}

	return localctx
}

// IIfNotExistContext is an interface to support dynamic dispatch.
type IIfNotExistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIfNotExistContext differentiates from other interfaces.
	IsIfNotExistContext()
}

type IfNotExistContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIfNotExistContext() *IfNotExistContext {
	var p = new(IfNotExistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_ifNotExist
	return p
}

func (*IfNotExistContext) IsIfNotExistContext() {}

func NewIfNotExistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfNotExistContext {
	var p = new(IfNotExistContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_ifNotExist

	return p
}

func (s *IfNotExistContext) GetParser() antlr.Parser { return s.parser }

func (s *IfNotExistContext) KwIf() IKwIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwIfContext)
}

func (s *IfNotExistContext) KwNot() IKwNotContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwNotContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwNotContext)
}

func (s *IfNotExistContext) KwExists() IKwExistsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwExistsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwExistsContext)
}

func (s *IfNotExistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IfNotExistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IfNotExistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterIfNotExist(s)
	}
}

func (s *IfNotExistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitIfNotExist(s)
	}
}

func (p *CqlParser) IfNotExist() (localctx IIfNotExistContext) {
	this := p
	_ = this

	localctx = NewIfNotExistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 246, CqlParserRULE_ifNotExist)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1782)
		p.KwIf()
	}
	{
		p.SetState(1783)
		p.KwNot()
	}
	{
		p.SetState(1784)
		p.KwExists()
	}

	return localctx
}

// IIfExistContext is an interface to support dynamic dispatch.
type IIfExistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIfExistContext differentiates from other interfaces.
	IsIfExistContext()
}

type IfExistContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIfExistContext() *IfExistContext {
	var p = new(IfExistContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_ifExist
	return p
}

func (*IfExistContext) IsIfExistContext() {}

func NewIfExistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfExistContext {
	var p = new(IfExistContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_ifExist

	return p
}

func (s *IfExistContext) GetParser() antlr.Parser { return s.parser }

func (s *IfExistContext) KwIf() IKwIfContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwIfContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwIfContext)
}

func (s *IfExistContext) KwExists() IKwExistsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwExistsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwExistsContext)
}

func (s *IfExistContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *IfExistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *IfExistContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterIfExist(s)
	}
}

func (s *IfExistContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitIfExist(s)
	}
}

func (p *CqlParser) IfExist() (localctx IIfExistContext) {
	this := p
	_ = this

	localctx = NewIfExistContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 248, CqlParserRULE_ifExist)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1786)
		p.KwIf()
	}
	{
		p.SetState(1787)
		p.KwExists()
	}

	return localctx
}

// IInsertValuesSpecContext is an interface to support dynamic dispatch.
type IInsertValuesSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInsertValuesSpecContext differentiates from other interfaces.
	IsInsertValuesSpecContext()
}

type InsertValuesSpecContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInsertValuesSpecContext() *InsertValuesSpecContext {
	var p = new(InsertValuesSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_insertValuesSpec
	return p
}

func (*InsertValuesSpecContext) IsInsertValuesSpecContext() {}

func NewInsertValuesSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertValuesSpecContext {
	var p = new(InsertValuesSpecContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_insertValuesSpec

	return p
}

func (s *InsertValuesSpecContext) GetParser() antlr.Parser { return s.parser }

func (s *InsertValuesSpecContext) KwValues() IKwValuesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwValuesContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwValuesContext)
}

func (s *InsertValuesSpecContext) LR_BRACKET() antlr.TerminalNode {
	return s.GetToken(CqlParserLR_BRACKET, 0)
}

func (s *InsertValuesSpecContext) ExpressionList() IExpressionListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExpressionListContext)
}

func (s *InsertValuesSpecContext) RR_BRACKET() antlr.TerminalNode {
	return s.GetToken(CqlParserRR_BRACKET, 0)
}

func (s *InsertValuesSpecContext) KwJson() IKwJsonContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwJsonContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwJsonContext)
}

func (s *InsertValuesSpecContext) Constant() IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

func (s *InsertValuesSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InsertValuesSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InsertValuesSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterInsertValuesSpec(s)
	}
}

func (s *InsertValuesSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitInsertValuesSpec(s)
	}
}

func (p *CqlParser) InsertValuesSpec() (localctx IInsertValuesSpecContext) {
	this := p
	_ = this

	localctx = NewInsertValuesSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 250, CqlParserRULE_insertValuesSpec)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1797)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserK_VALUES:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1789)
			p.KwValues()
		}
		{
			p.SetState(1790)
			p.Match(CqlParserLR_BRACKET)
		}
		{
			p.SetState(1791)
			p.ExpressionList()
		}
		{
			p.SetState(1792)
			p.Match(CqlParserRR_BRACKET)
		}

	case CqlParserK_JSON:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1794)
			p.KwJson()
		}
		{
			p.SetState(1795)
			p.Constant()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IInsertColumnSpecContext is an interface to support dynamic dispatch.
type IInsertColumnSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInsertColumnSpecContext differentiates from other interfaces.
	IsInsertColumnSpecContext()
}

type InsertColumnSpecContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyInsertColumnSpecContext() *InsertColumnSpecContext {
	var p = new(InsertColumnSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_insertColumnSpec
	return p
}

func (*InsertColumnSpecContext) IsInsertColumnSpecContext() {}

func NewInsertColumnSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertColumnSpecContext {
	var p = new(InsertColumnSpecContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_insertColumnSpec

	return p
}

func (s *InsertColumnSpecContext) GetParser() antlr.Parser { return s.parser }

func (s *InsertColumnSpecContext) LR_BRACKET() antlr.TerminalNode {
	return s.GetToken(CqlParserLR_BRACKET, 0)
}

func (s *InsertColumnSpecContext) ColumnList() IColumnListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumnListContext)
}

func (s *InsertColumnSpecContext) RR_BRACKET() antlr.TerminalNode {
	return s.GetToken(CqlParserRR_BRACKET, 0)
}

func (s *InsertColumnSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *InsertColumnSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *InsertColumnSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterInsertColumnSpec(s)
	}
}

func (s *InsertColumnSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitInsertColumnSpec(s)
	}
}

func (p *CqlParser) InsertColumnSpec() (localctx IInsertColumnSpecContext) {
	this := p
	_ = this

	localctx = NewInsertColumnSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 252, CqlParserRULE_insertColumnSpec)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1799)
		p.Match(CqlParserLR_BRACKET)
	}
	{
		p.SetState(1800)
		p.ColumnList()
	}
	{
		p.SetState(1801)
		p.Match(CqlParserRR_BRACKET)
	}

	return localctx
}

// IColumnListContext is an interface to support dynamic dispatch.
type IColumnListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsColumnListContext differentiates from other interfaces.
	IsColumnListContext()
}

type ColumnListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColumnListContext() *ColumnListContext {
	var p = new(ColumnListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_columnList
	return p
}

func (*ColumnListContext) IsColumnListContext() {}

func NewColumnListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnListContext {
	var p = new(ColumnListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_columnList

	return p
}

func (s *ColumnListContext) GetParser() antlr.Parser { return s.parser }

func (s *ColumnListContext) AllColumn() []IColumnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumnContext)(nil)).Elem())
	var tst = make([]IColumnContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IColumnContext)
		}
	}

	return tst
}

func (s *ColumnListContext) Column(i int) IColumnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumnContext)
}

func (s *ColumnListContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *ColumnListContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *ColumnListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ColumnListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ColumnListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterColumnList(s)
	}
}

func (s *ColumnListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitColumnList(s)
	}
}

func (p *CqlParser) ColumnList() (localctx IColumnListContext) {
	this := p
	_ = this

	localctx = NewColumnListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 254, CqlParserRULE_columnList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1803)
		p.Column()
	}
	p.SetState(1809)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(1804)
			p.SyntaxComma()
		}
		{
			p.SetState(1805)
			p.Column()
		}

		p.SetState(1811)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IExpressionListContext is an interface to support dynamic dispatch.
type IExpressionListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExpressionListContext differentiates from other interfaces.
	IsExpressionListContext()
}

type ExpressionListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyExpressionListContext() *ExpressionListContext {
	var p = new(ExpressionListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_expressionList
	return p
}

func (*ExpressionListContext) IsExpressionListContext() {}

func NewExpressionListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionListContext {
	var p = new(ExpressionListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_expressionList

	return p
}

func (s *ExpressionListContext) GetParser() antlr.Parser { return s.parser }

func (s *ExpressionListContext) AllExpression() []IExpressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExpressionContext)(nil)).Elem())
	var tst = make([]IExpressionContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IExpressionContext)
		}
	}

	return tst
}

func (s *ExpressionListContext) Expression(i int) IExpressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExpressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExpressionContext)
}

func (s *ExpressionListContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *ExpressionListContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *ExpressionListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ExpressionListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ExpressionListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterExpressionList(s)
	}
}

func (s *ExpressionListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitExpressionList(s)
	}
}

func (p *CqlParser) ExpressionList() (localctx IExpressionListContext) {
	this := p
	_ = this

	localctx = NewExpressionListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 256, CqlParserRULE_expressionList)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1812)
		p.Expression()
	}
	p.SetState(1818)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(1813)
			p.SyntaxComma()
		}
		{
			p.SetState(1814)
			p.Expression()
		}

		p.SetState(1820)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	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 = CqlParserRULE_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 = CqlParserRULE_expression

	return p
}

func (s *ExpressionContext) GetParser() antlr.Parser { return s.parser }

func (s *ExpressionContext) Constant() IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

func (s *ExpressionContext) AssignmentMap() IAssignmentMapContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentMapContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentMapContext)
}

func (s *ExpressionContext) AssignmentSet() IAssignmentSetContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentSetContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentSetContext)
}

func (s *ExpressionContext) AssignmentList() IAssignmentListContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentListContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentListContext)
}

func (s *ExpressionContext) AssignmentTuple() IAssignmentTupleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentTupleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAssignmentTupleContext)
}

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.(CqlParserListener); ok {
		listenerT.EnterExpression(s)
	}
}

func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitExpression(s)
	}
}

func (p *CqlParser) Expression() (localctx IExpressionContext) {
	this := p
	_ = this

	localctx = NewExpressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 258, CqlParserRULE_expression)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1826)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 146, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1821)
			p.Constant()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1822)
			p.AssignmentMap()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1823)
			p.AssignmentSet()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1824)
			p.AssignmentList()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1825)
			p.AssignmentTuple()
		}

	}

	return localctx
}

// ISelect_Context is an interface to support dynamic dispatch.
type ISelect_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSelect_Context differentiates from other interfaces.
	IsSelect_Context()
}

type Select_Context struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySelect_Context() *Select_Context {
	var p = new(Select_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_select_
	return p
}

func (*Select_Context) IsSelect_Context() {}

func NewSelect_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_Context {
	var p = new(Select_Context)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_select_

	return p
}

func (s *Select_Context) GetParser() antlr.Parser { return s.parser }

func (s *Select_Context) KwSelect() IKwSelectContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwSelectContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwSelectContext)
}

func (s *Select_Context) SelectElements() ISelectElementsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelectElementsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelectElementsContext)
}

func (s *Select_Context) FromSpec() IFromSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFromSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFromSpecContext)
}

func (s *Select_Context) DistinctSpec() IDistinctSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDistinctSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDistinctSpecContext)
}

func (s *Select_Context) KwJson() IKwJsonContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwJsonContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwJsonContext)
}

func (s *Select_Context) WhereSpec() IWhereSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWhereSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWhereSpecContext)
}

func (s *Select_Context) OrderSpec() IOrderSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrderSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOrderSpecContext)
}

func (s *Select_Context) LimitSpec() ILimitSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILimitSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILimitSpecContext)
}

func (s *Select_Context) AllowFilteringSpec() IAllowFilteringSpecContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAllowFilteringSpecContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAllowFilteringSpecContext)
}

func (s *Select_Context) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Select_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Select_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterSelect_(s)
	}
}

func (s *Select_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitSelect_(s)
	}
}

func (p *CqlParser) Select_() (localctx ISelect_Context) {
	this := p
	_ = this

	localctx = NewSelect_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 260, CqlParserRULE_select_)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1828)
		p.KwSelect()
	}
	p.SetState(1830)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_DISTINCT {
		{
			p.SetState(1829)
			p.DistinctSpec()
		}

	}
	p.SetState(1833)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_JSON {
		{
			p.SetState(1832)
			p.KwJson()
		}

	}
	{
		p.SetState(1835)
		p.SelectElements()
	}
	{
		p.SetState(1836)
		p.FromSpec()
	}
	p.SetState(1838)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_WHERE {
		{
			p.SetState(1837)
			p.WhereSpec()
		}

	}
	p.SetState(1841)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_ORDER {
		{
			p.SetState(1840)
			p.OrderSpec()
		}

	}
	p.SetState(1844)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_LIMIT {
		{
			p.SetState(1843)
			p.LimitSpec()
		}

	}
	p.SetState(1847)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserK_ALLOW {
		{
			p.SetState(1846)
			p.AllowFilteringSpec()
		}

	}

	return localctx
}

// IAllowFilteringSpecContext is an interface to support dynamic dispatch.
type IAllowFilteringSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAllowFilteringSpecContext differentiates from other interfaces.
	IsAllowFilteringSpecContext()
}

type AllowFilteringSpecContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAllowFilteringSpecContext() *AllowFilteringSpecContext {
	var p = new(AllowFilteringSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_allowFilteringSpec
	return p
}

func (*AllowFilteringSpecContext) IsAllowFilteringSpecContext() {}

func NewAllowFilteringSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AllowFilteringSpecContext {
	var p = new(AllowFilteringSpecContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_allowFilteringSpec

	return p
}

func (s *AllowFilteringSpecContext) GetParser() antlr.Parser { return s.parser }

func (s *AllowFilteringSpecContext) KwAllow() IKwAllowContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAllowContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAllowContext)
}

func (s *AllowFilteringSpecContext) KwFiltering() IKwFilteringContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwFilteringContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwFilteringContext)
}

func (s *AllowFilteringSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AllowFilteringSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AllowFilteringSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAllowFilteringSpec(s)
	}
}

func (s *AllowFilteringSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAllowFilteringSpec(s)
	}
}

func (p *CqlParser) AllowFilteringSpec() (localctx IAllowFilteringSpecContext) {
	this := p
	_ = this

	localctx = NewAllowFilteringSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 262, CqlParserRULE_allowFilteringSpec)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1849)
		p.KwAllow()
	}
	{
		p.SetState(1850)
		p.KwFiltering()
	}

	return localctx
}

// ILimitSpecContext is an interface to support dynamic dispatch.
type ILimitSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLimitSpecContext differentiates from other interfaces.
	IsLimitSpecContext()
}

type LimitSpecContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLimitSpecContext() *LimitSpecContext {
	var p = new(LimitSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_limitSpec
	return p
}

func (*LimitSpecContext) IsLimitSpecContext() {}

func NewLimitSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitSpecContext {
	var p = new(LimitSpecContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_limitSpec

	return p
}

func (s *LimitSpecContext) GetParser() antlr.Parser { return s.parser }

func (s *LimitSpecContext) KwLimit() IKwLimitContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwLimitContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwLimitContext)
}

func (s *LimitSpecContext) DecimalLiteral() IDecimalLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDecimalLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDecimalLiteralContext)
}

func (s *LimitSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LimitSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LimitSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterLimitSpec(s)
	}
}

func (s *LimitSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitLimitSpec(s)
	}
}

func (p *CqlParser) LimitSpec() (localctx ILimitSpecContext) {
	this := p
	_ = this

	localctx = NewLimitSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 264, CqlParserRULE_limitSpec)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1852)
		p.KwLimit()
	}
	{
		p.SetState(1853)
		p.DecimalLiteral()
	}

	return localctx
}

// IFromSpecContext is an interface to support dynamic dispatch.
type IFromSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFromSpecContext differentiates from other interfaces.
	IsFromSpecContext()
}

type FromSpecContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFromSpecContext() *FromSpecContext {
	var p = new(FromSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_fromSpec
	return p
}

func (*FromSpecContext) IsFromSpecContext() {}

func NewFromSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromSpecContext {
	var p = new(FromSpecContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_fromSpec

	return p
}

func (s *FromSpecContext) GetParser() antlr.Parser { return s.parser }

func (s *FromSpecContext) KwFrom() IKwFromContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwFromContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwFromContext)
}

func (s *FromSpecContext) FromSpecElement() IFromSpecElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFromSpecElementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFromSpecElementContext)
}

func (s *FromSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FromSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FromSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterFromSpec(s)
	}
}

func (s *FromSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitFromSpec(s)
	}
}

func (p *CqlParser) FromSpec() (localctx IFromSpecContext) {
	this := p
	_ = this

	localctx = NewFromSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 266, CqlParserRULE_fromSpec)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1855)
		p.KwFrom()
	}
	{
		p.SetState(1856)
		p.FromSpecElement()
	}

	return localctx
}

// IFromSpecElementContext is an interface to support dynamic dispatch.
type IFromSpecElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFromSpecElementContext differentiates from other interfaces.
	IsFromSpecElementContext()
}

type FromSpecElementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFromSpecElementContext() *FromSpecElementContext {
	var p = new(FromSpecElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_fromSpecElement
	return p
}

func (*FromSpecElementContext) IsFromSpecElementContext() {}

func NewFromSpecElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromSpecElementContext {
	var p = new(FromSpecElementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_fromSpecElement

	return p
}

func (s *FromSpecElementContext) GetParser() antlr.Parser { return s.parser }

func (s *FromSpecElementContext) AllOBJECT_NAME() []antlr.TerminalNode {
	return s.GetTokens(CqlParserOBJECT_NAME)
}

func (s *FromSpecElementContext) OBJECT_NAME(i int) antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, i)
}

func (s *FromSpecElementContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

func (s *FromSpecElementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FromSpecElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FromSpecElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterFromSpecElement(s)
	}
}

func (s *FromSpecElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitFromSpecElement(s)
	}
}

func (p *CqlParser) FromSpecElement() (localctx IFromSpecElementContext) {
	this := p
	_ = this

	localctx = NewFromSpecElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 268, CqlParserRULE_fromSpecElement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1862)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 153, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1858)
			p.Match(CqlParserOBJECT_NAME)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1859)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1860)
			p.Match(CqlParserDOT)
		}
		{
			p.SetState(1861)
			p.Match(CqlParserOBJECT_NAME)
		}

	}

	return localctx
}

// IOrderSpecContext is an interface to support dynamic dispatch.
type IOrderSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOrderSpecContext differentiates from other interfaces.
	IsOrderSpecContext()
}

type OrderSpecContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOrderSpecContext() *OrderSpecContext {
	var p = new(OrderSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_orderSpec
	return p
}

func (*OrderSpecContext) IsOrderSpecContext() {}

func NewOrderSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderSpecContext {
	var p = new(OrderSpecContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_orderSpec

	return p
}

func (s *OrderSpecContext) GetParser() antlr.Parser { return s.parser }

func (s *OrderSpecContext) KwOrder() IKwOrderContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwOrderContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwOrderContext)
}

func (s *OrderSpecContext) KwBy() IKwByContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwByContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwByContext)
}

func (s *OrderSpecContext) OrderSpecElement() IOrderSpecElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrderSpecElementContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOrderSpecElementContext)
}

func (s *OrderSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OrderSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OrderSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterOrderSpec(s)
	}
}

func (s *OrderSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitOrderSpec(s)
	}
}

func (p *CqlParser) OrderSpec() (localctx IOrderSpecContext) {
	this := p
	_ = this

	localctx = NewOrderSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 270, CqlParserRULE_orderSpec)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1864)
		p.KwOrder()
	}
	{
		p.SetState(1865)
		p.KwBy()
	}
	{
		p.SetState(1866)
		p.OrderSpecElement()
	}

	return localctx
}

// IOrderSpecElementContext is an interface to support dynamic dispatch.
type IOrderSpecElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOrderSpecElementContext differentiates from other interfaces.
	IsOrderSpecElementContext()
}

type OrderSpecElementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOrderSpecElementContext() *OrderSpecElementContext {
	var p = new(OrderSpecElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_orderSpecElement
	return p
}

func (*OrderSpecElementContext) IsOrderSpecElementContext() {}

func NewOrderSpecElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderSpecElementContext {
	var p = new(OrderSpecElementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_orderSpecElement

	return p
}

func (s *OrderSpecElementContext) GetParser() antlr.Parser { return s.parser }

func (s *OrderSpecElementContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *OrderSpecElementContext) KwAsc() IKwAscContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAscContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAscContext)
}

func (s *OrderSpecElementContext) KwDesc() IKwDescContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDescContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDescContext)
}

func (s *OrderSpecElementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OrderSpecElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OrderSpecElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterOrderSpecElement(s)
	}
}

func (s *OrderSpecElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitOrderSpecElement(s)
	}
}

func (p *CqlParser) OrderSpecElement() (localctx IOrderSpecElementContext) {
	this := p
	_ = this

	localctx = NewOrderSpecElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 272, CqlParserRULE_orderSpecElement)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1868)
		p.Match(CqlParserOBJECT_NAME)
	}
	p.SetState(1871)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserK_ASC:
		{
			p.SetState(1869)
			p.KwAsc()
		}

	case CqlParserK_DESC:
		{
			p.SetState(1870)
			p.KwDesc()
		}

	case CqlParserEOF, CqlParserSEMI, CqlParserMINUSMINUS, CqlParserK_ALLOW, CqlParserK_LIMIT:

	default:
	}

	return localctx
}

// IWhereSpecContext is an interface to support dynamic dispatch.
type IWhereSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWhereSpecContext differentiates from other interfaces.
	IsWhereSpecContext()
}

type WhereSpecContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWhereSpecContext() *WhereSpecContext {
	var p = new(WhereSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_whereSpec
	return p
}

func (*WhereSpecContext) IsWhereSpecContext() {}

func NewWhereSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhereSpecContext {
	var p = new(WhereSpecContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_whereSpec

	return p
}

func (s *WhereSpecContext) GetParser() antlr.Parser { return s.parser }

func (s *WhereSpecContext) KwWhere() IKwWhereContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwWhereContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwWhereContext)
}

func (s *WhereSpecContext) RelationElements() IRelationElementsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRelationElementsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRelationElementsContext)
}

func (s *WhereSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *WhereSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *WhereSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterWhereSpec(s)
	}
}

func (s *WhereSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitWhereSpec(s)
	}
}

func (p *CqlParser) WhereSpec() (localctx IWhereSpecContext) {
	this := p
	_ = this

	localctx = NewWhereSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 274, CqlParserRULE_whereSpec)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1873)
		p.KwWhere()
	}
	{
		p.SetState(1874)
		p.RelationElements()
	}

	return localctx
}

// IDistinctSpecContext is an interface to support dynamic dispatch.
type IDistinctSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDistinctSpecContext differentiates from other interfaces.
	IsDistinctSpecContext()
}

type DistinctSpecContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDistinctSpecContext() *DistinctSpecContext {
	var p = new(DistinctSpecContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_distinctSpec
	return p
}

func (*DistinctSpecContext) IsDistinctSpecContext() {}

func NewDistinctSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DistinctSpecContext {
	var p = new(DistinctSpecContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_distinctSpec

	return p
}

func (s *DistinctSpecContext) GetParser() antlr.Parser { return s.parser }

func (s *DistinctSpecContext) KwDistinct() IKwDistinctContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDistinctContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDistinctContext)
}

func (s *DistinctSpecContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DistinctSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DistinctSpecContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDistinctSpec(s)
	}
}

func (s *DistinctSpecContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDistinctSpec(s)
	}
}

func (p *CqlParser) DistinctSpec() (localctx IDistinctSpecContext) {
	this := p
	_ = this

	localctx = NewDistinctSpecContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 276, CqlParserRULE_distinctSpec)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1876)
		p.KwDistinct()
	}

	return localctx
}

// ISelectElementsContext is an interface to support dynamic dispatch.
type ISelectElementsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetStar returns the star token.
	GetStar() antlr.Token

	// SetStar sets the star token.
	SetStar(antlr.Token)

	// IsSelectElementsContext differentiates from other interfaces.
	IsSelectElementsContext()
}

type SelectElementsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
	star   antlr.Token
}

func NewEmptySelectElementsContext() *SelectElementsContext {
	var p = new(SelectElementsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_selectElements
	return p
}

func (*SelectElementsContext) IsSelectElementsContext() {}

func NewSelectElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectElementsContext {
	var p = new(SelectElementsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_selectElements

	return p
}

func (s *SelectElementsContext) GetParser() antlr.Parser { return s.parser }

func (s *SelectElementsContext) GetStar() antlr.Token { return s.star }

func (s *SelectElementsContext) SetStar(v antlr.Token) { s.star = v }

func (s *SelectElementsContext) AllSelectElement() []ISelectElementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISelectElementContext)(nil)).Elem())
	var tst = make([]ISelectElementContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISelectElementContext)
		}
	}

	return tst
}

func (s *SelectElementsContext) SelectElement(i int) ISelectElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelectElementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISelectElementContext)
}

func (s *SelectElementsContext) STAR() antlr.TerminalNode {
	return s.GetToken(CqlParserSTAR, 0)
}

func (s *SelectElementsContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *SelectElementsContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *SelectElementsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SelectElementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SelectElementsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterSelectElements(s)
	}
}

func (s *SelectElementsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitSelectElements(s)
	}
}

func (p *CqlParser) SelectElements() (localctx ISelectElementsContext) {
	this := p
	_ = this

	localctx = NewSelectElementsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 278, CqlParserRULE_selectElements)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1880)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserSTAR:
		{
			p.SetState(1878)

			var _m = p.Match(CqlParserSTAR)

			localctx.(*SelectElementsContext).star = _m
		}

	case CqlParserOBJECT_NAME:
		{
			p.SetState(1879)
			p.SelectElement()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	p.SetState(1887)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(1882)
			p.SyntaxComma()
		}
		{
			p.SetState(1883)
			p.SelectElement()
		}

		p.SetState(1889)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// ISelectElementContext is an interface to support dynamic dispatch.
type ISelectElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSelectElementContext differentiates from other interfaces.
	IsSelectElementContext()
}

type SelectElementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySelectElementContext() *SelectElementContext {
	var p = new(SelectElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_selectElement
	return p
}

func (*SelectElementContext) IsSelectElementContext() {}

func NewSelectElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectElementContext {
	var p = new(SelectElementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_selectElement

	return p
}

func (s *SelectElementContext) GetParser() antlr.Parser { return s.parser }

func (s *SelectElementContext) AllOBJECT_NAME() []antlr.TerminalNode {
	return s.GetTokens(CqlParserOBJECT_NAME)
}

func (s *SelectElementContext) OBJECT_NAME(i int) antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, i)
}

func (s *SelectElementContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

func (s *SelectElementContext) STAR() antlr.TerminalNode {
	return s.GetToken(CqlParserSTAR, 0)
}

func (s *SelectElementContext) KwAs() IKwAsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAsContext)
}

func (s *SelectElementContext) FunctionCall() IFunctionCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionCallContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionCallContext)
}

func (s *SelectElementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SelectElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SelectElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterSelectElement(s)
	}
}

func (s *SelectElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitSelectElement(s)
	}
}

func (p *CqlParser) SelectElement() (localctx ISelectElementContext) {
	this := p
	_ = this

	localctx = NewSelectElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 280, CqlParserRULE_selectElement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1905)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 159, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1890)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1891)
			p.Match(CqlParserDOT)
		}
		{
			p.SetState(1892)
			p.Match(CqlParserSTAR)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1893)
			p.Match(CqlParserOBJECT_NAME)
		}
		p.SetState(1897)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == CqlParserK_AS {
			{
				p.SetState(1894)
				p.KwAs()
			}
			{
				p.SetState(1895)
				p.Match(CqlParserOBJECT_NAME)
			}

		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1899)
			p.FunctionCall()
		}
		p.SetState(1903)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == CqlParserK_AS {
			{
				p.SetState(1900)
				p.KwAs()
			}
			{
				p.SetState(1901)
				p.Match(CqlParserOBJECT_NAME)
			}

		}

	}

	return localctx
}

// IRelationElementsContext is an interface to support dynamic dispatch.
type IRelationElementsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRelationElementsContext differentiates from other interfaces.
	IsRelationElementsContext()
}

type RelationElementsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRelationElementsContext() *RelationElementsContext {
	var p = new(RelationElementsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_relationElements
	return p
}

func (*RelationElementsContext) IsRelationElementsContext() {}

func NewRelationElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationElementsContext {
	var p = new(RelationElementsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_relationElements

	return p
}

func (s *RelationElementsContext) GetParser() antlr.Parser { return s.parser }

func (s *RelationElementsContext) AllRelationElement() []IRelationElementContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IRelationElementContext)(nil)).Elem())
	var tst = make([]IRelationElementContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IRelationElementContext)
		}
	}

	return tst
}

func (s *RelationElementsContext) RelationElement(i int) IRelationElementContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRelationElementContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IRelationElementContext)
}

func (s *RelationElementsContext) AllKwAnd() []IKwAndContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IKwAndContext)(nil)).Elem())
	var tst = make([]IKwAndContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IKwAndContext)
		}
	}

	return tst
}

func (s *RelationElementsContext) KwAnd(i int) IKwAndContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAndContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IKwAndContext)
}

func (s *RelationElementsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RelationElementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RelationElementsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterRelationElements(s)
	}
}

func (s *RelationElementsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitRelationElements(s)
	}
}

func (p *CqlParser) RelationElements() (localctx IRelationElementsContext) {
	this := p
	_ = this

	localctx = NewRelationElementsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 282, CqlParserRULE_relationElements)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1907)
		p.RelationElement()
	}

	p.SetState(1913)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserK_AND {
		{
			p.SetState(1908)
			p.KwAnd()
		}
		{
			p.SetState(1909)
			p.RelationElement()
		}

		p.SetState(1915)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IRelationElementContext is an interface to support dynamic dispatch.
type IRelationElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRelationElementContext differentiates from other interfaces.
	IsRelationElementContext()
}

type RelationElementContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRelationElementContext() *RelationElementContext {
	var p = new(RelationElementContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_relationElement
	return p
}

func (*RelationElementContext) IsRelationElementContext() {}

func NewRelationElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationElementContext {
	var p = new(RelationElementContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_relationElement

	return p
}

func (s *RelationElementContext) GetParser() antlr.Parser { return s.parser }

func (s *RelationElementContext) AllOBJECT_NAME() []antlr.TerminalNode {
	return s.GetTokens(CqlParserOBJECT_NAME)
}

func (s *RelationElementContext) OBJECT_NAME(i int) antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, i)
}

func (s *RelationElementContext) Constant() IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

func (s *RelationElementContext) OPERATOR_EQ() antlr.TerminalNode {
	return s.GetToken(CqlParserOPERATOR_EQ, 0)
}

func (s *RelationElementContext) OPERATOR_LT() antlr.TerminalNode {
	return s.GetToken(CqlParserOPERATOR_LT, 0)
}

func (s *RelationElementContext) OPERATOR_GT() antlr.TerminalNode {
	return s.GetToken(CqlParserOPERATOR_GT, 0)
}

func (s *RelationElementContext) OPERATOR_LTE() antlr.TerminalNode {
	return s.GetToken(CqlParserOPERATOR_LTE, 0)
}

func (s *RelationElementContext) OPERATOR_GTE() antlr.TerminalNode {
	return s.GetToken(CqlParserOPERATOR_GTE, 0)
}

func (s *RelationElementContext) DOT() antlr.TerminalNode {
	return s.GetToken(CqlParserDOT, 0)
}

func (s *RelationElementContext) AllFunctionCall() []IFunctionCallContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFunctionCallContext)(nil)).Elem())
	var tst = make([]IFunctionCallContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IFunctionCallContext)
		}
	}

	return tst
}

func (s *RelationElementContext) FunctionCall(i int) IFunctionCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionCallContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IFunctionCallContext)
}

func (s *RelationElementContext) KwIn() IKwInContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwInContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwInContext)
}

func (s *RelationElementContext) AllLR_BRACKET() []antlr.TerminalNode {
	return s.GetTokens(CqlParserLR_BRACKET)
}

func (s *RelationElementContext) LR_BRACKET(i int) antlr.TerminalNode {
	return s.GetToken(CqlParserLR_BRACKET, i)
}

func (s *RelationElementContext) AllRR_BRACKET() []antlr.TerminalNode {
	return s.GetTokens(CqlParserRR_BRACKET)
}

func (s *RelationElementContext) RR_BRACKET(i int) antlr.TerminalNode {
	return s.GetToken(CqlParserRR_BRACKET, i)
}

func (s *RelationElementContext) FunctionArgs() IFunctionArgsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionArgsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionArgsContext)
}

func (s *RelationElementContext) AllAssignmentTuple() []IAssignmentTupleContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAssignmentTupleContext)(nil)).Elem())
	var tst = make([]IAssignmentTupleContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IAssignmentTupleContext)
		}
	}

	return tst
}

func (s *RelationElementContext) AssignmentTuple(i int) IAssignmentTupleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAssignmentTupleContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAssignmentTupleContext)
}

func (s *RelationElementContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *RelationElementContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *RelationElementContext) RelalationContainsKey() IRelalationContainsKeyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRelalationContainsKeyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRelalationContainsKeyContext)
}

func (s *RelationElementContext) RelalationContains() IRelalationContainsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRelalationContainsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRelalationContainsContext)
}

func (s *RelationElementContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RelationElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RelationElementContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterRelationElement(s)
	}
}

func (s *RelationElementContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitRelationElement(s)
	}
}

func (p *CqlParser) RelationElement() (localctx IRelationElementContext) {
	this := p
	_ = this

	localctx = NewRelationElementContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 284, CqlParserRULE_relationElement)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1987)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 166, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1916)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1917)
			_la = p.GetTokenStream().LA(1)

			if !(((_la-171)&-(0x1f+1)) == 0 && ((1<<uint((_la-171)))&((1<<(CqlParserOPERATOR_EQ-171))|(1<<(CqlParserOPERATOR_LT-171))|(1<<(CqlParserOPERATOR_GT-171))|(1<<(CqlParserOPERATOR_LTE-171))|(1<<(CqlParserOPERATOR_GTE-171)))) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1918)
			p.Constant()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1919)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1920)
			p.Match(CqlParserDOT)
		}
		{
			p.SetState(1921)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1922)
			_la = p.GetTokenStream().LA(1)

			if !(((_la-171)&-(0x1f+1)) == 0 && ((1<<uint((_la-171)))&((1<<(CqlParserOPERATOR_EQ-171))|(1<<(CqlParserOPERATOR_LT-171))|(1<<(CqlParserOPERATOR_GT-171))|(1<<(CqlParserOPERATOR_LTE-171))|(1<<(CqlParserOPERATOR_GTE-171)))) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1923)
			p.Constant()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1924)
			p.FunctionCall()
		}
		{
			p.SetState(1925)
			_la = p.GetTokenStream().LA(1)

			if !(((_la-171)&-(0x1f+1)) == 0 && ((1<<uint((_la-171)))&((1<<(CqlParserOPERATOR_EQ-171))|(1<<(CqlParserOPERATOR_LT-171))|(1<<(CqlParserOPERATOR_GT-171))|(1<<(CqlParserOPERATOR_LTE-171))|(1<<(CqlParserOPERATOR_GTE-171)))) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1926)
			p.Constant()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1928)
			p.FunctionCall()
		}
		{
			p.SetState(1929)
			_la = p.GetTokenStream().LA(1)

			if !(((_la-171)&-(0x1f+1)) == 0 && ((1<<uint((_la-171)))&((1<<(CqlParserOPERATOR_EQ-171))|(1<<(CqlParserOPERATOR_LT-171))|(1<<(CqlParserOPERATOR_GT-171))|(1<<(CqlParserOPERATOR_LTE-171))|(1<<(CqlParserOPERATOR_GTE-171)))) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1930)
			p.FunctionCall()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1932)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(1933)
			p.KwIn()
		}
		{
			p.SetState(1934)
			p.Match(CqlParserLR_BRACKET)
		}
		p.SetState(1936)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == CqlParserK_FALSE || _la == CqlParserK_NULL || _la == CqlParserK_TRUE || (((_la-163)&-(0x1f+1)) == 0 && ((1<<uint((_la-163)))&((1<<(CqlParserCODE_BLOCK-163))|(1<<(CqlParserSTRING_LITERAL-163))|(1<<(CqlParserDECIMAL_LITERAL-163))|(1<<(CqlParserFLOAT_LITERAL-163))|(1<<(CqlParserHEXADECIMAL_LITERAL-163))|(1<<(CqlParserOBJECT_NAME-163))|(1<<(CqlParserUUID-163)))) != 0) {
			{
				p.SetState(1935)
				p.FunctionArgs()
			}

		}
		{
			p.SetState(1938)
			p.Match(CqlParserRR_BRACKET)
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1940)
			p.Match(CqlParserLR_BRACKET)
		}
		{
			p.SetState(1941)
			p.Match(CqlParserOBJECT_NAME)
		}
		p.SetState(1947)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == CqlParserCOMMA {
			{
				p.SetState(1942)
				p.SyntaxComma()
			}
			{
				p.SetState(1943)
				p.Match(CqlParserOBJECT_NAME)
			}

			p.SetState(1949)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1950)
			p.Match(CqlParserRR_BRACKET)
		}
		{
			p.SetState(1951)
			p.KwIn()
		}
		{
			p.SetState(1952)
			p.Match(CqlParserLR_BRACKET)
		}
		{
			p.SetState(1953)
			p.AssignmentTuple()
		}
		p.SetState(1959)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == CqlParserCOMMA {
			{
				p.SetState(1954)
				p.SyntaxComma()
			}
			{
				p.SetState(1955)
				p.AssignmentTuple()
			}

			p.SetState(1961)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1962)
			p.Match(CqlParserRR_BRACKET)
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(1964)
			p.Match(CqlParserLR_BRACKET)
		}
		{
			p.SetState(1965)
			p.Match(CqlParserOBJECT_NAME)
		}
		p.SetState(1971)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == CqlParserCOMMA {
			{
				p.SetState(1966)
				p.SyntaxComma()
			}
			{
				p.SetState(1967)
				p.Match(CqlParserOBJECT_NAME)
			}

			p.SetState(1973)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1974)
			p.Match(CqlParserRR_BRACKET)
		}
		{
			p.SetState(1975)
			_la = p.GetTokenStream().LA(1)

			if !(((_la-171)&-(0x1f+1)) == 0 && ((1<<uint((_la-171)))&((1<<(CqlParserOPERATOR_EQ-171))|(1<<(CqlParserOPERATOR_LT-171))|(1<<(CqlParserOPERATOR_GT-171))|(1<<(CqlParserOPERATOR_LTE-171))|(1<<(CqlParserOPERATOR_GTE-171)))) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

		{
			p.SetState(1976)
			p.AssignmentTuple()
		}
		p.SetState(1982)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == CqlParserCOMMA {
			{
				p.SetState(1977)
				p.SyntaxComma()
			}
			{
				p.SetState(1978)
				p.AssignmentTuple()
			}

			p.SetState(1984)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(1985)
			p.RelalationContainsKey()
		}

	case 9:
		p.EnterOuterAlt(localctx, 9)
		{
			p.SetState(1986)
			p.RelalationContains()
		}

	}

	return localctx
}

// IRelalationContainsContext is an interface to support dynamic dispatch.
type IRelalationContainsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRelalationContainsContext differentiates from other interfaces.
	IsRelalationContainsContext()
}

type RelalationContainsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRelalationContainsContext() *RelalationContainsContext {
	var p = new(RelalationContainsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_relalationContains
	return p
}

func (*RelalationContainsContext) IsRelalationContainsContext() {}

func NewRelalationContainsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelalationContainsContext {
	var p = new(RelalationContainsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_relalationContains

	return p
}

func (s *RelalationContainsContext) GetParser() antlr.Parser { return s.parser }

func (s *RelalationContainsContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *RelalationContainsContext) KwContains() IKwContainsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwContainsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwContainsContext)
}

func (s *RelalationContainsContext) Constant() IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

func (s *RelalationContainsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RelalationContainsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RelalationContainsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterRelalationContains(s)
	}
}

func (s *RelalationContainsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitRelalationContains(s)
	}
}

func (p *CqlParser) RelalationContains() (localctx IRelalationContainsContext) {
	this := p
	_ = this

	localctx = NewRelalationContainsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 286, CqlParserRULE_relalationContains)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1989)
		p.Match(CqlParserOBJECT_NAME)
	}
	{
		p.SetState(1990)
		p.KwContains()
	}
	{
		p.SetState(1991)
		p.Constant()
	}

	return localctx
}

// IRelalationContainsKeyContext is an interface to support dynamic dispatch.
type IRelalationContainsKeyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRelalationContainsKeyContext differentiates from other interfaces.
	IsRelalationContainsKeyContext()
}

type RelalationContainsKeyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRelalationContainsKeyContext() *RelalationContainsKeyContext {
	var p = new(RelalationContainsKeyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_relalationContainsKey
	return p
}

func (*RelalationContainsKeyContext) IsRelalationContainsKeyContext() {}

func NewRelalationContainsKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelalationContainsKeyContext {
	var p = new(RelalationContainsKeyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_relalationContainsKey

	return p
}

func (s *RelalationContainsKeyContext) GetParser() antlr.Parser { return s.parser }

func (s *RelalationContainsKeyContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *RelalationContainsKeyContext) Constant() IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

func (s *RelalationContainsKeyContext) KwContains() IKwContainsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwContainsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwContainsContext)
}

func (s *RelalationContainsKeyContext) KwKey() IKwKeyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwKeyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwKeyContext)
}

func (s *RelalationContainsKeyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RelalationContainsKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RelalationContainsKeyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterRelalationContainsKey(s)
	}
}

func (s *RelalationContainsKeyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitRelalationContainsKey(s)
	}
}

func (p *CqlParser) RelalationContainsKey() (localctx IRelalationContainsKeyContext) {
	this := p
	_ = this

	localctx = NewRelalationContainsKeyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 288, CqlParserRULE_relalationContainsKey)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1993)
		p.Match(CqlParserOBJECT_NAME)
	}

	{
		p.SetState(1994)
		p.KwContains()
	}
	{
		p.SetState(1995)
		p.KwKey()
	}

	{
		p.SetState(1997)
		p.Constant()
	}

	return localctx
}

// IFunctionCallContext is an interface to support dynamic dispatch.
type IFunctionCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunctionCallContext differentiates from other interfaces.
	IsFunctionCallContext()
}

type FunctionCallContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunctionCallContext() *FunctionCallContext {
	var p = new(FunctionCallContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_functionCall
	return p
}

func (*FunctionCallContext) IsFunctionCallContext() {}

func NewFunctionCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallContext {
	var p = new(FunctionCallContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_functionCall

	return p
}

func (s *FunctionCallContext) GetParser() antlr.Parser { return s.parser }

func (s *FunctionCallContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *FunctionCallContext) LR_BRACKET() antlr.TerminalNode {
	return s.GetToken(CqlParserLR_BRACKET, 0)
}

func (s *FunctionCallContext) STAR() antlr.TerminalNode {
	return s.GetToken(CqlParserSTAR, 0)
}

func (s *FunctionCallContext) RR_BRACKET() antlr.TerminalNode {
	return s.GetToken(CqlParserRR_BRACKET, 0)
}

func (s *FunctionCallContext) FunctionArgs() IFunctionArgsContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionArgsContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunctionArgsContext)
}

func (s *FunctionCallContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FunctionCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FunctionCallContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterFunctionCall(s)
	}
}

func (s *FunctionCallContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitFunctionCall(s)
	}
}

func (p *CqlParser) FunctionCall() (localctx IFunctionCallContext) {
	this := p
	_ = this

	localctx = NewFunctionCallContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 290, CqlParserRULE_functionCall)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(2009)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 168, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1999)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(2000)
			p.Match(CqlParserLR_BRACKET)
		}
		{
			p.SetState(2001)
			p.Match(CqlParserSTAR)
		}
		{
			p.SetState(2002)
			p.Match(CqlParserRR_BRACKET)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2003)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(2004)
			p.Match(CqlParserLR_BRACKET)
		}
		p.SetState(2006)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == CqlParserK_FALSE || _la == CqlParserK_NULL || _la == CqlParserK_TRUE || (((_la-163)&-(0x1f+1)) == 0 && ((1<<uint((_la-163)))&((1<<(CqlParserCODE_BLOCK-163))|(1<<(CqlParserSTRING_LITERAL-163))|(1<<(CqlParserDECIMAL_LITERAL-163))|(1<<(CqlParserFLOAT_LITERAL-163))|(1<<(CqlParserHEXADECIMAL_LITERAL-163))|(1<<(CqlParserOBJECT_NAME-163))|(1<<(CqlParserUUID-163)))) != 0) {
			{
				p.SetState(2005)
				p.FunctionArgs()
			}

		}
		{
			p.SetState(2008)
			p.Match(CqlParserRR_BRACKET)
		}

	}

	return localctx
}

// IFunctionArgsContext is an interface to support dynamic dispatch.
type IFunctionArgsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunctionArgsContext differentiates from other interfaces.
	IsFunctionArgsContext()
}

type FunctionArgsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunctionArgsContext() *FunctionArgsContext {
	var p = new(FunctionArgsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_functionArgs
	return p
}

func (*FunctionArgsContext) IsFunctionArgsContext() {}

func NewFunctionArgsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionArgsContext {
	var p = new(FunctionArgsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_functionArgs

	return p
}

func (s *FunctionArgsContext) GetParser() antlr.Parser { return s.parser }

func (s *FunctionArgsContext) AllConstant() []IConstantContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IConstantContext)(nil)).Elem())
	var tst = make([]IConstantContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IConstantContext)
		}
	}

	return tst
}

func (s *FunctionArgsContext) Constant(i int) IConstantContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConstantContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IConstantContext)
}

func (s *FunctionArgsContext) AllOBJECT_NAME() []antlr.TerminalNode {
	return s.GetTokens(CqlParserOBJECT_NAME)
}

func (s *FunctionArgsContext) OBJECT_NAME(i int) antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, i)
}

func (s *FunctionArgsContext) AllFunctionCall() []IFunctionCallContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFunctionCallContext)(nil)).Elem())
	var tst = make([]IFunctionCallContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IFunctionCallContext)
		}
	}

	return tst
}

func (s *FunctionArgsContext) FunctionCall(i int) IFunctionCallContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunctionCallContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IFunctionCallContext)
}

func (s *FunctionArgsContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *FunctionArgsContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *FunctionArgsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FunctionArgsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FunctionArgsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterFunctionArgs(s)
	}
}

func (s *FunctionArgsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitFunctionArgs(s)
	}
}

func (p *CqlParser) FunctionArgs() (localctx IFunctionArgsContext) {
	this := p
	_ = this

	localctx = NewFunctionArgsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 292, CqlParserRULE_functionArgs)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(2014)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 169, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(2011)
			p.Constant()
		}

	case 2:
		{
			p.SetState(2012)
			p.Match(CqlParserOBJECT_NAME)
		}

	case 3:
		{
			p.SetState(2013)
			p.FunctionCall()
		}

	}
	p.SetState(2024)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(2016)
			p.SyntaxComma()
		}
		p.SetState(2020)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 170, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(2017)
				p.Constant()
			}

		case 2:
			{
				p.SetState(2018)
				p.Match(CqlParserOBJECT_NAME)
			}

		case 3:
			{
				p.SetState(2019)
				p.FunctionCall()
			}

		}

		p.SetState(2026)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}

	return localctx
}

// IConstantContext is an interface to support dynamic dispatch.
type IConstantContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConstantContext differentiates from other interfaces.
	IsConstantContext()
}

type ConstantContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyConstantContext() *ConstantContext {
	var p = new(ConstantContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_constant
	return p
}

func (*ConstantContext) IsConstantContext() {}

func NewConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantContext {
	var p = new(ConstantContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_constant

	return p
}

func (s *ConstantContext) GetParser() antlr.Parser { return s.parser }

func (s *ConstantContext) UUID() antlr.TerminalNode {
	return s.GetToken(CqlParserUUID, 0)
}

func (s *ConstantContext) StringLiteral() IStringLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStringLiteralContext)
}

func (s *ConstantContext) DecimalLiteral() IDecimalLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDecimalLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDecimalLiteralContext)
}

func (s *ConstantContext) FloatLiteral() IFloatLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFloatLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFloatLiteralContext)
}

func (s *ConstantContext) HexadecimalLiteral() IHexadecimalLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IHexadecimalLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IHexadecimalLiteralContext)
}

func (s *ConstantContext) BooleanLiteral() IBooleanLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBooleanLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBooleanLiteralContext)
}

func (s *ConstantContext) CodeBlock() ICodeBlockContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICodeBlockContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICodeBlockContext)
}

func (s *ConstantContext) KwNull() IKwNullContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwNullContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwNullContext)
}

func (s *ConstantContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ConstantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ConstantContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterConstant(s)
	}
}

func (s *ConstantContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitConstant(s)
	}
}

func (p *CqlParser) Constant() (localctx IConstantContext) {
	this := p
	_ = this

	localctx = NewConstantContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 294, CqlParserRULE_constant)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(2035)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 172, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2027)
			p.Match(CqlParserUUID)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2028)
			p.StringLiteral()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2029)
			p.DecimalLiteral()
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2030)
			p.FloatLiteral()
		}

	case 5:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(2031)
			p.HexadecimalLiteral()
		}

	case 6:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(2032)
			p.BooleanLiteral()
		}

	case 7:
		p.EnterOuterAlt(localctx, 7)
		{
			p.SetState(2033)
			p.CodeBlock()
		}

	case 8:
		p.EnterOuterAlt(localctx, 8)
		{
			p.SetState(2034)
			p.KwNull()
		}

	}

	return localctx
}

// IDecimalLiteralContext is an interface to support dynamic dispatch.
type IDecimalLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDecimalLiteralContext differentiates from other interfaces.
	IsDecimalLiteralContext()
}

type DecimalLiteralContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDecimalLiteralContext() *DecimalLiteralContext {
	var p = new(DecimalLiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_decimalLiteral
	return p
}

func (*DecimalLiteralContext) IsDecimalLiteralContext() {}

func NewDecimalLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DecimalLiteralContext {
	var p = new(DecimalLiteralContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_decimalLiteral

	return p
}

func (s *DecimalLiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *DecimalLiteralContext) DECIMAL_LITERAL() antlr.TerminalNode {
	return s.GetToken(CqlParserDECIMAL_LITERAL, 0)
}

func (s *DecimalLiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DecimalLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DecimalLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDecimalLiteral(s)
	}
}

func (s *DecimalLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDecimalLiteral(s)
	}
}

func (p *CqlParser) DecimalLiteral() (localctx IDecimalLiteralContext) {
	this := p
	_ = this

	localctx = NewDecimalLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 296, CqlParserRULE_decimalLiteral)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2037)
		p.Match(CqlParserDECIMAL_LITERAL)
	}

	return localctx
}

// IFloatLiteralContext is an interface to support dynamic dispatch.
type IFloatLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFloatLiteralContext differentiates from other interfaces.
	IsFloatLiteralContext()
}

type FloatLiteralContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFloatLiteralContext() *FloatLiteralContext {
	var p = new(FloatLiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_floatLiteral
	return p
}

func (*FloatLiteralContext) IsFloatLiteralContext() {}

func NewFloatLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FloatLiteralContext {
	var p = new(FloatLiteralContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_floatLiteral

	return p
}

func (s *FloatLiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *FloatLiteralContext) DECIMAL_LITERAL() antlr.TerminalNode {
	return s.GetToken(CqlParserDECIMAL_LITERAL, 0)
}

func (s *FloatLiteralContext) FLOAT_LITERAL() antlr.TerminalNode {
	return s.GetToken(CqlParserFLOAT_LITERAL, 0)
}

func (s *FloatLiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *FloatLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *FloatLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterFloatLiteral(s)
	}
}

func (s *FloatLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitFloatLiteral(s)
	}
}

func (p *CqlParser) FloatLiteral() (localctx IFloatLiteralContext) {
	this := p
	_ = this

	localctx = NewFloatLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 298, CqlParserRULE_floatLiteral)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2039)
		_la = p.GetTokenStream().LA(1)

		if !(_la == CqlParserDECIMAL_LITERAL || _la == CqlParserFLOAT_LITERAL) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IStringLiteralContext is an interface to support dynamic dispatch.
type IStringLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStringLiteralContext differentiates from other interfaces.
	IsStringLiteralContext()
}

type StringLiteralContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyStringLiteralContext() *StringLiteralContext {
	var p = new(StringLiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_stringLiteral
	return p
}

func (*StringLiteralContext) IsStringLiteralContext() {}

func NewStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringLiteralContext {
	var p = new(StringLiteralContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_stringLiteral

	return p
}

func (s *StringLiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *StringLiteralContext) STRING_LITERAL() antlr.TerminalNode {
	return s.GetToken(CqlParserSTRING_LITERAL, 0)
}

func (s *StringLiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *StringLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *StringLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterStringLiteral(s)
	}
}

func (s *StringLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitStringLiteral(s)
	}
}

func (p *CqlParser) StringLiteral() (localctx IStringLiteralContext) {
	this := p
	_ = this

	localctx = NewStringLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 300, CqlParserRULE_stringLiteral)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2041)
		p.Match(CqlParserSTRING_LITERAL)
	}

	return localctx
}

// IBooleanLiteralContext is an interface to support dynamic dispatch.
type IBooleanLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBooleanLiteralContext differentiates from other interfaces.
	IsBooleanLiteralContext()
}

type BooleanLiteralContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyBooleanLiteralContext() *BooleanLiteralContext {
	var p = new(BooleanLiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_booleanLiteral
	return p
}

func (*BooleanLiteralContext) IsBooleanLiteralContext() {}

func NewBooleanLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BooleanLiteralContext {
	var p = new(BooleanLiteralContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_booleanLiteral

	return p
}

func (s *BooleanLiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *BooleanLiteralContext) K_TRUE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_TRUE, 0)
}

func (s *BooleanLiteralContext) K_FALSE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_FALSE, 0)
}

func (s *BooleanLiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *BooleanLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *BooleanLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterBooleanLiteral(s)
	}
}

func (s *BooleanLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitBooleanLiteral(s)
	}
}

func (p *CqlParser) BooleanLiteral() (localctx IBooleanLiteralContext) {
	this := p
	_ = this

	localctx = NewBooleanLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 302, CqlParserRULE_booleanLiteral)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2043)
		_la = p.GetTokenStream().LA(1)

		if !(_la == CqlParserK_FALSE || _la == CqlParserK_TRUE) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IHexadecimalLiteralContext is an interface to support dynamic dispatch.
type IHexadecimalLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsHexadecimalLiteralContext differentiates from other interfaces.
	IsHexadecimalLiteralContext()
}

type HexadecimalLiteralContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyHexadecimalLiteralContext() *HexadecimalLiteralContext {
	var p = new(HexadecimalLiteralContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_hexadecimalLiteral
	return p
}

func (*HexadecimalLiteralContext) IsHexadecimalLiteralContext() {}

func NewHexadecimalLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HexadecimalLiteralContext {
	var p = new(HexadecimalLiteralContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_hexadecimalLiteral

	return p
}

func (s *HexadecimalLiteralContext) GetParser() antlr.Parser { return s.parser }

func (s *HexadecimalLiteralContext) HEXADECIMAL_LITERAL() antlr.TerminalNode {
	return s.GetToken(CqlParserHEXADECIMAL_LITERAL, 0)
}

func (s *HexadecimalLiteralContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *HexadecimalLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *HexadecimalLiteralContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterHexadecimalLiteral(s)
	}
}

func (s *HexadecimalLiteralContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitHexadecimalLiteral(s)
	}
}

func (p *CqlParser) HexadecimalLiteral() (localctx IHexadecimalLiteralContext) {
	this := p
	_ = this

	localctx = NewHexadecimalLiteralContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 304, CqlParserRULE_hexadecimalLiteral)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2045)
		p.Match(CqlParserHEXADECIMAL_LITERAL)
	}

	return localctx
}

// IKeyspaceContext is an interface to support dynamic dispatch.
type IKeyspaceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKeyspaceContext differentiates from other interfaces.
	IsKeyspaceContext()
}

type KeyspaceContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKeyspaceContext() *KeyspaceContext {
	var p = new(KeyspaceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_keyspace
	return p
}

func (*KeyspaceContext) IsKeyspaceContext() {}

func NewKeyspaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeyspaceContext {
	var p = new(KeyspaceContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_keyspace

	return p
}

func (s *KeyspaceContext) GetParser() antlr.Parser { return s.parser }

func (s *KeyspaceContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *KeyspaceContext) AllDQUOTE() []antlr.TerminalNode {
	return s.GetTokens(CqlParserDQUOTE)
}

func (s *KeyspaceContext) DQUOTE(i int) antlr.TerminalNode {
	return s.GetToken(CqlParserDQUOTE, i)
}

func (s *KeyspaceContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KeyspaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KeyspaceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKeyspace(s)
	}
}

func (s *KeyspaceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKeyspace(s)
	}
}

func (p *CqlParser) Keyspace() (localctx IKeyspaceContext) {
	this := p
	_ = this

	localctx = NewKeyspaceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 306, CqlParserRULE_keyspace)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(2051)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserOBJECT_NAME:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2047)
			p.Match(CqlParserOBJECT_NAME)
		}

	case CqlParserDQUOTE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2048)
			p.Match(CqlParserDQUOTE)
		}
		{
			p.SetState(2049)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(2050)
			p.Match(CqlParserDQUOTE)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// ITableContext is an interface to support dynamic dispatch.
type ITableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTableContext differentiates from other interfaces.
	IsTableContext()
}

type TableContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTableContext() *TableContext {
	var p = new(TableContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_table
	return p
}

func (*TableContext) IsTableContext() {}

func NewTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableContext {
	var p = new(TableContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_table

	return p
}

func (s *TableContext) GetParser() antlr.Parser { return s.parser }

func (s *TableContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *TableContext) AllDQUOTE() []antlr.TerminalNode {
	return s.GetTokens(CqlParserDQUOTE)
}

func (s *TableContext) DQUOTE(i int) antlr.TerminalNode {
	return s.GetToken(CqlParserDQUOTE, i)
}

func (s *TableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterTable(s)
	}
}

func (s *TableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitTable(s)
	}
}

func (p *CqlParser) Table() (localctx ITableContext) {
	this := p
	_ = this

	localctx = NewTableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 308, CqlParserRULE_table)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(2057)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserOBJECT_NAME:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2053)
			p.Match(CqlParserOBJECT_NAME)
		}

	case CqlParserDQUOTE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2054)
			p.Match(CqlParserDQUOTE)
		}
		{
			p.SetState(2055)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(2056)
			p.Match(CqlParserDQUOTE)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IColumnContext is an interface to support dynamic dispatch.
type IColumnContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsColumnContext differentiates from other interfaces.
	IsColumnContext()
}

type ColumnContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColumnContext() *ColumnContext {
	var p = new(ColumnContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_column
	return p
}

func (*ColumnContext) IsColumnContext() {}

func NewColumnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnContext {
	var p = new(ColumnContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_column

	return p
}

func (s *ColumnContext) GetParser() antlr.Parser { return s.parser }

func (s *ColumnContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *ColumnContext) AllDQUOTE() []antlr.TerminalNode {
	return s.GetTokens(CqlParserDQUOTE)
}

func (s *ColumnContext) DQUOTE(i int) antlr.TerminalNode {
	return s.GetToken(CqlParserDQUOTE, i)
}

func (s *ColumnContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ColumnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ColumnContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterColumn(s)
	}
}

func (s *ColumnContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitColumn(s)
	}
}

func (p *CqlParser) Column() (localctx IColumnContext) {
	this := p
	_ = this

	localctx = NewColumnContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 310, CqlParserRULE_column)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(2063)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserOBJECT_NAME:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2059)
			p.Match(CqlParserOBJECT_NAME)
		}

	case CqlParserDQUOTE:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2060)
			p.Match(CqlParserDQUOTE)
		}
		{
			p.SetState(2061)
			p.Match(CqlParserOBJECT_NAME)
		}
		{
			p.SetState(2062)
			p.Match(CqlParserDQUOTE)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IDataTypeContext is an interface to support dynamic dispatch.
type IDataTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDataTypeContext differentiates from other interfaces.
	IsDataTypeContext()
}

type DataTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDataTypeContext() *DataTypeContext {
	var p = new(DataTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_dataType
	return p
}

func (*DataTypeContext) IsDataTypeContext() {}

func NewDataTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeContext {
	var p = new(DataTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_dataType

	return p
}

func (s *DataTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *DataTypeContext) DataTypeName() IDataTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDataTypeNameContext)
}

func (s *DataTypeContext) DataTypeDefinition() IDataTypeDefinitionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeDefinitionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDataTypeDefinitionContext)
}

func (s *DataTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DataTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DataTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDataType(s)
	}
}

func (s *DataTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDataType(s)
	}
}

func (p *CqlParser) DataType() (localctx IDataTypeContext) {
	this := p
	_ = this

	localctx = NewDataTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 312, CqlParserRULE_dataType)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2065)
		p.DataTypeName()
	}
	p.SetState(2067)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == CqlParserOPERATOR_LT {
		{
			p.SetState(2066)
			p.DataTypeDefinition()
		}

	}

	return localctx
}

// IDataTypeNameContext is an interface to support dynamic dispatch.
type IDataTypeNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDataTypeNameContext differentiates from other interfaces.
	IsDataTypeNameContext()
}

type DataTypeNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDataTypeNameContext() *DataTypeNameContext {
	var p = new(DataTypeNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_dataTypeName
	return p
}

func (*DataTypeNameContext) IsDataTypeNameContext() {}

func NewDataTypeNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeNameContext {
	var p = new(DataTypeNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_dataTypeName

	return p
}

func (s *DataTypeNameContext) GetParser() antlr.Parser { return s.parser }

func (s *DataTypeNameContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *DataTypeNameContext) K_TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(CqlParserK_TIMESTAMP, 0)
}

func (s *DataTypeNameContext) K_SET() antlr.TerminalNode {
	return s.GetToken(CqlParserK_SET, 0)
}

func (s *DataTypeNameContext) K_ASCII() antlr.TerminalNode {
	return s.GetToken(CqlParserK_ASCII, 0)
}

func (s *DataTypeNameContext) K_BIGINT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_BIGINT, 0)
}

func (s *DataTypeNameContext) K_BLOB() antlr.TerminalNode {
	return s.GetToken(CqlParserK_BLOB, 0)
}

func (s *DataTypeNameContext) K_BOOLEAN() antlr.TerminalNode {
	return s.GetToken(CqlParserK_BOOLEAN, 0)
}

func (s *DataTypeNameContext) K_COUNTER() antlr.TerminalNode {
	return s.GetToken(CqlParserK_COUNTER, 0)
}

func (s *DataTypeNameContext) K_DATE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_DATE, 0)
}

func (s *DataTypeNameContext) K_DECIMAL() antlr.TerminalNode {
	return s.GetToken(CqlParserK_DECIMAL, 0)
}

func (s *DataTypeNameContext) K_DOUBLE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_DOUBLE, 0)
}

func (s *DataTypeNameContext) K_FLOAT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_FLOAT, 0)
}

func (s *DataTypeNameContext) K_FROZEN() antlr.TerminalNode {
	return s.GetToken(CqlParserK_FROZEN, 0)
}

func (s *DataTypeNameContext) K_INET() antlr.TerminalNode {
	return s.GetToken(CqlParserK_INET, 0)
}

func (s *DataTypeNameContext) K_INT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_INT, 0)
}

func (s *DataTypeNameContext) K_LIST() antlr.TerminalNode {
	return s.GetToken(CqlParserK_LIST, 0)
}

func (s *DataTypeNameContext) K_MAP() antlr.TerminalNode {
	return s.GetToken(CqlParserK_MAP, 0)
}

func (s *DataTypeNameContext) K_SMALLINT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_SMALLINT, 0)
}

func (s *DataTypeNameContext) K_TEXT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_TEXT, 0)
}

func (s *DataTypeNameContext) K_TIME() antlr.TerminalNode {
	return s.GetToken(CqlParserK_TIME, 0)
}

func (s *DataTypeNameContext) K_TIMEUUID() antlr.TerminalNode {
	return s.GetToken(CqlParserK_TIMEUUID, 0)
}

func (s *DataTypeNameContext) K_TINYINT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_TINYINT, 0)
}

func (s *DataTypeNameContext) K_TUPLE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_TUPLE, 0)
}

func (s *DataTypeNameContext) K_VARCHAR() antlr.TerminalNode {
	return s.GetToken(CqlParserK_VARCHAR, 0)
}

func (s *DataTypeNameContext) K_VARINT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_VARINT, 0)
}

func (s *DataTypeNameContext) K_UUID() antlr.TerminalNode {
	return s.GetToken(CqlParserK_UUID, 0)
}

func (s *DataTypeNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DataTypeNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DataTypeNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDataTypeName(s)
	}
}

func (s *DataTypeNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDataTypeName(s)
	}
}

func (p *CqlParser) DataTypeName() (localctx IDataTypeNameContext) {
	this := p
	_ = this

	localctx = NewDataTypeNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 314, CqlParserRULE_dataTypeName)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2069)
		_la = p.GetTokenStream().LA(1)

		if !((((_la-113)&-(0x1f+1)) == 0 && ((1<<uint((_la-113)))&((1<<(CqlParserK_SET-113))|(1<<(CqlParserK_TIMESTAMP-113))|(1<<(CqlParserK_UUID-113))|(1<<(CqlParserK_ASCII-113))|(1<<(CqlParserK_BIGINT-113))|(1<<(CqlParserK_BLOB-113))|(1<<(CqlParserK_BOOLEAN-113)))) != 0) || (((_la-145)&-(0x1f+1)) == 0 && ((1<<uint((_la-145)))&((1<<(CqlParserK_COUNTER-145))|(1<<(CqlParserK_DATE-145))|(1<<(CqlParserK_DECIMAL-145))|(1<<(CqlParserK_DOUBLE-145))|(1<<(CqlParserK_FLOAT-145))|(1<<(CqlParserK_FROZEN-145))|(1<<(CqlParserK_INET-145))|(1<<(CqlParserK_INT-145))|(1<<(CqlParserK_LIST-145))|(1<<(CqlParserK_MAP-145))|(1<<(CqlParserK_SMALLINT-145))|(1<<(CqlParserK_TEXT-145))|(1<<(CqlParserK_TIMEUUID-145))|(1<<(CqlParserK_TIME-145))|(1<<(CqlParserK_TINYINT-145))|(1<<(CqlParserK_TUPLE-145))|(1<<(CqlParserK_VARCHAR-145))|(1<<(CqlParserK_VARINT-145))|(1<<(CqlParserOBJECT_NAME-145)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

// IDataTypeDefinitionContext is an interface to support dynamic dispatch.
type IDataTypeDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDataTypeDefinitionContext differentiates from other interfaces.
	IsDataTypeDefinitionContext()
}

type DataTypeDefinitionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDataTypeDefinitionContext() *DataTypeDefinitionContext {
	var p = new(DataTypeDefinitionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_dataTypeDefinition
	return p
}

func (*DataTypeDefinitionContext) IsDataTypeDefinitionContext() {}

func NewDataTypeDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeDefinitionContext {
	var p = new(DataTypeDefinitionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_dataTypeDefinition

	return p
}

func (s *DataTypeDefinitionContext) GetParser() antlr.Parser { return s.parser }

func (s *DataTypeDefinitionContext) SyntaxBracketLa() ISyntaxBracketLaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketLaContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketLaContext)
}

func (s *DataTypeDefinitionContext) AllDataTypeName() []IDataTypeNameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDataTypeNameContext)(nil)).Elem())
	var tst = make([]IDataTypeNameContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IDataTypeNameContext)
		}
	}

	return tst
}

func (s *DataTypeDefinitionContext) DataTypeName(i int) IDataTypeNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeNameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDataTypeNameContext)
}

func (s *DataTypeDefinitionContext) SyntaxBracketRa() ISyntaxBracketRaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxBracketRaContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISyntaxBracketRaContext)
}

func (s *DataTypeDefinitionContext) AllSyntaxComma() []ISyntaxCommaContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem())
	var tst = make([]ISyntaxCommaContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISyntaxCommaContext)
		}
	}

	return tst
}

func (s *DataTypeDefinitionContext) SyntaxComma(i int) ISyntaxCommaContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxCommaContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISyntaxCommaContext)
}

func (s *DataTypeDefinitionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *DataTypeDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *DataTypeDefinitionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterDataTypeDefinition(s)
	}
}

func (s *DataTypeDefinitionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitDataTypeDefinition(s)
	}
}

func (p *CqlParser) DataTypeDefinition() (localctx IDataTypeDefinitionContext) {
	this := p
	_ = this

	localctx = NewDataTypeDefinitionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 316, CqlParserRULE_dataTypeDefinition)
	var _la int

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2071)
		p.SyntaxBracketLa()
	}
	{
		p.SetState(2072)
		p.DataTypeName()
	}
	p.SetState(2078)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == CqlParserCOMMA {
		{
			p.SetState(2073)
			p.SyntaxComma()
		}
		{
			p.SetState(2074)
			p.DataTypeName()
		}

		p.SetState(2080)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(2081)
		p.SyntaxBracketRa()
	}

	return localctx
}

// IOrderDirectionContext is an interface to support dynamic dispatch.
type IOrderDirectionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOrderDirectionContext differentiates from other interfaces.
	IsOrderDirectionContext()
}

type OrderDirectionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOrderDirectionContext() *OrderDirectionContext {
	var p = new(OrderDirectionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_orderDirection
	return p
}

func (*OrderDirectionContext) IsOrderDirectionContext() {}

func NewOrderDirectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderDirectionContext {
	var p = new(OrderDirectionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_orderDirection

	return p
}

func (s *OrderDirectionContext) GetParser() antlr.Parser { return s.parser }

func (s *OrderDirectionContext) KwAsc() IKwAscContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwAscContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwAscContext)
}

func (s *OrderDirectionContext) KwDesc() IKwDescContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKwDescContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKwDescContext)
}

func (s *OrderDirectionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *OrderDirectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *OrderDirectionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterOrderDirection(s)
	}
}

func (s *OrderDirectionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitOrderDirection(s)
	}
}

func (p *CqlParser) OrderDirection() (localctx IOrderDirectionContext) {
	this := p
	_ = this

	localctx = NewOrderDirectionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 318, CqlParserRULE_orderDirection)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(2085)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case CqlParserK_ASC:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2083)
			p.KwAsc()
		}

	case CqlParserK_DESC:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2084)
			p.KwDesc()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	return localctx
}

// IRoleContext is an interface to support dynamic dispatch.
type IRoleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRoleContext differentiates from other interfaces.
	IsRoleContext()
}

type RoleContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyRoleContext() *RoleContext {
	var p = new(RoleContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_role
	return p
}

func (*RoleContext) IsRoleContext() {}

func NewRoleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoleContext {
	var p = new(RoleContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_role

	return p
}

func (s *RoleContext) GetParser() antlr.Parser { return s.parser }

func (s *RoleContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *RoleContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *RoleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *RoleContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterRole(s)
	}
}

func (s *RoleContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitRole(s)
	}
}

func (p *CqlParser) Role() (localctx IRoleContext) {
	this := p
	_ = this

	localctx = NewRoleContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 320, CqlParserRULE_role)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2087)
		p.Match(CqlParserOBJECT_NAME)
	}

	return localctx
}

// ITriggerContext is an interface to support dynamic dispatch.
type ITriggerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTriggerContext differentiates from other interfaces.
	IsTriggerContext()
}

type TriggerContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTriggerContext() *TriggerContext {
	var p = new(TriggerContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_trigger
	return p
}

func (*TriggerContext) IsTriggerContext() {}

func NewTriggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerContext {
	var p = new(TriggerContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_trigger

	return p
}

func (s *TriggerContext) GetParser() antlr.Parser { return s.parser }

func (s *TriggerContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *TriggerContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TriggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TriggerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterTrigger(s)
	}
}

func (s *TriggerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitTrigger(s)
	}
}

func (p *CqlParser) Trigger() (localctx ITriggerContext) {
	this := p
	_ = this

	localctx = NewTriggerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 322, CqlParserRULE_trigger)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2089)
		p.Match(CqlParserOBJECT_NAME)
	}

	return localctx
}

// ITriggerClassContext is an interface to support dynamic dispatch.
type ITriggerClassContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTriggerClassContext differentiates from other interfaces.
	IsTriggerClassContext()
}

type TriggerClassContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTriggerClassContext() *TriggerClassContext {
	var p = new(TriggerClassContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_triggerClass
	return p
}

func (*TriggerClassContext) IsTriggerClassContext() {}

func NewTriggerClassContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerClassContext {
	var p = new(TriggerClassContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_triggerClass

	return p
}

func (s *TriggerClassContext) GetParser() antlr.Parser { return s.parser }

func (s *TriggerClassContext) StringLiteral() IStringLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStringLiteralContext)
}

func (s *TriggerClassContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *TriggerClassContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *TriggerClassContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterTriggerClass(s)
	}
}

func (s *TriggerClassContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitTriggerClass(s)
	}
}

func (p *CqlParser) TriggerClass() (localctx ITriggerClassContext) {
	this := p
	_ = this

	localctx = NewTriggerClassContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 324, CqlParserRULE_triggerClass)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2091)
		p.StringLiteral()
	}

	return localctx
}

// IMaterializedViewContext is an interface to support dynamic dispatch.
type IMaterializedViewContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMaterializedViewContext differentiates from other interfaces.
	IsMaterializedViewContext()
}

type MaterializedViewContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyMaterializedViewContext() *MaterializedViewContext {
	var p = new(MaterializedViewContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_materializedView
	return p
}

func (*MaterializedViewContext) IsMaterializedViewContext() {}

func NewMaterializedViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MaterializedViewContext {
	var p = new(MaterializedViewContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_materializedView

	return p
}

func (s *MaterializedViewContext) GetParser() antlr.Parser { return s.parser }

func (s *MaterializedViewContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *MaterializedViewContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *MaterializedViewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *MaterializedViewContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterMaterializedView(s)
	}
}

func (s *MaterializedViewContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitMaterializedView(s)
	}
}

func (p *CqlParser) MaterializedView() (localctx IMaterializedViewContext) {
	this := p
	_ = this

	localctx = NewMaterializedViewContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 326, CqlParserRULE_materializedView)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2093)
		p.Match(CqlParserOBJECT_NAME)
	}

	return localctx
}

// IType_Context is an interface to support dynamic dispatch.
type IType_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsType_Context differentiates from other interfaces.
	IsType_Context()
}

type Type_Context struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyType_Context() *Type_Context {
	var p = new(Type_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_type_
	return p
}

func (*Type_Context) IsType_Context() {}

func NewType_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_Context {
	var p = new(Type_Context)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_type_

	return p
}

func (s *Type_Context) GetParser() antlr.Parser { return s.parser }

func (s *Type_Context) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *Type_Context) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Type_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Type_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterType_(s)
	}
}

func (s *Type_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitType_(s)
	}
}

func (p *CqlParser) Type_() (localctx IType_Context) {
	this := p
	_ = this

	localctx = NewType_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 328, CqlParserRULE_type_)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2095)
		p.Match(CqlParserOBJECT_NAME)
	}

	return localctx
}

// IAggregateContext is an interface to support dynamic dispatch.
type IAggregateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAggregateContext differentiates from other interfaces.
	IsAggregateContext()
}

type AggregateContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAggregateContext() *AggregateContext {
	var p = new(AggregateContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_aggregate
	return p
}

func (*AggregateContext) IsAggregateContext() {}

func NewAggregateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AggregateContext {
	var p = new(AggregateContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_aggregate

	return p
}

func (s *AggregateContext) GetParser() antlr.Parser { return s.parser }

func (s *AggregateContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *AggregateContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *AggregateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *AggregateContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterAggregate(s)
	}
}

func (s *AggregateContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitAggregate(s)
	}
}

func (p *CqlParser) Aggregate() (localctx IAggregateContext) {
	this := p
	_ = this

	localctx = NewAggregateContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 330, CqlParserRULE_aggregate)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2097)
		p.Match(CqlParserOBJECT_NAME)
	}

	return localctx
}

// IFunction_Context is an interface to support dynamic dispatch.
type IFunction_Context interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunction_Context differentiates from other interfaces.
	IsFunction_Context()
}

type Function_Context struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunction_Context() *Function_Context {
	var p = new(Function_Context)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_function_
	return p
}

func (*Function_Context) IsFunction_Context() {}

func NewFunction_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_Context {
	var p = new(Function_Context)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_function_

	return p
}

func (s *Function_Context) GetParser() antlr.Parser { return s.parser }

func (s *Function_Context) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *Function_Context) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Function_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *Function_Context) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterFunction_(s)
	}
}

func (s *Function_Context) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitFunction_(s)
	}
}

func (p *CqlParser) Function_() (localctx IFunction_Context) {
	this := p
	_ = this

	localctx = NewFunction_Context(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 332, CqlParserRULE_function_)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2099)
		p.Match(CqlParserOBJECT_NAME)
	}

	return localctx
}

// ILanguageContext is an interface to support dynamic dispatch.
type ILanguageContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLanguageContext differentiates from other interfaces.
	IsLanguageContext()
}

type LanguageContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLanguageContext() *LanguageContext {
	var p = new(LanguageContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_language
	return p
}

func (*LanguageContext) IsLanguageContext() {}

func NewLanguageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LanguageContext {
	var p = new(LanguageContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_language

	return p
}

func (s *LanguageContext) GetParser() antlr.Parser { return s.parser }

func (s *LanguageContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *LanguageContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *LanguageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *LanguageContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterLanguage(s)
	}
}

func (s *LanguageContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitLanguage(s)
	}
}

func (p *CqlParser) Language() (localctx ILanguageContext) {
	this := p
	_ = this

	localctx = NewLanguageContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 334, CqlParserRULE_language)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2101)
		p.Match(CqlParserOBJECT_NAME)
	}

	return localctx
}

// IUserContext is an interface to support dynamic dispatch.
type IUserContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUserContext differentiates from other interfaces.
	IsUserContext()
}

type UserContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUserContext() *UserContext {
	var p = new(UserContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_user
	return p
}

func (*UserContext) IsUserContext() {}

func NewUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserContext {
	var p = new(UserContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_user

	return p
}

func (s *UserContext) GetParser() antlr.Parser { return s.parser }

func (s *UserContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *UserContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *UserContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterUser(s)
	}
}

func (s *UserContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitUser(s)
	}
}

func (p *CqlParser) User() (localctx IUserContext) {
	this := p
	_ = this

	localctx = NewUserContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 336, CqlParserRULE_user)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2103)
		p.Match(CqlParserOBJECT_NAME)
	}

	return localctx
}

// IPasswordContext is an interface to support dynamic dispatch.
type IPasswordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPasswordContext differentiates from other interfaces.
	IsPasswordContext()
}

type PasswordContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPasswordContext() *PasswordContext {
	var p = new(PasswordContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_password
	return p
}

func (*PasswordContext) IsPasswordContext() {}

func NewPasswordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PasswordContext {
	var p = new(PasswordContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_password

	return p
}

func (s *PasswordContext) GetParser() antlr.Parser { return s.parser }

func (s *PasswordContext) StringLiteral() IStringLiteralContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IStringLiteralContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IStringLiteralContext)
}

func (s *PasswordContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *PasswordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *PasswordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterPassword(s)
	}
}

func (s *PasswordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitPassword(s)
	}
}

func (p *CqlParser) Password() (localctx IPasswordContext) {
	this := p
	_ = this

	localctx = NewPasswordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 338, CqlParserRULE_password)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2105)
		p.StringLiteral()
	}

	return localctx
}

// IHashKeyContext is an interface to support dynamic dispatch.
type IHashKeyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsHashKeyContext differentiates from other interfaces.
	IsHashKeyContext()
}

type HashKeyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyHashKeyContext() *HashKeyContext {
	var p = new(HashKeyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_hashKey
	return p
}

func (*HashKeyContext) IsHashKeyContext() {}

func NewHashKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HashKeyContext {
	var p = new(HashKeyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_hashKey

	return p
}

func (s *HashKeyContext) GetParser() antlr.Parser { return s.parser }

func (s *HashKeyContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *HashKeyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *HashKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *HashKeyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterHashKey(s)
	}
}

func (s *HashKeyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitHashKey(s)
	}
}

func (p *CqlParser) HashKey() (localctx IHashKeyContext) {
	this := p
	_ = this

	localctx = NewHashKeyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 340, CqlParserRULE_hashKey)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2107)
		p.Match(CqlParserOBJECT_NAME)
	}

	return localctx
}

// IParamContext is an interface to support dynamic dispatch.
type IParamContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsParamContext differentiates from other interfaces.
	IsParamContext()
}

type ParamContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyParamContext() *ParamContext {
	var p = new(ParamContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_param
	return p
}

func (*ParamContext) IsParamContext() {}

func NewParamContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParamContext {
	var p = new(ParamContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_param

	return p
}

func (s *ParamContext) GetParser() antlr.Parser { return s.parser }

func (s *ParamContext) ParamName() IParamNameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IParamNameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IParamNameContext)
}

func (s *ParamContext) DataType() IDataTypeContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDataTypeContext)
}

func (s *ParamContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ParamContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ParamContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterParam(s)
	}
}

func (s *ParamContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitParam(s)
	}
}

func (p *CqlParser) Param() (localctx IParamContext) {
	this := p
	_ = this

	localctx = NewParamContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 342, CqlParserRULE_param)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2109)
		p.ParamName()
	}
	{
		p.SetState(2110)
		p.DataType()
	}

	return localctx
}

// IParamNameContext is an interface to support dynamic dispatch.
type IParamNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsParamNameContext differentiates from other interfaces.
	IsParamNameContext()
}

type ParamNameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyParamNameContext() *ParamNameContext {
	var p = new(ParamNameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_paramName
	return p
}

func (*ParamNameContext) IsParamNameContext() {}

func NewParamNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParamNameContext {
	var p = new(ParamNameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_paramName

	return p
}

func (s *ParamNameContext) GetParser() antlr.Parser { return s.parser }

func (s *ParamNameContext) OBJECT_NAME() antlr.TerminalNode {
	return s.GetToken(CqlParserOBJECT_NAME, 0)
}

func (s *ParamNameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *ParamNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *ParamNameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterParamName(s)
	}
}

func (s *ParamNameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitParamName(s)
	}
}

func (p *CqlParser) ParamName() (localctx IParamNameContext) {
	this := p
	_ = this

	localctx = NewParamNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 344, CqlParserRULE_paramName)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2112)
		p.Match(CqlParserOBJECT_NAME)
	}

	return localctx
}

// IKwAddContext is an interface to support dynamic dispatch.
type IKwAddContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwAddContext differentiates from other interfaces.
	IsKwAddContext()
}

type KwAddContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwAddContext() *KwAddContext {
	var p = new(KwAddContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwAdd
	return p
}

func (*KwAddContext) IsKwAddContext() {}

func NewKwAddContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAddContext {
	var p = new(KwAddContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwAdd

	return p
}

func (s *KwAddContext) GetParser() antlr.Parser { return s.parser }

func (s *KwAddContext) K_ADD() antlr.TerminalNode {
	return s.GetToken(CqlParserK_ADD, 0)
}

func (s *KwAddContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwAddContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwAddContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwAdd(s)
	}
}

func (s *KwAddContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwAdd(s)
	}
}

func (p *CqlParser) KwAdd() (localctx IKwAddContext) {
	this := p
	_ = this

	localctx = NewKwAddContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 346, CqlParserRULE_kwAdd)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2114)
		p.Match(CqlParserK_ADD)
	}

	return localctx
}

// IKwAggregateContext is an interface to support dynamic dispatch.
type IKwAggregateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwAggregateContext differentiates from other interfaces.
	IsKwAggregateContext()
}

type KwAggregateContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwAggregateContext() *KwAggregateContext {
	var p = new(KwAggregateContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwAggregate
	return p
}

func (*KwAggregateContext) IsKwAggregateContext() {}

func NewKwAggregateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAggregateContext {
	var p = new(KwAggregateContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwAggregate

	return p
}

func (s *KwAggregateContext) GetParser() antlr.Parser { return s.parser }

func (s *KwAggregateContext) K_AGGREGATE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_AGGREGATE, 0)
}

func (s *KwAggregateContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwAggregateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwAggregateContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwAggregate(s)
	}
}

func (s *KwAggregateContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwAggregate(s)
	}
}

func (p *CqlParser) KwAggregate() (localctx IKwAggregateContext) {
	this := p
	_ = this

	localctx = NewKwAggregateContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 348, CqlParserRULE_kwAggregate)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2116)
		p.Match(CqlParserK_AGGREGATE)
	}

	return localctx
}

// IKwAllContext is an interface to support dynamic dispatch.
type IKwAllContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwAllContext differentiates from other interfaces.
	IsKwAllContext()
}

type KwAllContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwAllContext() *KwAllContext {
	var p = new(KwAllContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwAll
	return p
}

func (*KwAllContext) IsKwAllContext() {}

func NewKwAllContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAllContext {
	var p = new(KwAllContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwAll

	return p
}

func (s *KwAllContext) GetParser() antlr.Parser { return s.parser }

func (s *KwAllContext) K_ALL() antlr.TerminalNode {
	return s.GetToken(CqlParserK_ALL, 0)
}

func (s *KwAllContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwAllContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwAllContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwAll(s)
	}
}

func (s *KwAllContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwAll(s)
	}
}

func (p *CqlParser) KwAll() (localctx IKwAllContext) {
	this := p
	_ = this

	localctx = NewKwAllContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 350, CqlParserRULE_kwAll)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2118)
		p.Match(CqlParserK_ALL)
	}

	return localctx
}

// IKwAllPermissionsContext is an interface to support dynamic dispatch.
type IKwAllPermissionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwAllPermissionsContext differentiates from other interfaces.
	IsKwAllPermissionsContext()
}

type KwAllPermissionsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwAllPermissionsContext() *KwAllPermissionsContext {
	var p = new(KwAllPermissionsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwAllPermissions
	return p
}

func (*KwAllPermissionsContext) IsKwAllPermissionsContext() {}

func NewKwAllPermissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAllPermissionsContext {
	var p = new(KwAllPermissionsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwAllPermissions

	return p
}

func (s *KwAllPermissionsContext) GetParser() antlr.Parser { return s.parser }

func (s *KwAllPermissionsContext) K_ALL() antlr.TerminalNode {
	return s.GetToken(CqlParserK_ALL, 0)
}

func (s *KwAllPermissionsContext) K_PERMISSIONS() antlr.TerminalNode {
	return s.GetToken(CqlParserK_PERMISSIONS, 0)
}

func (s *KwAllPermissionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwAllPermissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwAllPermissionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwAllPermissions(s)
	}
}

func (s *KwAllPermissionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwAllPermissions(s)
	}
}

func (p *CqlParser) KwAllPermissions() (localctx IKwAllPermissionsContext) {
	this := p
	_ = this

	localctx = NewKwAllPermissionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 352, CqlParserRULE_kwAllPermissions)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2120)
		p.Match(CqlParserK_ALL)
	}
	{
		p.SetState(2121)
		p.Match(CqlParserK_PERMISSIONS)
	}

	return localctx
}

// IKwAllowContext is an interface to support dynamic dispatch.
type IKwAllowContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwAllowContext differentiates from other interfaces.
	IsKwAllowContext()
}

type KwAllowContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwAllowContext() *KwAllowContext {
	var p = new(KwAllowContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwAllow
	return p
}

func (*KwAllowContext) IsKwAllowContext() {}

func NewKwAllowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAllowContext {
	var p = new(KwAllowContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwAllow

	return p
}

func (s *KwAllowContext) GetParser() antlr.Parser { return s.parser }

func (s *KwAllowContext) K_ALLOW() antlr.TerminalNode {
	return s.GetToken(CqlParserK_ALLOW, 0)
}

func (s *KwAllowContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwAllowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwAllowContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwAllow(s)
	}
}

func (s *KwAllowContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwAllow(s)
	}
}

func (p *CqlParser) KwAllow() (localctx IKwAllowContext) {
	this := p
	_ = this

	localctx = NewKwAllowContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 354, CqlParserRULE_kwAllow)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2123)
		p.Match(CqlParserK_ALLOW)
	}

	return localctx
}

// IKwAlterContext is an interface to support dynamic dispatch.
type IKwAlterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwAlterContext differentiates from other interfaces.
	IsKwAlterContext()
}

type KwAlterContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwAlterContext() *KwAlterContext {
	var p = new(KwAlterContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwAlter
	return p
}

func (*KwAlterContext) IsKwAlterContext() {}

func NewKwAlterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAlterContext {
	var p = new(KwAlterContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwAlter

	return p
}

func (s *KwAlterContext) GetParser() antlr.Parser { return s.parser }

func (s *KwAlterContext) K_ALTER() antlr.TerminalNode {
	return s.GetToken(CqlParserK_ALTER, 0)
}

func (s *KwAlterContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwAlterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwAlterContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwAlter(s)
	}
}

func (s *KwAlterContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwAlter(s)
	}
}

func (p *CqlParser) KwAlter() (localctx IKwAlterContext) {
	this := p
	_ = this

	localctx = NewKwAlterContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 356, CqlParserRULE_kwAlter)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2125)
		p.Match(CqlParserK_ALTER)
	}

	return localctx
}

// IKwAndContext is an interface to support dynamic dispatch.
type IKwAndContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwAndContext differentiates from other interfaces.
	IsKwAndContext()
}

type KwAndContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwAndContext() *KwAndContext {
	var p = new(KwAndContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwAnd
	return p
}

func (*KwAndContext) IsKwAndContext() {}

func NewKwAndContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAndContext {
	var p = new(KwAndContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwAnd

	return p
}

func (s *KwAndContext) GetParser() antlr.Parser { return s.parser }

func (s *KwAndContext) K_AND() antlr.TerminalNode {
	return s.GetToken(CqlParserK_AND, 0)
}

func (s *KwAndContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwAndContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwAndContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwAnd(s)
	}
}

func (s *KwAndContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwAnd(s)
	}
}

func (p *CqlParser) KwAnd() (localctx IKwAndContext) {
	this := p
	_ = this

	localctx = NewKwAndContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 358, CqlParserRULE_kwAnd)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2127)
		p.Match(CqlParserK_AND)
	}

	return localctx
}

// IKwApplyContext is an interface to support dynamic dispatch.
type IKwApplyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwApplyContext differentiates from other interfaces.
	IsKwApplyContext()
}

type KwApplyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwApplyContext() *KwApplyContext {
	var p = new(KwApplyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwApply
	return p
}

func (*KwApplyContext) IsKwApplyContext() {}

func NewKwApplyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwApplyContext {
	var p = new(KwApplyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwApply

	return p
}

func (s *KwApplyContext) GetParser() antlr.Parser { return s.parser }

func (s *KwApplyContext) K_APPLY() antlr.TerminalNode {
	return s.GetToken(CqlParserK_APPLY, 0)
}

func (s *KwApplyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwApplyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwApplyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwApply(s)
	}
}

func (s *KwApplyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwApply(s)
	}
}

func (p *CqlParser) KwApply() (localctx IKwApplyContext) {
	this := p
	_ = this

	localctx = NewKwApplyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 360, CqlParserRULE_kwApply)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2129)
		p.Match(CqlParserK_APPLY)
	}

	return localctx
}

// IKwAsContext is an interface to support dynamic dispatch.
type IKwAsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwAsContext differentiates from other interfaces.
	IsKwAsContext()
}

type KwAsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwAsContext() *KwAsContext {
	var p = new(KwAsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwAs
	return p
}

func (*KwAsContext) IsKwAsContext() {}

func NewKwAsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAsContext {
	var p = new(KwAsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwAs

	return p
}

func (s *KwAsContext) GetParser() antlr.Parser { return s.parser }

func (s *KwAsContext) K_AS() antlr.TerminalNode {
	return s.GetToken(CqlParserK_AS, 0)
}

func (s *KwAsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwAsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwAsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwAs(s)
	}
}

func (s *KwAsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwAs(s)
	}
}

func (p *CqlParser) KwAs() (localctx IKwAsContext) {
	this := p
	_ = this

	localctx = NewKwAsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 362, CqlParserRULE_kwAs)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2131)
		p.Match(CqlParserK_AS)
	}

	return localctx
}

// IKwAscContext is an interface to support dynamic dispatch.
type IKwAscContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwAscContext differentiates from other interfaces.
	IsKwAscContext()
}

type KwAscContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwAscContext() *KwAscContext {
	var p = new(KwAscContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwAsc
	return p
}

func (*KwAscContext) IsKwAscContext() {}

func NewKwAscContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAscContext {
	var p = new(KwAscContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwAsc

	return p
}

func (s *KwAscContext) GetParser() antlr.Parser { return s.parser }

func (s *KwAscContext) K_ASC() antlr.TerminalNode {
	return s.GetToken(CqlParserK_ASC, 0)
}

func (s *KwAscContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwAscContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwAscContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwAsc(s)
	}
}

func (s *KwAscContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwAsc(s)
	}
}

func (p *CqlParser) KwAsc() (localctx IKwAscContext) {
	this := p
	_ = this

	localctx = NewKwAscContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 364, CqlParserRULE_kwAsc)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2133)
		p.Match(CqlParserK_ASC)
	}

	return localctx
}

// IKwAuthorizeContext is an interface to support dynamic dispatch.
type IKwAuthorizeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwAuthorizeContext differentiates from other interfaces.
	IsKwAuthorizeContext()
}

type KwAuthorizeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwAuthorizeContext() *KwAuthorizeContext {
	var p = new(KwAuthorizeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwAuthorize
	return p
}

func (*KwAuthorizeContext) IsKwAuthorizeContext() {}

func NewKwAuthorizeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAuthorizeContext {
	var p = new(KwAuthorizeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwAuthorize

	return p
}

func (s *KwAuthorizeContext) GetParser() antlr.Parser { return s.parser }

func (s *KwAuthorizeContext) K_AUTHORIZE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_AUTHORIZE, 0)
}

func (s *KwAuthorizeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwAuthorizeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwAuthorizeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwAuthorize(s)
	}
}

func (s *KwAuthorizeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwAuthorize(s)
	}
}

func (p *CqlParser) KwAuthorize() (localctx IKwAuthorizeContext) {
	this := p
	_ = this

	localctx = NewKwAuthorizeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 366, CqlParserRULE_kwAuthorize)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2135)
		p.Match(CqlParserK_AUTHORIZE)
	}

	return localctx
}

// IKwBatchContext is an interface to support dynamic dispatch.
type IKwBatchContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwBatchContext differentiates from other interfaces.
	IsKwBatchContext()
}

type KwBatchContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwBatchContext() *KwBatchContext {
	var p = new(KwBatchContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwBatch
	return p
}

func (*KwBatchContext) IsKwBatchContext() {}

func NewKwBatchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwBatchContext {
	var p = new(KwBatchContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwBatch

	return p
}

func (s *KwBatchContext) GetParser() antlr.Parser { return s.parser }

func (s *KwBatchContext) K_BATCH() antlr.TerminalNode {
	return s.GetToken(CqlParserK_BATCH, 0)
}

func (s *KwBatchContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwBatchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwBatchContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwBatch(s)
	}
}

func (s *KwBatchContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwBatch(s)
	}
}

func (p *CqlParser) KwBatch() (localctx IKwBatchContext) {
	this := p
	_ = this

	localctx = NewKwBatchContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 368, CqlParserRULE_kwBatch)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2137)
		p.Match(CqlParserK_BATCH)
	}

	return localctx
}

// IKwBeginContext is an interface to support dynamic dispatch.
type IKwBeginContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwBeginContext differentiates from other interfaces.
	IsKwBeginContext()
}

type KwBeginContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwBeginContext() *KwBeginContext {
	var p = new(KwBeginContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwBegin
	return p
}

func (*KwBeginContext) IsKwBeginContext() {}

func NewKwBeginContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwBeginContext {
	var p = new(KwBeginContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwBegin

	return p
}

func (s *KwBeginContext) GetParser() antlr.Parser { return s.parser }

func (s *KwBeginContext) K_BEGIN() antlr.TerminalNode {
	return s.GetToken(CqlParserK_BEGIN, 0)
}

func (s *KwBeginContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwBeginContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwBeginContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwBegin(s)
	}
}

func (s *KwBeginContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwBegin(s)
	}
}

func (p *CqlParser) KwBegin() (localctx IKwBeginContext) {
	this := p
	_ = this

	localctx = NewKwBeginContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 370, CqlParserRULE_kwBegin)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2139)
		p.Match(CqlParserK_BEGIN)
	}

	return localctx
}

// IKwByContext is an interface to support dynamic dispatch.
type IKwByContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwByContext differentiates from other interfaces.
	IsKwByContext()
}

type KwByContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwByContext() *KwByContext {
	var p = new(KwByContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwBy
	return p
}

func (*KwByContext) IsKwByContext() {}

func NewKwByContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwByContext {
	var p = new(KwByContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwBy

	return p
}

func (s *KwByContext) GetParser() antlr.Parser { return s.parser }

func (s *KwByContext) K_BY() antlr.TerminalNode {
	return s.GetToken(CqlParserK_BY, 0)
}

func (s *KwByContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwByContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwByContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwBy(s)
	}
}

func (s *KwByContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwBy(s)
	}
}

func (p *CqlParser) KwBy() (localctx IKwByContext) {
	this := p
	_ = this

	localctx = NewKwByContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 372, CqlParserRULE_kwBy)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2141)
		p.Match(CqlParserK_BY)
	}

	return localctx
}

// IKwCalledContext is an interface to support dynamic dispatch.
type IKwCalledContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwCalledContext differentiates from other interfaces.
	IsKwCalledContext()
}

type KwCalledContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwCalledContext() *KwCalledContext {
	var p = new(KwCalledContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwCalled
	return p
}

func (*KwCalledContext) IsKwCalledContext() {}

func NewKwCalledContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwCalledContext {
	var p = new(KwCalledContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwCalled

	return p
}

func (s *KwCalledContext) GetParser() antlr.Parser { return s.parser }

func (s *KwCalledContext) K_CALLED() antlr.TerminalNode {
	return s.GetToken(CqlParserK_CALLED, 0)
}

func (s *KwCalledContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwCalledContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwCalledContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwCalled(s)
	}
}

func (s *KwCalledContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwCalled(s)
	}
}

func (p *CqlParser) KwCalled() (localctx IKwCalledContext) {
	this := p
	_ = this

	localctx = NewKwCalledContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 374, CqlParserRULE_kwCalled)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2143)
		p.Match(CqlParserK_CALLED)
	}

	return localctx
}

// IKwClusteringContext is an interface to support dynamic dispatch.
type IKwClusteringContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwClusteringContext differentiates from other interfaces.
	IsKwClusteringContext()
}

type KwClusteringContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwClusteringContext() *KwClusteringContext {
	var p = new(KwClusteringContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwClustering
	return p
}

func (*KwClusteringContext) IsKwClusteringContext() {}

func NewKwClusteringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwClusteringContext {
	var p = new(KwClusteringContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwClustering

	return p
}

func (s *KwClusteringContext) GetParser() antlr.Parser { return s.parser }

func (s *KwClusteringContext) K_CLUSTERING() antlr.TerminalNode {
	return s.GetToken(CqlParserK_CLUSTERING, 0)
}

func (s *KwClusteringContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwClusteringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwClusteringContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwClustering(s)
	}
}

func (s *KwClusteringContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwClustering(s)
	}
}

func (p *CqlParser) KwClustering() (localctx IKwClusteringContext) {
	this := p
	_ = this

	localctx = NewKwClusteringContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 376, CqlParserRULE_kwClustering)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2145)
		p.Match(CqlParserK_CLUSTERING)
	}

	return localctx
}

// IKwCompactContext is an interface to support dynamic dispatch.
type IKwCompactContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwCompactContext differentiates from other interfaces.
	IsKwCompactContext()
}

type KwCompactContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwCompactContext() *KwCompactContext {
	var p = new(KwCompactContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwCompact
	return p
}

func (*KwCompactContext) IsKwCompactContext() {}

func NewKwCompactContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwCompactContext {
	var p = new(KwCompactContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwCompact

	return p
}

func (s *KwCompactContext) GetParser() antlr.Parser { return s.parser }

func (s *KwCompactContext) K_COMPACT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_COMPACT, 0)
}

func (s *KwCompactContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwCompactContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwCompactContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwCompact(s)
	}
}

func (s *KwCompactContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwCompact(s)
	}
}

func (p *CqlParser) KwCompact() (localctx IKwCompactContext) {
	this := p
	_ = this

	localctx = NewKwCompactContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 378, CqlParserRULE_kwCompact)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2147)
		p.Match(CqlParserK_COMPACT)
	}

	return localctx
}

// IKwContainsContext is an interface to support dynamic dispatch.
type IKwContainsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwContainsContext differentiates from other interfaces.
	IsKwContainsContext()
}

type KwContainsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwContainsContext() *KwContainsContext {
	var p = new(KwContainsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwContains
	return p
}

func (*KwContainsContext) IsKwContainsContext() {}

func NewKwContainsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwContainsContext {
	var p = new(KwContainsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwContains

	return p
}

func (s *KwContainsContext) GetParser() antlr.Parser { return s.parser }

func (s *KwContainsContext) K_CONTAINS() antlr.TerminalNode {
	return s.GetToken(CqlParserK_CONTAINS, 0)
}

func (s *KwContainsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwContainsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwContainsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwContains(s)
	}
}

func (s *KwContainsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwContains(s)
	}
}

func (p *CqlParser) KwContains() (localctx IKwContainsContext) {
	this := p
	_ = this

	localctx = NewKwContainsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 380, CqlParserRULE_kwContains)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2149)
		p.Match(CqlParserK_CONTAINS)
	}

	return localctx
}

// IKwCreateContext is an interface to support dynamic dispatch.
type IKwCreateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwCreateContext differentiates from other interfaces.
	IsKwCreateContext()
}

type KwCreateContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwCreateContext() *KwCreateContext {
	var p = new(KwCreateContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwCreate
	return p
}

func (*KwCreateContext) IsKwCreateContext() {}

func NewKwCreateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwCreateContext {
	var p = new(KwCreateContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwCreate

	return p
}

func (s *KwCreateContext) GetParser() antlr.Parser { return s.parser }

func (s *KwCreateContext) K_CREATE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_CREATE, 0)
}

func (s *KwCreateContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwCreateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwCreateContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwCreate(s)
	}
}

func (s *KwCreateContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwCreate(s)
	}
}

func (p *CqlParser) KwCreate() (localctx IKwCreateContext) {
	this := p
	_ = this

	localctx = NewKwCreateContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 382, CqlParserRULE_kwCreate)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2151)
		p.Match(CqlParserK_CREATE)
	}

	return localctx
}

// IKwDeleteContext is an interface to support dynamic dispatch.
type IKwDeleteContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwDeleteContext differentiates from other interfaces.
	IsKwDeleteContext()
}

type KwDeleteContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwDeleteContext() *KwDeleteContext {
	var p = new(KwDeleteContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwDelete
	return p
}

func (*KwDeleteContext) IsKwDeleteContext() {}

func NewKwDeleteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwDeleteContext {
	var p = new(KwDeleteContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwDelete

	return p
}

func (s *KwDeleteContext) GetParser() antlr.Parser { return s.parser }

func (s *KwDeleteContext) K_DELETE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_DELETE, 0)
}

func (s *KwDeleteContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwDeleteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwDeleteContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwDelete(s)
	}
}

func (s *KwDeleteContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwDelete(s)
	}
}

func (p *CqlParser) KwDelete() (localctx IKwDeleteContext) {
	this := p
	_ = this

	localctx = NewKwDeleteContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 384, CqlParserRULE_kwDelete)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2153)
		p.Match(CqlParserK_DELETE)
	}

	return localctx
}

// IKwDescContext is an interface to support dynamic dispatch.
type IKwDescContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwDescContext differentiates from other interfaces.
	IsKwDescContext()
}

type KwDescContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwDescContext() *KwDescContext {
	var p = new(KwDescContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwDesc
	return p
}

func (*KwDescContext) IsKwDescContext() {}

func NewKwDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwDescContext {
	var p = new(KwDescContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwDesc

	return p
}

func (s *KwDescContext) GetParser() antlr.Parser { return s.parser }

func (s *KwDescContext) K_DESC() antlr.TerminalNode {
	return s.GetToken(CqlParserK_DESC, 0)
}

func (s *KwDescContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwDescContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwDescContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwDesc(s)
	}
}

func (s *KwDescContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwDesc(s)
	}
}

func (p *CqlParser) KwDesc() (localctx IKwDescContext) {
	this := p
	_ = this

	localctx = NewKwDescContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 386, CqlParserRULE_kwDesc)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2155)
		p.Match(CqlParserK_DESC)
	}

	return localctx
}

// IKwDescibeContext is an interface to support dynamic dispatch.
type IKwDescibeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwDescibeContext differentiates from other interfaces.
	IsKwDescibeContext()
}

type KwDescibeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwDescibeContext() *KwDescibeContext {
	var p = new(KwDescibeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwDescibe
	return p
}

func (*KwDescibeContext) IsKwDescibeContext() {}

func NewKwDescibeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwDescibeContext {
	var p = new(KwDescibeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwDescibe

	return p
}

func (s *KwDescibeContext) GetParser() antlr.Parser { return s.parser }

func (s *KwDescibeContext) K_DESCRIBE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_DESCRIBE, 0)
}

func (s *KwDescibeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwDescibeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwDescibeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwDescibe(s)
	}
}

func (s *KwDescibeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwDescibe(s)
	}
}

func (p *CqlParser) KwDescibe() (localctx IKwDescibeContext) {
	this := p
	_ = this

	localctx = NewKwDescibeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 388, CqlParserRULE_kwDescibe)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2157)
		p.Match(CqlParserK_DESCRIBE)
	}

	return localctx
}

// IKwDistinctContext is an interface to support dynamic dispatch.
type IKwDistinctContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwDistinctContext differentiates from other interfaces.
	IsKwDistinctContext()
}

type KwDistinctContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwDistinctContext() *KwDistinctContext {
	var p = new(KwDistinctContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwDistinct
	return p
}

func (*KwDistinctContext) IsKwDistinctContext() {}

func NewKwDistinctContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwDistinctContext {
	var p = new(KwDistinctContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwDistinct

	return p
}

func (s *KwDistinctContext) GetParser() antlr.Parser { return s.parser }

func (s *KwDistinctContext) K_DISTINCT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_DISTINCT, 0)
}

func (s *KwDistinctContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwDistinctContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwDistinctContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwDistinct(s)
	}
}

func (s *KwDistinctContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwDistinct(s)
	}
}

func (p *CqlParser) KwDistinct() (localctx IKwDistinctContext) {
	this := p
	_ = this

	localctx = NewKwDistinctContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 390, CqlParserRULE_kwDistinct)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2159)
		p.Match(CqlParserK_DISTINCT)
	}

	return localctx
}

// IKwDropContext is an interface to support dynamic dispatch.
type IKwDropContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwDropContext differentiates from other interfaces.
	IsKwDropContext()
}

type KwDropContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwDropContext() *KwDropContext {
	var p = new(KwDropContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwDrop
	return p
}

func (*KwDropContext) IsKwDropContext() {}

func NewKwDropContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwDropContext {
	var p = new(KwDropContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwDrop

	return p
}

func (s *KwDropContext) GetParser() antlr.Parser { return s.parser }

func (s *KwDropContext) K_DROP() antlr.TerminalNode {
	return s.GetToken(CqlParserK_DROP, 0)
}

func (s *KwDropContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwDropContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwDropContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwDrop(s)
	}
}

func (s *KwDropContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwDrop(s)
	}
}

func (p *CqlParser) KwDrop() (localctx IKwDropContext) {
	this := p
	_ = this

	localctx = NewKwDropContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 392, CqlParserRULE_kwDrop)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2161)
		p.Match(CqlParserK_DROP)
	}

	return localctx
}

// IKwDurableWritesContext is an interface to support dynamic dispatch.
type IKwDurableWritesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwDurableWritesContext differentiates from other interfaces.
	IsKwDurableWritesContext()
}

type KwDurableWritesContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwDurableWritesContext() *KwDurableWritesContext {
	var p = new(KwDurableWritesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwDurableWrites
	return p
}

func (*KwDurableWritesContext) IsKwDurableWritesContext() {}

func NewKwDurableWritesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwDurableWritesContext {
	var p = new(KwDurableWritesContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwDurableWrites

	return p
}

func (s *KwDurableWritesContext) GetParser() antlr.Parser { return s.parser }

func (s *KwDurableWritesContext) K_DURABLE_WRITES() antlr.TerminalNode {
	return s.GetToken(CqlParserK_DURABLE_WRITES, 0)
}

func (s *KwDurableWritesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwDurableWritesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwDurableWritesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwDurableWrites(s)
	}
}

func (s *KwDurableWritesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwDurableWrites(s)
	}
}

func (p *CqlParser) KwDurableWrites() (localctx IKwDurableWritesContext) {
	this := p
	_ = this

	localctx = NewKwDurableWritesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 394, CqlParserRULE_kwDurableWrites)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2163)
		p.Match(CqlParserK_DURABLE_WRITES)
	}

	return localctx
}

// IKwEntriesContext is an interface to support dynamic dispatch.
type IKwEntriesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwEntriesContext differentiates from other interfaces.
	IsKwEntriesContext()
}

type KwEntriesContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwEntriesContext() *KwEntriesContext {
	var p = new(KwEntriesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwEntries
	return p
}

func (*KwEntriesContext) IsKwEntriesContext() {}

func NewKwEntriesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwEntriesContext {
	var p = new(KwEntriesContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwEntries

	return p
}

func (s *KwEntriesContext) GetParser() antlr.Parser { return s.parser }

func (s *KwEntriesContext) K_ENTRIES() antlr.TerminalNode {
	return s.GetToken(CqlParserK_ENTRIES, 0)
}

func (s *KwEntriesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwEntriesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwEntriesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwEntries(s)
	}
}

func (s *KwEntriesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwEntries(s)
	}
}

func (p *CqlParser) KwEntries() (localctx IKwEntriesContext) {
	this := p
	_ = this

	localctx = NewKwEntriesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 396, CqlParserRULE_kwEntries)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2165)
		p.Match(CqlParserK_ENTRIES)
	}

	return localctx
}

// IKwExecuteContext is an interface to support dynamic dispatch.
type IKwExecuteContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwExecuteContext differentiates from other interfaces.
	IsKwExecuteContext()
}

type KwExecuteContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwExecuteContext() *KwExecuteContext {
	var p = new(KwExecuteContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwExecute
	return p
}

func (*KwExecuteContext) IsKwExecuteContext() {}

func NewKwExecuteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwExecuteContext {
	var p = new(KwExecuteContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwExecute

	return p
}

func (s *KwExecuteContext) GetParser() antlr.Parser { return s.parser }

func (s *KwExecuteContext) K_EXECUTE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_EXECUTE, 0)
}

func (s *KwExecuteContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwExecuteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwExecuteContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwExecute(s)
	}
}

func (s *KwExecuteContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwExecute(s)
	}
}

func (p *CqlParser) KwExecute() (localctx IKwExecuteContext) {
	this := p
	_ = this

	localctx = NewKwExecuteContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 398, CqlParserRULE_kwExecute)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2167)
		p.Match(CqlParserK_EXECUTE)
	}

	return localctx
}

// IKwExistsContext is an interface to support dynamic dispatch.
type IKwExistsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwExistsContext differentiates from other interfaces.
	IsKwExistsContext()
}

type KwExistsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwExistsContext() *KwExistsContext {
	var p = new(KwExistsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwExists
	return p
}

func (*KwExistsContext) IsKwExistsContext() {}

func NewKwExistsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwExistsContext {
	var p = new(KwExistsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwExists

	return p
}

func (s *KwExistsContext) GetParser() antlr.Parser { return s.parser }

func (s *KwExistsContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(CqlParserK_EXISTS, 0)
}

func (s *KwExistsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwExistsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwExistsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwExists(s)
	}
}

func (s *KwExistsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwExists(s)
	}
}

func (p *CqlParser) KwExists() (localctx IKwExistsContext) {
	this := p
	_ = this

	localctx = NewKwExistsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 400, CqlParserRULE_kwExists)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2169)
		p.Match(CqlParserK_EXISTS)
	}

	return localctx
}

// IKwFilteringContext is an interface to support dynamic dispatch.
type IKwFilteringContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwFilteringContext differentiates from other interfaces.
	IsKwFilteringContext()
}

type KwFilteringContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwFilteringContext() *KwFilteringContext {
	var p = new(KwFilteringContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwFiltering
	return p
}

func (*KwFilteringContext) IsKwFilteringContext() {}

func NewKwFilteringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwFilteringContext {
	var p = new(KwFilteringContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwFiltering

	return p
}

func (s *KwFilteringContext) GetParser() antlr.Parser { return s.parser }

func (s *KwFilteringContext) K_FILTERING() antlr.TerminalNode {
	return s.GetToken(CqlParserK_FILTERING, 0)
}

func (s *KwFilteringContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwFilteringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwFilteringContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwFiltering(s)
	}
}

func (s *KwFilteringContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwFiltering(s)
	}
}

func (p *CqlParser) KwFiltering() (localctx IKwFilteringContext) {
	this := p
	_ = this

	localctx = NewKwFilteringContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 402, CqlParserRULE_kwFiltering)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2171)
		p.Match(CqlParserK_FILTERING)
	}

	return localctx
}

// IKwFinalfuncContext is an interface to support dynamic dispatch.
type IKwFinalfuncContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwFinalfuncContext differentiates from other interfaces.
	IsKwFinalfuncContext()
}

type KwFinalfuncContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwFinalfuncContext() *KwFinalfuncContext {
	var p = new(KwFinalfuncContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwFinalfunc
	return p
}

func (*KwFinalfuncContext) IsKwFinalfuncContext() {}

func NewKwFinalfuncContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwFinalfuncContext {
	var p = new(KwFinalfuncContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwFinalfunc

	return p
}

func (s *KwFinalfuncContext) GetParser() antlr.Parser { return s.parser }

func (s *KwFinalfuncContext) K_FINALFUNC() antlr.TerminalNode {
	return s.GetToken(CqlParserK_FINALFUNC, 0)
}

func (s *KwFinalfuncContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwFinalfuncContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwFinalfuncContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwFinalfunc(s)
	}
}

func (s *KwFinalfuncContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwFinalfunc(s)
	}
}

func (p *CqlParser) KwFinalfunc() (localctx IKwFinalfuncContext) {
	this := p
	_ = this

	localctx = NewKwFinalfuncContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 404, CqlParserRULE_kwFinalfunc)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2173)
		p.Match(CqlParserK_FINALFUNC)
	}

	return localctx
}

// IKwFromContext is an interface to support dynamic dispatch.
type IKwFromContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwFromContext differentiates from other interfaces.
	IsKwFromContext()
}

type KwFromContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwFromContext() *KwFromContext {
	var p = new(KwFromContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwFrom
	return p
}

func (*KwFromContext) IsKwFromContext() {}

func NewKwFromContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwFromContext {
	var p = new(KwFromContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwFrom

	return p
}

func (s *KwFromContext) GetParser() antlr.Parser { return s.parser }

func (s *KwFromContext) K_FROM() antlr.TerminalNode {
	return s.GetToken(CqlParserK_FROM, 0)
}

func (s *KwFromContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwFromContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwFromContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwFrom(s)
	}
}

func (s *KwFromContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwFrom(s)
	}
}

func (p *CqlParser) KwFrom() (localctx IKwFromContext) {
	this := p
	_ = this

	localctx = NewKwFromContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 406, CqlParserRULE_kwFrom)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2175)
		p.Match(CqlParserK_FROM)
	}

	return localctx
}

// IKwFullContext is an interface to support dynamic dispatch.
type IKwFullContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwFullContext differentiates from other interfaces.
	IsKwFullContext()
}

type KwFullContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwFullContext() *KwFullContext {
	var p = new(KwFullContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwFull
	return p
}

func (*KwFullContext) IsKwFullContext() {}

func NewKwFullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwFullContext {
	var p = new(KwFullContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwFull

	return p
}

func (s *KwFullContext) GetParser() antlr.Parser { return s.parser }

func (s *KwFullContext) K_FULL() antlr.TerminalNode {
	return s.GetToken(CqlParserK_FULL, 0)
}

func (s *KwFullContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwFullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwFullContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwFull(s)
	}
}

func (s *KwFullContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwFull(s)
	}
}

func (p *CqlParser) KwFull() (localctx IKwFullContext) {
	this := p
	_ = this

	localctx = NewKwFullContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 408, CqlParserRULE_kwFull)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2177)
		p.Match(CqlParserK_FULL)
	}

	return localctx
}

// IKwFunctionContext is an interface to support dynamic dispatch.
type IKwFunctionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwFunctionContext differentiates from other interfaces.
	IsKwFunctionContext()
}

type KwFunctionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwFunctionContext() *KwFunctionContext {
	var p = new(KwFunctionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwFunction
	return p
}

func (*KwFunctionContext) IsKwFunctionContext() {}

func NewKwFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwFunctionContext {
	var p = new(KwFunctionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwFunction

	return p
}

func (s *KwFunctionContext) GetParser() antlr.Parser { return s.parser }

func (s *KwFunctionContext) K_FUNCTION() antlr.TerminalNode {
	return s.GetToken(CqlParserK_FUNCTION, 0)
}

func (s *KwFunctionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwFunctionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwFunction(s)
	}
}

func (s *KwFunctionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwFunction(s)
	}
}

func (p *CqlParser) KwFunction() (localctx IKwFunctionContext) {
	this := p
	_ = this

	localctx = NewKwFunctionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 410, CqlParserRULE_kwFunction)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2179)
		p.Match(CqlParserK_FUNCTION)
	}

	return localctx
}

// IKwFunctionsContext is an interface to support dynamic dispatch.
type IKwFunctionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwFunctionsContext differentiates from other interfaces.
	IsKwFunctionsContext()
}

type KwFunctionsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwFunctionsContext() *KwFunctionsContext {
	var p = new(KwFunctionsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwFunctions
	return p
}

func (*KwFunctionsContext) IsKwFunctionsContext() {}

func NewKwFunctionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwFunctionsContext {
	var p = new(KwFunctionsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwFunctions

	return p
}

func (s *KwFunctionsContext) GetParser() antlr.Parser { return s.parser }

func (s *KwFunctionsContext) K_FUNCTIONS() antlr.TerminalNode {
	return s.GetToken(CqlParserK_FUNCTIONS, 0)
}

func (s *KwFunctionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwFunctionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwFunctionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwFunctions(s)
	}
}

func (s *KwFunctionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwFunctions(s)
	}
}

func (p *CqlParser) KwFunctions() (localctx IKwFunctionsContext) {
	this := p
	_ = this

	localctx = NewKwFunctionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 412, CqlParserRULE_kwFunctions)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2181)
		p.Match(CqlParserK_FUNCTIONS)
	}

	return localctx
}

// IKwGrantContext is an interface to support dynamic dispatch.
type IKwGrantContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwGrantContext differentiates from other interfaces.
	IsKwGrantContext()
}

type KwGrantContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwGrantContext() *KwGrantContext {
	var p = new(KwGrantContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwGrant
	return p
}

func (*KwGrantContext) IsKwGrantContext() {}

func NewKwGrantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwGrantContext {
	var p = new(KwGrantContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwGrant

	return p
}

func (s *KwGrantContext) GetParser() antlr.Parser { return s.parser }

func (s *KwGrantContext) K_GRANT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_GRANT, 0)
}

func (s *KwGrantContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwGrantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwGrantContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwGrant(s)
	}
}

func (s *KwGrantContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwGrant(s)
	}
}

func (p *CqlParser) KwGrant() (localctx IKwGrantContext) {
	this := p
	_ = this

	localctx = NewKwGrantContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 414, CqlParserRULE_kwGrant)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2183)
		p.Match(CqlParserK_GRANT)
	}

	return localctx
}

// IKwIfContext is an interface to support dynamic dispatch.
type IKwIfContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwIfContext differentiates from other interfaces.
	IsKwIfContext()
}

type KwIfContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwIfContext() *KwIfContext {
	var p = new(KwIfContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwIf
	return p
}

func (*KwIfContext) IsKwIfContext() {}

func NewKwIfContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwIfContext {
	var p = new(KwIfContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwIf

	return p
}

func (s *KwIfContext) GetParser() antlr.Parser { return s.parser }

func (s *KwIfContext) K_IF() antlr.TerminalNode {
	return s.GetToken(CqlParserK_IF, 0)
}

func (s *KwIfContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwIfContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwIfContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwIf(s)
	}
}

func (s *KwIfContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwIf(s)
	}
}

func (p *CqlParser) KwIf() (localctx IKwIfContext) {
	this := p
	_ = this

	localctx = NewKwIfContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 416, CqlParserRULE_kwIf)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2185)
		p.Match(CqlParserK_IF)
	}

	return localctx
}

// IKwInContext is an interface to support dynamic dispatch.
type IKwInContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwInContext differentiates from other interfaces.
	IsKwInContext()
}

type KwInContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwInContext() *KwInContext {
	var p = new(KwInContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwIn
	return p
}

func (*KwInContext) IsKwInContext() {}

func NewKwInContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwInContext {
	var p = new(KwInContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwIn

	return p
}

func (s *KwInContext) GetParser() antlr.Parser { return s.parser }

func (s *KwInContext) K_IN() antlr.TerminalNode {
	return s.GetToken(CqlParserK_IN, 0)
}

func (s *KwInContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwInContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwInContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwIn(s)
	}
}

func (s *KwInContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwIn(s)
	}
}

func (p *CqlParser) KwIn() (localctx IKwInContext) {
	this := p
	_ = this

	localctx = NewKwInContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 418, CqlParserRULE_kwIn)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2187)
		p.Match(CqlParserK_IN)
	}

	return localctx
}

// IKwIndexContext is an interface to support dynamic dispatch.
type IKwIndexContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwIndexContext differentiates from other interfaces.
	IsKwIndexContext()
}

type KwIndexContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwIndexContext() *KwIndexContext {
	var p = new(KwIndexContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwIndex
	return p
}

func (*KwIndexContext) IsKwIndexContext() {}

func NewKwIndexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwIndexContext {
	var p = new(KwIndexContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwIndex

	return p
}

func (s *KwIndexContext) GetParser() antlr.Parser { return s.parser }

func (s *KwIndexContext) K_INDEX() antlr.TerminalNode {
	return s.GetToken(CqlParserK_INDEX, 0)
}

func (s *KwIndexContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwIndexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwIndexContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwIndex(s)
	}
}

func (s *KwIndexContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwIndex(s)
	}
}

func (p *CqlParser) KwIndex() (localctx IKwIndexContext) {
	this := p
	_ = this

	localctx = NewKwIndexContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 420, CqlParserRULE_kwIndex)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2189)
		p.Match(CqlParserK_INDEX)
	}

	return localctx
}

// IKwInitcondContext is an interface to support dynamic dispatch.
type IKwInitcondContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwInitcondContext differentiates from other interfaces.
	IsKwInitcondContext()
}

type KwInitcondContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwInitcondContext() *KwInitcondContext {
	var p = new(KwInitcondContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwInitcond
	return p
}

func (*KwInitcondContext) IsKwInitcondContext() {}

func NewKwInitcondContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwInitcondContext {
	var p = new(KwInitcondContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwInitcond

	return p
}

func (s *KwInitcondContext) GetParser() antlr.Parser { return s.parser }

func (s *KwInitcondContext) K_INITCOND() antlr.TerminalNode {
	return s.GetToken(CqlParserK_INITCOND, 0)
}

func (s *KwInitcondContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwInitcondContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwInitcondContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwInitcond(s)
	}
}

func (s *KwInitcondContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwInitcond(s)
	}
}

func (p *CqlParser) KwInitcond() (localctx IKwInitcondContext) {
	this := p
	_ = this

	localctx = NewKwInitcondContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 422, CqlParserRULE_kwInitcond)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2191)
		p.Match(CqlParserK_INITCOND)
	}

	return localctx
}

// IKwInputContext is an interface to support dynamic dispatch.
type IKwInputContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwInputContext differentiates from other interfaces.
	IsKwInputContext()
}

type KwInputContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwInputContext() *KwInputContext {
	var p = new(KwInputContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwInput
	return p
}

func (*KwInputContext) IsKwInputContext() {}

func NewKwInputContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwInputContext {
	var p = new(KwInputContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwInput

	return p
}

func (s *KwInputContext) GetParser() antlr.Parser { return s.parser }

func (s *KwInputContext) K_INPUT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_INPUT, 0)
}

func (s *KwInputContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwInputContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwInputContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwInput(s)
	}
}

func (s *KwInputContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwInput(s)
	}
}

func (p *CqlParser) KwInput() (localctx IKwInputContext) {
	this := p
	_ = this

	localctx = NewKwInputContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 424, CqlParserRULE_kwInput)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2193)
		p.Match(CqlParserK_INPUT)
	}

	return localctx
}

// IKwInsertContext is an interface to support dynamic dispatch.
type IKwInsertContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwInsertContext differentiates from other interfaces.
	IsKwInsertContext()
}

type KwInsertContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwInsertContext() *KwInsertContext {
	var p = new(KwInsertContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwInsert
	return p
}

func (*KwInsertContext) IsKwInsertContext() {}

func NewKwInsertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwInsertContext {
	var p = new(KwInsertContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwInsert

	return p
}

func (s *KwInsertContext) GetParser() antlr.Parser { return s.parser }

func (s *KwInsertContext) K_INSERT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_INSERT, 0)
}

func (s *KwInsertContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwInsertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwInsertContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwInsert(s)
	}
}

func (s *KwInsertContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwInsert(s)
	}
}

func (p *CqlParser) KwInsert() (localctx IKwInsertContext) {
	this := p
	_ = this

	localctx = NewKwInsertContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 426, CqlParserRULE_kwInsert)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2195)
		p.Match(CqlParserK_INSERT)
	}

	return localctx
}

// IKwIntoContext is an interface to support dynamic dispatch.
type IKwIntoContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwIntoContext differentiates from other interfaces.
	IsKwIntoContext()
}

type KwIntoContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwIntoContext() *KwIntoContext {
	var p = new(KwIntoContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwInto
	return p
}

func (*KwIntoContext) IsKwIntoContext() {}

func NewKwIntoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwIntoContext {
	var p = new(KwIntoContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwInto

	return p
}

func (s *KwIntoContext) GetParser() antlr.Parser { return s.parser }

func (s *KwIntoContext) K_INTO() antlr.TerminalNode {
	return s.GetToken(CqlParserK_INTO, 0)
}

func (s *KwIntoContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwIntoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwIntoContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwInto(s)
	}
}

func (s *KwIntoContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwInto(s)
	}
}

func (p *CqlParser) KwInto() (localctx IKwIntoContext) {
	this := p
	_ = this

	localctx = NewKwIntoContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 428, CqlParserRULE_kwInto)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2197)
		p.Match(CqlParserK_INTO)
	}

	return localctx
}

// IKwIsContext is an interface to support dynamic dispatch.
type IKwIsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwIsContext differentiates from other interfaces.
	IsKwIsContext()
}

type KwIsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwIsContext() *KwIsContext {
	var p = new(KwIsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwIs
	return p
}

func (*KwIsContext) IsKwIsContext() {}

func NewKwIsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwIsContext {
	var p = new(KwIsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwIs

	return p
}

func (s *KwIsContext) GetParser() antlr.Parser { return s.parser }

func (s *KwIsContext) K_IS() antlr.TerminalNode {
	return s.GetToken(CqlParserK_IS, 0)
}

func (s *KwIsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwIsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwIsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwIs(s)
	}
}

func (s *KwIsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwIs(s)
	}
}

func (p *CqlParser) KwIs() (localctx IKwIsContext) {
	this := p
	_ = this

	localctx = NewKwIsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 430, CqlParserRULE_kwIs)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2199)
		p.Match(CqlParserK_IS)
	}

	return localctx
}

// IKwJsonContext is an interface to support dynamic dispatch.
type IKwJsonContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwJsonContext differentiates from other interfaces.
	IsKwJsonContext()
}

type KwJsonContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwJsonContext() *KwJsonContext {
	var p = new(KwJsonContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwJson
	return p
}

func (*KwJsonContext) IsKwJsonContext() {}

func NewKwJsonContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwJsonContext {
	var p = new(KwJsonContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwJson

	return p
}

func (s *KwJsonContext) GetParser() antlr.Parser { return s.parser }

func (s *KwJsonContext) K_JSON() antlr.TerminalNode {
	return s.GetToken(CqlParserK_JSON, 0)
}

func (s *KwJsonContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwJsonContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwJsonContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwJson(s)
	}
}

func (s *KwJsonContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwJson(s)
	}
}

func (p *CqlParser) KwJson() (localctx IKwJsonContext) {
	this := p
	_ = this

	localctx = NewKwJsonContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 432, CqlParserRULE_kwJson)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2201)
		p.Match(CqlParserK_JSON)
	}

	return localctx
}

// IKwKeyContext is an interface to support dynamic dispatch.
type IKwKeyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwKeyContext differentiates from other interfaces.
	IsKwKeyContext()
}

type KwKeyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwKeyContext() *KwKeyContext {
	var p = new(KwKeyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwKey
	return p
}

func (*KwKeyContext) IsKwKeyContext() {}

func NewKwKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwKeyContext {
	var p = new(KwKeyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwKey

	return p
}

func (s *KwKeyContext) GetParser() antlr.Parser { return s.parser }

func (s *KwKeyContext) K_KEY() antlr.TerminalNode {
	return s.GetToken(CqlParserK_KEY, 0)
}

func (s *KwKeyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwKeyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwKey(s)
	}
}

func (s *KwKeyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwKey(s)
	}
}

func (p *CqlParser) KwKey() (localctx IKwKeyContext) {
	this := p
	_ = this

	localctx = NewKwKeyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 434, CqlParserRULE_kwKey)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2203)
		p.Match(CqlParserK_KEY)
	}

	return localctx
}

// IKwKeysContext is an interface to support dynamic dispatch.
type IKwKeysContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwKeysContext differentiates from other interfaces.
	IsKwKeysContext()
}

type KwKeysContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwKeysContext() *KwKeysContext {
	var p = new(KwKeysContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwKeys
	return p
}

func (*KwKeysContext) IsKwKeysContext() {}

func NewKwKeysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwKeysContext {
	var p = new(KwKeysContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwKeys

	return p
}

func (s *KwKeysContext) GetParser() antlr.Parser { return s.parser }

func (s *KwKeysContext) K_KEYS() antlr.TerminalNode {
	return s.GetToken(CqlParserK_KEYS, 0)
}

func (s *KwKeysContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwKeysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwKeysContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwKeys(s)
	}
}

func (s *KwKeysContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwKeys(s)
	}
}

func (p *CqlParser) KwKeys() (localctx IKwKeysContext) {
	this := p
	_ = this

	localctx = NewKwKeysContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 436, CqlParserRULE_kwKeys)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2205)
		p.Match(CqlParserK_KEYS)
	}

	return localctx
}

// IKwKeyspaceContext is an interface to support dynamic dispatch.
type IKwKeyspaceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwKeyspaceContext differentiates from other interfaces.
	IsKwKeyspaceContext()
}

type KwKeyspaceContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwKeyspaceContext() *KwKeyspaceContext {
	var p = new(KwKeyspaceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwKeyspace
	return p
}

func (*KwKeyspaceContext) IsKwKeyspaceContext() {}

func NewKwKeyspaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwKeyspaceContext {
	var p = new(KwKeyspaceContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwKeyspace

	return p
}

func (s *KwKeyspaceContext) GetParser() antlr.Parser { return s.parser }

func (s *KwKeyspaceContext) K_KEYSPACE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_KEYSPACE, 0)
}

func (s *KwKeyspaceContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwKeyspaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwKeyspaceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwKeyspace(s)
	}
}

func (s *KwKeyspaceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwKeyspace(s)
	}
}

func (p *CqlParser) KwKeyspace() (localctx IKwKeyspaceContext) {
	this := p
	_ = this

	localctx = NewKwKeyspaceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 438, CqlParserRULE_kwKeyspace)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2207)
		p.Match(CqlParserK_KEYSPACE)
	}

	return localctx
}

// IKwKeyspacesContext is an interface to support dynamic dispatch.
type IKwKeyspacesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwKeyspacesContext differentiates from other interfaces.
	IsKwKeyspacesContext()
}

type KwKeyspacesContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwKeyspacesContext() *KwKeyspacesContext {
	var p = new(KwKeyspacesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwKeyspaces
	return p
}

func (*KwKeyspacesContext) IsKwKeyspacesContext() {}

func NewKwKeyspacesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwKeyspacesContext {
	var p = new(KwKeyspacesContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwKeyspaces

	return p
}

func (s *KwKeyspacesContext) GetParser() antlr.Parser { return s.parser }

func (s *KwKeyspacesContext) K_KEYSPACES() antlr.TerminalNode {
	return s.GetToken(CqlParserK_KEYSPACES, 0)
}

func (s *KwKeyspacesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwKeyspacesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwKeyspacesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwKeyspaces(s)
	}
}

func (s *KwKeyspacesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwKeyspaces(s)
	}
}

func (p *CqlParser) KwKeyspaces() (localctx IKwKeyspacesContext) {
	this := p
	_ = this

	localctx = NewKwKeyspacesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 440, CqlParserRULE_kwKeyspaces)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2209)
		p.Match(CqlParserK_KEYSPACES)
	}

	return localctx
}

// IKwLanguageContext is an interface to support dynamic dispatch.
type IKwLanguageContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwLanguageContext differentiates from other interfaces.
	IsKwLanguageContext()
}

type KwLanguageContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwLanguageContext() *KwLanguageContext {
	var p = new(KwLanguageContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwLanguage
	return p
}

func (*KwLanguageContext) IsKwLanguageContext() {}

func NewKwLanguageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwLanguageContext {
	var p = new(KwLanguageContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwLanguage

	return p
}

func (s *KwLanguageContext) GetParser() antlr.Parser { return s.parser }

func (s *KwLanguageContext) K_LANGUAGE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_LANGUAGE, 0)
}

func (s *KwLanguageContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwLanguageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwLanguageContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwLanguage(s)
	}
}

func (s *KwLanguageContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwLanguage(s)
	}
}

func (p *CqlParser) KwLanguage() (localctx IKwLanguageContext) {
	this := p
	_ = this

	localctx = NewKwLanguageContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 442, CqlParserRULE_kwLanguage)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2211)
		p.Match(CqlParserK_LANGUAGE)
	}

	return localctx
}

// IKwLimitContext is an interface to support dynamic dispatch.
type IKwLimitContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwLimitContext differentiates from other interfaces.
	IsKwLimitContext()
}

type KwLimitContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwLimitContext() *KwLimitContext {
	var p = new(KwLimitContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwLimit
	return p
}

func (*KwLimitContext) IsKwLimitContext() {}

func NewKwLimitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwLimitContext {
	var p = new(KwLimitContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwLimit

	return p
}

func (s *KwLimitContext) GetParser() antlr.Parser { return s.parser }

func (s *KwLimitContext) K_LIMIT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_LIMIT, 0)
}

func (s *KwLimitContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwLimitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwLimitContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwLimit(s)
	}
}

func (s *KwLimitContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwLimit(s)
	}
}

func (p *CqlParser) KwLimit() (localctx IKwLimitContext) {
	this := p
	_ = this

	localctx = NewKwLimitContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 444, CqlParserRULE_kwLimit)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2213)
		p.Match(CqlParserK_LIMIT)
	}

	return localctx
}

// IKwListContext is an interface to support dynamic dispatch.
type IKwListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwListContext differentiates from other interfaces.
	IsKwListContext()
}

type KwListContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwListContext() *KwListContext {
	var p = new(KwListContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwList
	return p
}

func (*KwListContext) IsKwListContext() {}

func NewKwListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwListContext {
	var p = new(KwListContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwList

	return p
}

func (s *KwListContext) GetParser() antlr.Parser { return s.parser }

func (s *KwListContext) K_LIST() antlr.TerminalNode {
	return s.GetToken(CqlParserK_LIST, 0)
}

func (s *KwListContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwListContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwList(s)
	}
}

func (s *KwListContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwList(s)
	}
}

func (p *CqlParser) KwList() (localctx IKwListContext) {
	this := p
	_ = this

	localctx = NewKwListContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 446, CqlParserRULE_kwList)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2215)
		p.Match(CqlParserK_LIST)
	}

	return localctx
}

// IKwLoggedContext is an interface to support dynamic dispatch.
type IKwLoggedContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwLoggedContext differentiates from other interfaces.
	IsKwLoggedContext()
}

type KwLoggedContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwLoggedContext() *KwLoggedContext {
	var p = new(KwLoggedContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwLogged
	return p
}

func (*KwLoggedContext) IsKwLoggedContext() {}

func NewKwLoggedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwLoggedContext {
	var p = new(KwLoggedContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwLogged

	return p
}

func (s *KwLoggedContext) GetParser() antlr.Parser { return s.parser }

func (s *KwLoggedContext) K_LOGGED() antlr.TerminalNode {
	return s.GetToken(CqlParserK_LOGGED, 0)
}

func (s *KwLoggedContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwLoggedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwLoggedContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwLogged(s)
	}
}

func (s *KwLoggedContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwLogged(s)
	}
}

func (p *CqlParser) KwLogged() (localctx IKwLoggedContext) {
	this := p
	_ = this

	localctx = NewKwLoggedContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 448, CqlParserRULE_kwLogged)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2217)
		p.Match(CqlParserK_LOGGED)
	}

	return localctx
}

// IKwLoginContext is an interface to support dynamic dispatch.
type IKwLoginContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwLoginContext differentiates from other interfaces.
	IsKwLoginContext()
}

type KwLoginContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwLoginContext() *KwLoginContext {
	var p = new(KwLoginContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwLogin
	return p
}

func (*KwLoginContext) IsKwLoginContext() {}

func NewKwLoginContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwLoginContext {
	var p = new(KwLoginContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwLogin

	return p
}

func (s *KwLoginContext) GetParser() antlr.Parser { return s.parser }

func (s *KwLoginContext) K_LOGIN() antlr.TerminalNode {
	return s.GetToken(CqlParserK_LOGIN, 0)
}

func (s *KwLoginContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwLoginContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwLoginContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwLogin(s)
	}
}

func (s *KwLoginContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwLogin(s)
	}
}

func (p *CqlParser) KwLogin() (localctx IKwLoginContext) {
	this := p
	_ = this

	localctx = NewKwLoginContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 450, CqlParserRULE_kwLogin)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2219)
		p.Match(CqlParserK_LOGIN)
	}

	return localctx
}

// IKwMaterializedContext is an interface to support dynamic dispatch.
type IKwMaterializedContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwMaterializedContext differentiates from other interfaces.
	IsKwMaterializedContext()
}

type KwMaterializedContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwMaterializedContext() *KwMaterializedContext {
	var p = new(KwMaterializedContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwMaterialized
	return p
}

func (*KwMaterializedContext) IsKwMaterializedContext() {}

func NewKwMaterializedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwMaterializedContext {
	var p = new(KwMaterializedContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwMaterialized

	return p
}

func (s *KwMaterializedContext) GetParser() antlr.Parser { return s.parser }

func (s *KwMaterializedContext) K_MATERIALIZED() antlr.TerminalNode {
	return s.GetToken(CqlParserK_MATERIALIZED, 0)
}

func (s *KwMaterializedContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwMaterializedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwMaterializedContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwMaterialized(s)
	}
}

func (s *KwMaterializedContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwMaterialized(s)
	}
}

func (p *CqlParser) KwMaterialized() (localctx IKwMaterializedContext) {
	this := p
	_ = this

	localctx = NewKwMaterializedContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 452, CqlParserRULE_kwMaterialized)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2221)
		p.Match(CqlParserK_MATERIALIZED)
	}

	return localctx
}

// IKwModifyContext is an interface to support dynamic dispatch.
type IKwModifyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwModifyContext differentiates from other interfaces.
	IsKwModifyContext()
}

type KwModifyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwModifyContext() *KwModifyContext {
	var p = new(KwModifyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwModify
	return p
}

func (*KwModifyContext) IsKwModifyContext() {}

func NewKwModifyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwModifyContext {
	var p = new(KwModifyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwModify

	return p
}

func (s *KwModifyContext) GetParser() antlr.Parser { return s.parser }

func (s *KwModifyContext) K_MODIFY() antlr.TerminalNode {
	return s.GetToken(CqlParserK_MODIFY, 0)
}

func (s *KwModifyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwModifyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwModifyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwModify(s)
	}
}

func (s *KwModifyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwModify(s)
	}
}

func (p *CqlParser) KwModify() (localctx IKwModifyContext) {
	this := p
	_ = this

	localctx = NewKwModifyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 454, CqlParserRULE_kwModify)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2223)
		p.Match(CqlParserK_MODIFY)
	}

	return localctx
}

// IKwNosuperuserContext is an interface to support dynamic dispatch.
type IKwNosuperuserContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwNosuperuserContext differentiates from other interfaces.
	IsKwNosuperuserContext()
}

type KwNosuperuserContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwNosuperuserContext() *KwNosuperuserContext {
	var p = new(KwNosuperuserContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwNosuperuser
	return p
}

func (*KwNosuperuserContext) IsKwNosuperuserContext() {}

func NewKwNosuperuserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwNosuperuserContext {
	var p = new(KwNosuperuserContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwNosuperuser

	return p
}

func (s *KwNosuperuserContext) GetParser() antlr.Parser { return s.parser }

func (s *KwNosuperuserContext) K_NOSUPERUSER() antlr.TerminalNode {
	return s.GetToken(CqlParserK_NOSUPERUSER, 0)
}

func (s *KwNosuperuserContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwNosuperuserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwNosuperuserContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwNosuperuser(s)
	}
}

func (s *KwNosuperuserContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwNosuperuser(s)
	}
}

func (p *CqlParser) KwNosuperuser() (localctx IKwNosuperuserContext) {
	this := p
	_ = this

	localctx = NewKwNosuperuserContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 456, CqlParserRULE_kwNosuperuser)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2225)
		p.Match(CqlParserK_NOSUPERUSER)
	}

	return localctx
}

// IKwNorecursiveContext is an interface to support dynamic dispatch.
type IKwNorecursiveContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwNorecursiveContext differentiates from other interfaces.
	IsKwNorecursiveContext()
}

type KwNorecursiveContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwNorecursiveContext() *KwNorecursiveContext {
	var p = new(KwNorecursiveContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwNorecursive
	return p
}

func (*KwNorecursiveContext) IsKwNorecursiveContext() {}

func NewKwNorecursiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwNorecursiveContext {
	var p = new(KwNorecursiveContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwNorecursive

	return p
}

func (s *KwNorecursiveContext) GetParser() antlr.Parser { return s.parser }

func (s *KwNorecursiveContext) K_NORECURSIVE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_NORECURSIVE, 0)
}

func (s *KwNorecursiveContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwNorecursiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwNorecursiveContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwNorecursive(s)
	}
}

func (s *KwNorecursiveContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwNorecursive(s)
	}
}

func (p *CqlParser) KwNorecursive() (localctx IKwNorecursiveContext) {
	this := p
	_ = this

	localctx = NewKwNorecursiveContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 458, CqlParserRULE_kwNorecursive)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2227)
		p.Match(CqlParserK_NORECURSIVE)
	}

	return localctx
}

// IKwNotContext is an interface to support dynamic dispatch.
type IKwNotContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwNotContext differentiates from other interfaces.
	IsKwNotContext()
}

type KwNotContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwNotContext() *KwNotContext {
	var p = new(KwNotContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwNot
	return p
}

func (*KwNotContext) IsKwNotContext() {}

func NewKwNotContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwNotContext {
	var p = new(KwNotContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwNot

	return p
}

func (s *KwNotContext) GetParser() antlr.Parser { return s.parser }

func (s *KwNotContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_NOT, 0)
}

func (s *KwNotContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwNotContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwNotContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwNot(s)
	}
}

func (s *KwNotContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwNot(s)
	}
}

func (p *CqlParser) KwNot() (localctx IKwNotContext) {
	this := p
	_ = this

	localctx = NewKwNotContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 460, CqlParserRULE_kwNot)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2229)
		p.Match(CqlParserK_NOT)
	}

	return localctx
}

// IKwNullContext is an interface to support dynamic dispatch.
type IKwNullContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwNullContext differentiates from other interfaces.
	IsKwNullContext()
}

type KwNullContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwNullContext() *KwNullContext {
	var p = new(KwNullContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwNull
	return p
}

func (*KwNullContext) IsKwNullContext() {}

func NewKwNullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwNullContext {
	var p = new(KwNullContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwNull

	return p
}

func (s *KwNullContext) GetParser() antlr.Parser { return s.parser }

func (s *KwNullContext) K_NULL() antlr.TerminalNode {
	return s.GetToken(CqlParserK_NULL, 0)
}

func (s *KwNullContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwNullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwNullContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwNull(s)
	}
}

func (s *KwNullContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwNull(s)
	}
}

func (p *CqlParser) KwNull() (localctx IKwNullContext) {
	this := p
	_ = this

	localctx = NewKwNullContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 462, CqlParserRULE_kwNull)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2231)
		p.Match(CqlParserK_NULL)
	}

	return localctx
}

// IKwOfContext is an interface to support dynamic dispatch.
type IKwOfContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwOfContext differentiates from other interfaces.
	IsKwOfContext()
}

type KwOfContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwOfContext() *KwOfContext {
	var p = new(KwOfContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwOf
	return p
}

func (*KwOfContext) IsKwOfContext() {}

func NewKwOfContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwOfContext {
	var p = new(KwOfContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwOf

	return p
}

func (s *KwOfContext) GetParser() antlr.Parser { return s.parser }

func (s *KwOfContext) K_OF() antlr.TerminalNode {
	return s.GetToken(CqlParserK_OF, 0)
}

func (s *KwOfContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwOfContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwOfContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwOf(s)
	}
}

func (s *KwOfContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwOf(s)
	}
}

func (p *CqlParser) KwOf() (localctx IKwOfContext) {
	this := p
	_ = this

	localctx = NewKwOfContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 464, CqlParserRULE_kwOf)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2233)
		p.Match(CqlParserK_OF)
	}

	return localctx
}

// IKwOnContext is an interface to support dynamic dispatch.
type IKwOnContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwOnContext differentiates from other interfaces.
	IsKwOnContext()
}

type KwOnContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwOnContext() *KwOnContext {
	var p = new(KwOnContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwOn
	return p
}

func (*KwOnContext) IsKwOnContext() {}

func NewKwOnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwOnContext {
	var p = new(KwOnContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwOn

	return p
}

func (s *KwOnContext) GetParser() antlr.Parser { return s.parser }

func (s *KwOnContext) K_ON() antlr.TerminalNode {
	return s.GetToken(CqlParserK_ON, 0)
}

func (s *KwOnContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwOnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwOnContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwOn(s)
	}
}

func (s *KwOnContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwOn(s)
	}
}

func (p *CqlParser) KwOn() (localctx IKwOnContext) {
	this := p
	_ = this

	localctx = NewKwOnContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 466, CqlParserRULE_kwOn)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2235)
		p.Match(CqlParserK_ON)
	}

	return localctx
}

// IKwOptionsContext is an interface to support dynamic dispatch.
type IKwOptionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwOptionsContext differentiates from other interfaces.
	IsKwOptionsContext()
}

type KwOptionsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwOptionsContext() *KwOptionsContext {
	var p = new(KwOptionsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwOptions
	return p
}

func (*KwOptionsContext) IsKwOptionsContext() {}

func NewKwOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwOptionsContext {
	var p = new(KwOptionsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwOptions

	return p
}

func (s *KwOptionsContext) GetParser() antlr.Parser { return s.parser }

func (s *KwOptionsContext) K_OPTIONS() antlr.TerminalNode {
	return s.GetToken(CqlParserK_OPTIONS, 0)
}

func (s *KwOptionsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwOptionsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwOptions(s)
	}
}

func (s *KwOptionsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwOptions(s)
	}
}

func (p *CqlParser) KwOptions() (localctx IKwOptionsContext) {
	this := p
	_ = this

	localctx = NewKwOptionsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 468, CqlParserRULE_kwOptions)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2237)
		p.Match(CqlParserK_OPTIONS)
	}

	return localctx
}

// IKwOrContext is an interface to support dynamic dispatch.
type IKwOrContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwOrContext differentiates from other interfaces.
	IsKwOrContext()
}

type KwOrContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwOrContext() *KwOrContext {
	var p = new(KwOrContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwOr
	return p
}

func (*KwOrContext) IsKwOrContext() {}

func NewKwOrContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwOrContext {
	var p = new(KwOrContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwOr

	return p
}

func (s *KwOrContext) GetParser() antlr.Parser { return s.parser }

func (s *KwOrContext) K_OR() antlr.TerminalNode {
	return s.GetToken(CqlParserK_OR, 0)
}

func (s *KwOrContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwOrContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwOrContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwOr(s)
	}
}

func (s *KwOrContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwOr(s)
	}
}

func (p *CqlParser) KwOr() (localctx IKwOrContext) {
	this := p
	_ = this

	localctx = NewKwOrContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 470, CqlParserRULE_kwOr)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2239)
		p.Match(CqlParserK_OR)
	}

	return localctx
}

// IKwOrderContext is an interface to support dynamic dispatch.
type IKwOrderContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwOrderContext differentiates from other interfaces.
	IsKwOrderContext()
}

type KwOrderContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwOrderContext() *KwOrderContext {
	var p = new(KwOrderContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwOrder
	return p
}

func (*KwOrderContext) IsKwOrderContext() {}

func NewKwOrderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwOrderContext {
	var p = new(KwOrderContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwOrder

	return p
}

func (s *KwOrderContext) GetParser() antlr.Parser { return s.parser }

func (s *KwOrderContext) K_ORDER() antlr.TerminalNode {
	return s.GetToken(CqlParserK_ORDER, 0)
}

func (s *KwOrderContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwOrderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwOrderContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwOrder(s)
	}
}

func (s *KwOrderContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwOrder(s)
	}
}

func (p *CqlParser) KwOrder() (localctx IKwOrderContext) {
	this := p
	_ = this

	localctx = NewKwOrderContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 472, CqlParserRULE_kwOrder)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2241)
		p.Match(CqlParserK_ORDER)
	}

	return localctx
}

// IKwPasswordContext is an interface to support dynamic dispatch.
type IKwPasswordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwPasswordContext differentiates from other interfaces.
	IsKwPasswordContext()
}

type KwPasswordContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwPasswordContext() *KwPasswordContext {
	var p = new(KwPasswordContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwPassword
	return p
}

func (*KwPasswordContext) IsKwPasswordContext() {}

func NewKwPasswordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwPasswordContext {
	var p = new(KwPasswordContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwPassword

	return p
}

func (s *KwPasswordContext) GetParser() antlr.Parser { return s.parser }

func (s *KwPasswordContext) K_PASSWORD() antlr.TerminalNode {
	return s.GetToken(CqlParserK_PASSWORD, 0)
}

func (s *KwPasswordContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwPasswordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwPasswordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwPassword(s)
	}
}

func (s *KwPasswordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwPassword(s)
	}
}

func (p *CqlParser) KwPassword() (localctx IKwPasswordContext) {
	this := p
	_ = this

	localctx = NewKwPasswordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 474, CqlParserRULE_kwPassword)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2243)
		p.Match(CqlParserK_PASSWORD)
	}

	return localctx
}

// IKwPrimaryContext is an interface to support dynamic dispatch.
type IKwPrimaryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwPrimaryContext differentiates from other interfaces.
	IsKwPrimaryContext()
}

type KwPrimaryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwPrimaryContext() *KwPrimaryContext {
	var p = new(KwPrimaryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwPrimary
	return p
}

func (*KwPrimaryContext) IsKwPrimaryContext() {}

func NewKwPrimaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwPrimaryContext {
	var p = new(KwPrimaryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwPrimary

	return p
}

func (s *KwPrimaryContext) GetParser() antlr.Parser { return s.parser }

func (s *KwPrimaryContext) K_PRIMARY() antlr.TerminalNode {
	return s.GetToken(CqlParserK_PRIMARY, 0)
}

func (s *KwPrimaryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwPrimaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwPrimaryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwPrimary(s)
	}
}

func (s *KwPrimaryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwPrimary(s)
	}
}

func (p *CqlParser) KwPrimary() (localctx IKwPrimaryContext) {
	this := p
	_ = this

	localctx = NewKwPrimaryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 476, CqlParserRULE_kwPrimary)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2245)
		p.Match(CqlParserK_PRIMARY)
	}

	return localctx
}

// IKwRenameContext is an interface to support dynamic dispatch.
type IKwRenameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwRenameContext differentiates from other interfaces.
	IsKwRenameContext()
}

type KwRenameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwRenameContext() *KwRenameContext {
	var p = new(KwRenameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwRename
	return p
}

func (*KwRenameContext) IsKwRenameContext() {}

func NewKwRenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwRenameContext {
	var p = new(KwRenameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwRename

	return p
}

func (s *KwRenameContext) GetParser() antlr.Parser { return s.parser }

func (s *KwRenameContext) K_RENAME() antlr.TerminalNode {
	return s.GetToken(CqlParserK_RENAME, 0)
}

func (s *KwRenameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwRenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwRenameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwRename(s)
	}
}

func (s *KwRenameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwRename(s)
	}
}

func (p *CqlParser) KwRename() (localctx IKwRenameContext) {
	this := p
	_ = this

	localctx = NewKwRenameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 478, CqlParserRULE_kwRename)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2247)
		p.Match(CqlParserK_RENAME)
	}

	return localctx
}

// IKwReplaceContext is an interface to support dynamic dispatch.
type IKwReplaceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwReplaceContext differentiates from other interfaces.
	IsKwReplaceContext()
}

type KwReplaceContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwReplaceContext() *KwReplaceContext {
	var p = new(KwReplaceContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwReplace
	return p
}

func (*KwReplaceContext) IsKwReplaceContext() {}

func NewKwReplaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwReplaceContext {
	var p = new(KwReplaceContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwReplace

	return p
}

func (s *KwReplaceContext) GetParser() antlr.Parser { return s.parser }

func (s *KwReplaceContext) K_REPLACE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_REPLACE, 0)
}

func (s *KwReplaceContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwReplaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwReplaceContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwReplace(s)
	}
}

func (s *KwReplaceContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwReplace(s)
	}
}

func (p *CqlParser) KwReplace() (localctx IKwReplaceContext) {
	this := p
	_ = this

	localctx = NewKwReplaceContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 480, CqlParserRULE_kwReplace)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2249)
		p.Match(CqlParserK_REPLACE)
	}

	return localctx
}

// IKwReplicationContext is an interface to support dynamic dispatch.
type IKwReplicationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwReplicationContext differentiates from other interfaces.
	IsKwReplicationContext()
}

type KwReplicationContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwReplicationContext() *KwReplicationContext {
	var p = new(KwReplicationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwReplication
	return p
}

func (*KwReplicationContext) IsKwReplicationContext() {}

func NewKwReplicationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwReplicationContext {
	var p = new(KwReplicationContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwReplication

	return p
}

func (s *KwReplicationContext) GetParser() antlr.Parser { return s.parser }

func (s *KwReplicationContext) K_REPLICATION() antlr.TerminalNode {
	return s.GetToken(CqlParserK_REPLICATION, 0)
}

func (s *KwReplicationContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwReplicationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwReplicationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwReplication(s)
	}
}

func (s *KwReplicationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwReplication(s)
	}
}

func (p *CqlParser) KwReplication() (localctx IKwReplicationContext) {
	this := p
	_ = this

	localctx = NewKwReplicationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 482, CqlParserRULE_kwReplication)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2251)
		p.Match(CqlParserK_REPLICATION)
	}

	return localctx
}

// IKwReturnsContext is an interface to support dynamic dispatch.
type IKwReturnsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwReturnsContext differentiates from other interfaces.
	IsKwReturnsContext()
}

type KwReturnsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwReturnsContext() *KwReturnsContext {
	var p = new(KwReturnsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwReturns
	return p
}

func (*KwReturnsContext) IsKwReturnsContext() {}

func NewKwReturnsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwReturnsContext {
	var p = new(KwReturnsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwReturns

	return p
}

func (s *KwReturnsContext) GetParser() antlr.Parser { return s.parser }

func (s *KwReturnsContext) K_RETURNS() antlr.TerminalNode {
	return s.GetToken(CqlParserK_RETURNS, 0)
}

func (s *KwReturnsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwReturnsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwReturnsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwReturns(s)
	}
}

func (s *KwReturnsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwReturns(s)
	}
}

func (p *CqlParser) KwReturns() (localctx IKwReturnsContext) {
	this := p
	_ = this

	localctx = NewKwReturnsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 484, CqlParserRULE_kwReturns)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2253)
		p.Match(CqlParserK_RETURNS)
	}

	return localctx
}

// IKwRoleContext is an interface to support dynamic dispatch.
type IKwRoleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwRoleContext differentiates from other interfaces.
	IsKwRoleContext()
}

type KwRoleContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwRoleContext() *KwRoleContext {
	var p = new(KwRoleContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwRole
	return p
}

func (*KwRoleContext) IsKwRoleContext() {}

func NewKwRoleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwRoleContext {
	var p = new(KwRoleContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwRole

	return p
}

func (s *KwRoleContext) GetParser() antlr.Parser { return s.parser }

func (s *KwRoleContext) K_ROLE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_ROLE, 0)
}

func (s *KwRoleContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwRoleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwRoleContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwRole(s)
	}
}

func (s *KwRoleContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwRole(s)
	}
}

func (p *CqlParser) KwRole() (localctx IKwRoleContext) {
	this := p
	_ = this

	localctx = NewKwRoleContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 486, CqlParserRULE_kwRole)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2255)
		p.Match(CqlParserK_ROLE)
	}

	return localctx
}

// IKwRolesContext is an interface to support dynamic dispatch.
type IKwRolesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwRolesContext differentiates from other interfaces.
	IsKwRolesContext()
}

type KwRolesContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwRolesContext() *KwRolesContext {
	var p = new(KwRolesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwRoles
	return p
}

func (*KwRolesContext) IsKwRolesContext() {}

func NewKwRolesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwRolesContext {
	var p = new(KwRolesContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwRoles

	return p
}

func (s *KwRolesContext) GetParser() antlr.Parser { return s.parser }

func (s *KwRolesContext) K_ROLES() antlr.TerminalNode {
	return s.GetToken(CqlParserK_ROLES, 0)
}

func (s *KwRolesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwRolesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwRolesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwRoles(s)
	}
}

func (s *KwRolesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwRoles(s)
	}
}

func (p *CqlParser) KwRoles() (localctx IKwRolesContext) {
	this := p
	_ = this

	localctx = NewKwRolesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 488, CqlParserRULE_kwRoles)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2257)
		p.Match(CqlParserK_ROLES)
	}

	return localctx
}

// IKwSelectContext is an interface to support dynamic dispatch.
type IKwSelectContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwSelectContext differentiates from other interfaces.
	IsKwSelectContext()
}

type KwSelectContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwSelectContext() *KwSelectContext {
	var p = new(KwSelectContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwSelect
	return p
}

func (*KwSelectContext) IsKwSelectContext() {}

func NewKwSelectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwSelectContext {
	var p = new(KwSelectContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwSelect

	return p
}

func (s *KwSelectContext) GetParser() antlr.Parser { return s.parser }

func (s *KwSelectContext) K_SELECT() antlr.TerminalNode {
	return s.GetToken(CqlParserK_SELECT, 0)
}

func (s *KwSelectContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwSelectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwSelectContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwSelect(s)
	}
}

func (s *KwSelectContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwSelect(s)
	}
}

func (p *CqlParser) KwSelect() (localctx IKwSelectContext) {
	this := p
	_ = this

	localctx = NewKwSelectContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 490, CqlParserRULE_kwSelect)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2259)
		p.Match(CqlParserK_SELECT)
	}

	return localctx
}

// IKwSetContext is an interface to support dynamic dispatch.
type IKwSetContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwSetContext differentiates from other interfaces.
	IsKwSetContext()
}

type KwSetContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwSetContext() *KwSetContext {
	var p = new(KwSetContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwSet
	return p
}

func (*KwSetContext) IsKwSetContext() {}

func NewKwSetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwSetContext {
	var p = new(KwSetContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwSet

	return p
}

func (s *KwSetContext) GetParser() antlr.Parser { return s.parser }

func (s *KwSetContext) K_SET() antlr.TerminalNode {
	return s.GetToken(CqlParserK_SET, 0)
}

func (s *KwSetContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwSetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwSetContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwSet(s)
	}
}

func (s *KwSetContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwSet(s)
	}
}

func (p *CqlParser) KwSet() (localctx IKwSetContext) {
	this := p
	_ = this

	localctx = NewKwSetContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 492, CqlParserRULE_kwSet)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2261)
		p.Match(CqlParserK_SET)
	}

	return localctx
}

// IKwSfuncContext is an interface to support dynamic dispatch.
type IKwSfuncContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwSfuncContext differentiates from other interfaces.
	IsKwSfuncContext()
}

type KwSfuncContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwSfuncContext() *KwSfuncContext {
	var p = new(KwSfuncContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwSfunc
	return p
}

func (*KwSfuncContext) IsKwSfuncContext() {}

func NewKwSfuncContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwSfuncContext {
	var p = new(KwSfuncContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwSfunc

	return p
}

func (s *KwSfuncContext) GetParser() antlr.Parser { return s.parser }

func (s *KwSfuncContext) K_SFUNC() antlr.TerminalNode {
	return s.GetToken(CqlParserK_SFUNC, 0)
}

func (s *KwSfuncContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwSfuncContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwSfuncContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwSfunc(s)
	}
}

func (s *KwSfuncContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwSfunc(s)
	}
}

func (p *CqlParser) KwSfunc() (localctx IKwSfuncContext) {
	this := p
	_ = this

	localctx = NewKwSfuncContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 494, CqlParserRULE_kwSfunc)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2263)
		p.Match(CqlParserK_SFUNC)
	}

	return localctx
}

// IKwStorageContext is an interface to support dynamic dispatch.
type IKwStorageContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwStorageContext differentiates from other interfaces.
	IsKwStorageContext()
}

type KwStorageContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwStorageContext() *KwStorageContext {
	var p = new(KwStorageContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwStorage
	return p
}

func (*KwStorageContext) IsKwStorageContext() {}

func NewKwStorageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwStorageContext {
	var p = new(KwStorageContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwStorage

	return p
}

func (s *KwStorageContext) GetParser() antlr.Parser { return s.parser }

func (s *KwStorageContext) K_STORAGE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_STORAGE, 0)
}

func (s *KwStorageContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwStorageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwStorageContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwStorage(s)
	}
}

func (s *KwStorageContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwStorage(s)
	}
}

func (p *CqlParser) KwStorage() (localctx IKwStorageContext) {
	this := p
	_ = this

	localctx = NewKwStorageContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 496, CqlParserRULE_kwStorage)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2265)
		p.Match(CqlParserK_STORAGE)
	}

	return localctx
}

// IKwStypeContext is an interface to support dynamic dispatch.
type IKwStypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwStypeContext differentiates from other interfaces.
	IsKwStypeContext()
}

type KwStypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwStypeContext() *KwStypeContext {
	var p = new(KwStypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwStype
	return p
}

func (*KwStypeContext) IsKwStypeContext() {}

func NewKwStypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwStypeContext {
	var p = new(KwStypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwStype

	return p
}

func (s *KwStypeContext) GetParser() antlr.Parser { return s.parser }

func (s *KwStypeContext) K_STYPE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_STYPE, 0)
}

func (s *KwStypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwStypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwStypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwStype(s)
	}
}

func (s *KwStypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwStype(s)
	}
}

func (p *CqlParser) KwStype() (localctx IKwStypeContext) {
	this := p
	_ = this

	localctx = NewKwStypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 498, CqlParserRULE_kwStype)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2267)
		p.Match(CqlParserK_STYPE)
	}

	return localctx
}

// IKwSuperuserContext is an interface to support dynamic dispatch.
type IKwSuperuserContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwSuperuserContext differentiates from other interfaces.
	IsKwSuperuserContext()
}

type KwSuperuserContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwSuperuserContext() *KwSuperuserContext {
	var p = new(KwSuperuserContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwSuperuser
	return p
}

func (*KwSuperuserContext) IsKwSuperuserContext() {}

func NewKwSuperuserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwSuperuserContext {
	var p = new(KwSuperuserContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwSuperuser

	return p
}

func (s *KwSuperuserContext) GetParser() antlr.Parser { return s.parser }

func (s *KwSuperuserContext) K_SUPERUSER() antlr.TerminalNode {
	return s.GetToken(CqlParserK_SUPERUSER, 0)
}

func (s *KwSuperuserContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwSuperuserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwSuperuserContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwSuperuser(s)
	}
}

func (s *KwSuperuserContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwSuperuser(s)
	}
}

func (p *CqlParser) KwSuperuser() (localctx IKwSuperuserContext) {
	this := p
	_ = this

	localctx = NewKwSuperuserContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 500, CqlParserRULE_kwSuperuser)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2269)
		p.Match(CqlParserK_SUPERUSER)
	}

	return localctx
}

// IKwTableContext is an interface to support dynamic dispatch.
type IKwTableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwTableContext differentiates from other interfaces.
	IsKwTableContext()
}

type KwTableContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwTableContext() *KwTableContext {
	var p = new(KwTableContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwTable
	return p
}

func (*KwTableContext) IsKwTableContext() {}

func NewKwTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwTableContext {
	var p = new(KwTableContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwTable

	return p
}

func (s *KwTableContext) GetParser() antlr.Parser { return s.parser }

func (s *KwTableContext) K_TABLE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_TABLE, 0)
}

func (s *KwTableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwTableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwTable(s)
	}
}

func (s *KwTableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwTable(s)
	}
}

func (p *CqlParser) KwTable() (localctx IKwTableContext) {
	this := p
	_ = this

	localctx = NewKwTableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 502, CqlParserRULE_kwTable)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2271)
		p.Match(CqlParserK_TABLE)
	}

	return localctx
}

// IKwTimestampContext is an interface to support dynamic dispatch.
type IKwTimestampContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwTimestampContext differentiates from other interfaces.
	IsKwTimestampContext()
}

type KwTimestampContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwTimestampContext() *KwTimestampContext {
	var p = new(KwTimestampContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwTimestamp
	return p
}

func (*KwTimestampContext) IsKwTimestampContext() {}

func NewKwTimestampContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwTimestampContext {
	var p = new(KwTimestampContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwTimestamp

	return p
}

func (s *KwTimestampContext) GetParser() antlr.Parser { return s.parser }

func (s *KwTimestampContext) K_TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(CqlParserK_TIMESTAMP, 0)
}

func (s *KwTimestampContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwTimestampContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwTimestampContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwTimestamp(s)
	}
}

func (s *KwTimestampContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwTimestamp(s)
	}
}

func (p *CqlParser) KwTimestamp() (localctx IKwTimestampContext) {
	this := p
	_ = this

	localctx = NewKwTimestampContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 504, CqlParserRULE_kwTimestamp)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2273)
		p.Match(CqlParserK_TIMESTAMP)
	}

	return localctx
}

// IKwToContext is an interface to support dynamic dispatch.
type IKwToContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwToContext differentiates from other interfaces.
	IsKwToContext()
}

type KwToContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwToContext() *KwToContext {
	var p = new(KwToContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwTo
	return p
}

func (*KwToContext) IsKwToContext() {}

func NewKwToContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwToContext {
	var p = new(KwToContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwTo

	return p
}

func (s *KwToContext) GetParser() antlr.Parser { return s.parser }

func (s *KwToContext) K_TO() antlr.TerminalNode {
	return s.GetToken(CqlParserK_TO, 0)
}

func (s *KwToContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwToContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwToContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwTo(s)
	}
}

func (s *KwToContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwTo(s)
	}
}

func (p *CqlParser) KwTo() (localctx IKwToContext) {
	this := p
	_ = this

	localctx = NewKwToContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 506, CqlParserRULE_kwTo)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2275)
		p.Match(CqlParserK_TO)
	}

	return localctx
}

// IKwTriggerContext is an interface to support dynamic dispatch.
type IKwTriggerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwTriggerContext differentiates from other interfaces.
	IsKwTriggerContext()
}

type KwTriggerContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwTriggerContext() *KwTriggerContext {
	var p = new(KwTriggerContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwTrigger
	return p
}

func (*KwTriggerContext) IsKwTriggerContext() {}

func NewKwTriggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwTriggerContext {
	var p = new(KwTriggerContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwTrigger

	return p
}

func (s *KwTriggerContext) GetParser() antlr.Parser { return s.parser }

func (s *KwTriggerContext) K_TRIGGER() antlr.TerminalNode {
	return s.GetToken(CqlParserK_TRIGGER, 0)
}

func (s *KwTriggerContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwTriggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwTriggerContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwTrigger(s)
	}
}

func (s *KwTriggerContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwTrigger(s)
	}
}

func (p *CqlParser) KwTrigger() (localctx IKwTriggerContext) {
	this := p
	_ = this

	localctx = NewKwTriggerContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 508, CqlParserRULE_kwTrigger)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2277)
		p.Match(CqlParserK_TRIGGER)
	}

	return localctx
}

// IKwTruncateContext is an interface to support dynamic dispatch.
type IKwTruncateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwTruncateContext differentiates from other interfaces.
	IsKwTruncateContext()
}

type KwTruncateContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwTruncateContext() *KwTruncateContext {
	var p = new(KwTruncateContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwTruncate
	return p
}

func (*KwTruncateContext) IsKwTruncateContext() {}

func NewKwTruncateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwTruncateContext {
	var p = new(KwTruncateContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwTruncate

	return p
}

func (s *KwTruncateContext) GetParser() antlr.Parser { return s.parser }

func (s *KwTruncateContext) K_TRUNCATE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_TRUNCATE, 0)
}

func (s *KwTruncateContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwTruncateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwTruncateContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwTruncate(s)
	}
}

func (s *KwTruncateContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwTruncate(s)
	}
}

func (p *CqlParser) KwTruncate() (localctx IKwTruncateContext) {
	this := p
	_ = this

	localctx = NewKwTruncateContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 510, CqlParserRULE_kwTruncate)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2279)
		p.Match(CqlParserK_TRUNCATE)
	}

	return localctx
}

// IKwTtlContext is an interface to support dynamic dispatch.
type IKwTtlContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwTtlContext differentiates from other interfaces.
	IsKwTtlContext()
}

type KwTtlContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwTtlContext() *KwTtlContext {
	var p = new(KwTtlContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwTtl
	return p
}

func (*KwTtlContext) IsKwTtlContext() {}

func NewKwTtlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwTtlContext {
	var p = new(KwTtlContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwTtl

	return p
}

func (s *KwTtlContext) GetParser() antlr.Parser { return s.parser }

func (s *KwTtlContext) K_TTL() antlr.TerminalNode {
	return s.GetToken(CqlParserK_TTL, 0)
}

func (s *KwTtlContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwTtlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwTtlContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwTtl(s)
	}
}

func (s *KwTtlContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwTtl(s)
	}
}

func (p *CqlParser) KwTtl() (localctx IKwTtlContext) {
	this := p
	_ = this

	localctx = NewKwTtlContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 512, CqlParserRULE_kwTtl)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2281)
		p.Match(CqlParserK_TTL)
	}

	return localctx
}

// IKwTypeContext is an interface to support dynamic dispatch.
type IKwTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwTypeContext differentiates from other interfaces.
	IsKwTypeContext()
}

type KwTypeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwTypeContext() *KwTypeContext {
	var p = new(KwTypeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwType
	return p
}

func (*KwTypeContext) IsKwTypeContext() {}

func NewKwTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwTypeContext {
	var p = new(KwTypeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwType

	return p
}

func (s *KwTypeContext) GetParser() antlr.Parser { return s.parser }

func (s *KwTypeContext) K_TYPE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_TYPE, 0)
}

func (s *KwTypeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwTypeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwType(s)
	}
}

func (s *KwTypeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwType(s)
	}
}

func (p *CqlParser) KwType() (localctx IKwTypeContext) {
	this := p
	_ = this

	localctx = NewKwTypeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 514, CqlParserRULE_kwType)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2283)
		p.Match(CqlParserK_TYPE)
	}

	return localctx
}

// IKwUnloggedContext is an interface to support dynamic dispatch.
type IKwUnloggedContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwUnloggedContext differentiates from other interfaces.
	IsKwUnloggedContext()
}

type KwUnloggedContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwUnloggedContext() *KwUnloggedContext {
	var p = new(KwUnloggedContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwUnlogged
	return p
}

func (*KwUnloggedContext) IsKwUnloggedContext() {}

func NewKwUnloggedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwUnloggedContext {
	var p = new(KwUnloggedContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwUnlogged

	return p
}

func (s *KwUnloggedContext) GetParser() antlr.Parser { return s.parser }

func (s *KwUnloggedContext) K_UNLOGGED() antlr.TerminalNode {
	return s.GetToken(CqlParserK_UNLOGGED, 0)
}

func (s *KwUnloggedContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwUnloggedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwUnloggedContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwUnlogged(s)
	}
}

func (s *KwUnloggedContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwUnlogged(s)
	}
}

func (p *CqlParser) KwUnlogged() (localctx IKwUnloggedContext) {
	this := p
	_ = this

	localctx = NewKwUnloggedContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 516, CqlParserRULE_kwUnlogged)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2285)
		p.Match(CqlParserK_UNLOGGED)
	}

	return localctx
}

// IKwUpdateContext is an interface to support dynamic dispatch.
type IKwUpdateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwUpdateContext differentiates from other interfaces.
	IsKwUpdateContext()
}

type KwUpdateContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwUpdateContext() *KwUpdateContext {
	var p = new(KwUpdateContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwUpdate
	return p
}

func (*KwUpdateContext) IsKwUpdateContext() {}

func NewKwUpdateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwUpdateContext {
	var p = new(KwUpdateContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwUpdate

	return p
}

func (s *KwUpdateContext) GetParser() antlr.Parser { return s.parser }

func (s *KwUpdateContext) K_UPDATE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_UPDATE, 0)
}

func (s *KwUpdateContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwUpdateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwUpdateContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwUpdate(s)
	}
}

func (s *KwUpdateContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwUpdate(s)
	}
}

func (p *CqlParser) KwUpdate() (localctx IKwUpdateContext) {
	this := p
	_ = this

	localctx = NewKwUpdateContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 518, CqlParserRULE_kwUpdate)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2287)
		p.Match(CqlParserK_UPDATE)
	}

	return localctx
}

// IKwUseContext is an interface to support dynamic dispatch.
type IKwUseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwUseContext differentiates from other interfaces.
	IsKwUseContext()
}

type KwUseContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwUseContext() *KwUseContext {
	var p = new(KwUseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwUse
	return p
}

func (*KwUseContext) IsKwUseContext() {}

func NewKwUseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwUseContext {
	var p = new(KwUseContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwUse

	return p
}

func (s *KwUseContext) GetParser() antlr.Parser { return s.parser }

func (s *KwUseContext) K_USE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_USE, 0)
}

func (s *KwUseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwUseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwUseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwUse(s)
	}
}

func (s *KwUseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwUse(s)
	}
}

func (p *CqlParser) KwUse() (localctx IKwUseContext) {
	this := p
	_ = this

	localctx = NewKwUseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 520, CqlParserRULE_kwUse)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2289)
		p.Match(CqlParserK_USE)
	}

	return localctx
}

// IKwUserContext is an interface to support dynamic dispatch.
type IKwUserContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwUserContext differentiates from other interfaces.
	IsKwUserContext()
}

type KwUserContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwUserContext() *KwUserContext {
	var p = new(KwUserContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwUser
	return p
}

func (*KwUserContext) IsKwUserContext() {}

func NewKwUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwUserContext {
	var p = new(KwUserContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwUser

	return p
}

func (s *KwUserContext) GetParser() antlr.Parser { return s.parser }

func (s *KwUserContext) K_USER() antlr.TerminalNode {
	return s.GetToken(CqlParserK_USER, 0)
}

func (s *KwUserContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwUserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwUserContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwUser(s)
	}
}

func (s *KwUserContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwUser(s)
	}
}

func (p *CqlParser) KwUser() (localctx IKwUserContext) {
	this := p
	_ = this

	localctx = NewKwUserContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 522, CqlParserRULE_kwUser)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2291)
		p.Match(CqlParserK_USER)
	}

	return localctx
}

// IKwUsersContext is an interface to support dynamic dispatch.
type IKwUsersContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwUsersContext differentiates from other interfaces.
	IsKwUsersContext()
}

type KwUsersContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwUsersContext() *KwUsersContext {
	var p = new(KwUsersContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwUsers
	return p
}

func (*KwUsersContext) IsKwUsersContext() {}

func NewKwUsersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwUsersContext {
	var p = new(KwUsersContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwUsers

	return p
}

func (s *KwUsersContext) GetParser() antlr.Parser { return s.parser }

func (s *KwUsersContext) K_USERS() antlr.TerminalNode {
	return s.GetToken(CqlParserK_USERS, 0)
}

func (s *KwUsersContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwUsersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwUsersContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwUsers(s)
	}
}

func (s *KwUsersContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwUsers(s)
	}
}

func (p *CqlParser) KwUsers() (localctx IKwUsersContext) {
	this := p
	_ = this

	localctx = NewKwUsersContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 524, CqlParserRULE_kwUsers)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2293)
		p.Match(CqlParserK_USERS)
	}

	return localctx
}

// IKwUsingContext is an interface to support dynamic dispatch.
type IKwUsingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwUsingContext differentiates from other interfaces.
	IsKwUsingContext()
}

type KwUsingContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwUsingContext() *KwUsingContext {
	var p = new(KwUsingContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwUsing
	return p
}

func (*KwUsingContext) IsKwUsingContext() {}

func NewKwUsingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwUsingContext {
	var p = new(KwUsingContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwUsing

	return p
}

func (s *KwUsingContext) GetParser() antlr.Parser { return s.parser }

func (s *KwUsingContext) K_USING() antlr.TerminalNode {
	return s.GetToken(CqlParserK_USING, 0)
}

func (s *KwUsingContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwUsingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwUsingContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwUsing(s)
	}
}

func (s *KwUsingContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwUsing(s)
	}
}

func (p *CqlParser) KwUsing() (localctx IKwUsingContext) {
	this := p
	_ = this

	localctx = NewKwUsingContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 526, CqlParserRULE_kwUsing)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2295)
		p.Match(CqlParserK_USING)
	}

	return localctx
}

// IKwValuesContext is an interface to support dynamic dispatch.
type IKwValuesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwValuesContext differentiates from other interfaces.
	IsKwValuesContext()
}

type KwValuesContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwValuesContext() *KwValuesContext {
	var p = new(KwValuesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwValues
	return p
}

func (*KwValuesContext) IsKwValuesContext() {}

func NewKwValuesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwValuesContext {
	var p = new(KwValuesContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwValues

	return p
}

func (s *KwValuesContext) GetParser() antlr.Parser { return s.parser }

func (s *KwValuesContext) K_VALUES() antlr.TerminalNode {
	return s.GetToken(CqlParserK_VALUES, 0)
}

func (s *KwValuesContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwValuesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwValuesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwValues(s)
	}
}

func (s *KwValuesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwValues(s)
	}
}

func (p *CqlParser) KwValues() (localctx IKwValuesContext) {
	this := p
	_ = this

	localctx = NewKwValuesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 528, CqlParserRULE_kwValues)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2297)
		p.Match(CqlParserK_VALUES)
	}

	return localctx
}

// IKwViewContext is an interface to support dynamic dispatch.
type IKwViewContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwViewContext differentiates from other interfaces.
	IsKwViewContext()
}

type KwViewContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwViewContext() *KwViewContext {
	var p = new(KwViewContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwView
	return p
}

func (*KwViewContext) IsKwViewContext() {}

func NewKwViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwViewContext {
	var p = new(KwViewContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwView

	return p
}

func (s *KwViewContext) GetParser() antlr.Parser { return s.parser }

func (s *KwViewContext) K_VIEW() antlr.TerminalNode {
	return s.GetToken(CqlParserK_VIEW, 0)
}

func (s *KwViewContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwViewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwViewContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwView(s)
	}
}

func (s *KwViewContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwView(s)
	}
}

func (p *CqlParser) KwView() (localctx IKwViewContext) {
	this := p
	_ = this

	localctx = NewKwViewContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 530, CqlParserRULE_kwView)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2299)
		p.Match(CqlParserK_VIEW)
	}

	return localctx
}

// IKwWhereContext is an interface to support dynamic dispatch.
type IKwWhereContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwWhereContext differentiates from other interfaces.
	IsKwWhereContext()
}

type KwWhereContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwWhereContext() *KwWhereContext {
	var p = new(KwWhereContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwWhere
	return p
}

func (*KwWhereContext) IsKwWhereContext() {}

func NewKwWhereContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwWhereContext {
	var p = new(KwWhereContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwWhere

	return p
}

func (s *KwWhereContext) GetParser() antlr.Parser { return s.parser }

func (s *KwWhereContext) K_WHERE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_WHERE, 0)
}

func (s *KwWhereContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwWhereContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwWhereContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwWhere(s)
	}
}

func (s *KwWhereContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwWhere(s)
	}
}

func (p *CqlParser) KwWhere() (localctx IKwWhereContext) {
	this := p
	_ = this

	localctx = NewKwWhereContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 532, CqlParserRULE_kwWhere)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2301)
		p.Match(CqlParserK_WHERE)
	}

	return localctx
}

// IKwWithContext is an interface to support dynamic dispatch.
type IKwWithContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwWithContext differentiates from other interfaces.
	IsKwWithContext()
}

type KwWithContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwWithContext() *KwWithContext {
	var p = new(KwWithContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwWith
	return p
}

func (*KwWithContext) IsKwWithContext() {}

func NewKwWithContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwWithContext {
	var p = new(KwWithContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwWith

	return p
}

func (s *KwWithContext) GetParser() antlr.Parser { return s.parser }

func (s *KwWithContext) K_WITH() antlr.TerminalNode {
	return s.GetToken(CqlParserK_WITH, 0)
}

func (s *KwWithContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwWithContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwWithContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwWith(s)
	}
}

func (s *KwWithContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwWith(s)
	}
}

func (p *CqlParser) KwWith() (localctx IKwWithContext) {
	this := p
	_ = this

	localctx = NewKwWithContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 534, CqlParserRULE_kwWith)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2303)
		p.Match(CqlParserK_WITH)
	}

	return localctx
}

// IKwRevokeContext is an interface to support dynamic dispatch.
type IKwRevokeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKwRevokeContext differentiates from other interfaces.
	IsKwRevokeContext()
}

type KwRevokeContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKwRevokeContext() *KwRevokeContext {
	var p = new(KwRevokeContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_kwRevoke
	return p
}

func (*KwRevokeContext) IsKwRevokeContext() {}

func NewKwRevokeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwRevokeContext {
	var p = new(KwRevokeContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_kwRevoke

	return p
}

func (s *KwRevokeContext) GetParser() antlr.Parser { return s.parser }

func (s *KwRevokeContext) K_REVOKE() antlr.TerminalNode {
	return s.GetToken(CqlParserK_REVOKE, 0)
}

func (s *KwRevokeContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KwRevokeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *KwRevokeContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterKwRevoke(s)
	}
}

func (s *KwRevokeContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitKwRevoke(s)
	}
}

func (p *CqlParser) KwRevoke() (localctx IKwRevokeContext) {
	this := p
	_ = this

	localctx = NewKwRevokeContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 536, CqlParserRULE_kwRevoke)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2305)
		p.Match(CqlParserK_REVOKE)
	}

	return localctx
}

// IEofContext is an interface to support dynamic dispatch.
type IEofContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEofContext differentiates from other interfaces.
	IsEofContext()
}

type EofContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyEofContext() *EofContext {
	var p = new(EofContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_eof
	return p
}

func (*EofContext) IsEofContext() {}

func NewEofContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EofContext {
	var p = new(EofContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_eof

	return p
}

func (s *EofContext) GetParser() antlr.Parser { return s.parser }

func (s *EofContext) EOF() antlr.TerminalNode {
	return s.GetToken(CqlParserEOF, 0)
}

func (s *EofContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *EofContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *EofContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterEof(s)
	}
}

func (s *EofContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitEof(s)
	}
}

func (p *CqlParser) Eof() (localctx IEofContext) {
	this := p
	_ = this

	localctx = NewEofContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 538, CqlParserRULE_eof)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2307)
		p.Match(CqlParserEOF)
	}

	return localctx
}

// ISyntaxBracketLrContext is an interface to support dynamic dispatch.
type ISyntaxBracketLrContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSyntaxBracketLrContext differentiates from other interfaces.
	IsSyntaxBracketLrContext()
}

type SyntaxBracketLrContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySyntaxBracketLrContext() *SyntaxBracketLrContext {
	var p = new(SyntaxBracketLrContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_syntaxBracketLr
	return p
}

func (*SyntaxBracketLrContext) IsSyntaxBracketLrContext() {}

func NewSyntaxBracketLrContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketLrContext {
	var p = new(SyntaxBracketLrContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_syntaxBracketLr

	return p
}

func (s *SyntaxBracketLrContext) GetParser() antlr.Parser { return s.parser }

func (s *SyntaxBracketLrContext) LR_BRACKET() antlr.TerminalNode {
	return s.GetToken(CqlParserLR_BRACKET, 0)
}

func (s *SyntaxBracketLrContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SyntaxBracketLrContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SyntaxBracketLrContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterSyntaxBracketLr(s)
	}
}

func (s *SyntaxBracketLrContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitSyntaxBracketLr(s)
	}
}

func (p *CqlParser) SyntaxBracketLr() (localctx ISyntaxBracketLrContext) {
	this := p
	_ = this

	localctx = NewSyntaxBracketLrContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 540, CqlParserRULE_syntaxBracketLr)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2309)
		p.Match(CqlParserLR_BRACKET)
	}

	return localctx
}

// ISyntaxBracketRrContext is an interface to support dynamic dispatch.
type ISyntaxBracketRrContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSyntaxBracketRrContext differentiates from other interfaces.
	IsSyntaxBracketRrContext()
}

type SyntaxBracketRrContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySyntaxBracketRrContext() *SyntaxBracketRrContext {
	var p = new(SyntaxBracketRrContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_syntaxBracketRr
	return p
}

func (*SyntaxBracketRrContext) IsSyntaxBracketRrContext() {}

func NewSyntaxBracketRrContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketRrContext {
	var p = new(SyntaxBracketRrContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_syntaxBracketRr

	return p
}

func (s *SyntaxBracketRrContext) GetParser() antlr.Parser { return s.parser }

func (s *SyntaxBracketRrContext) RR_BRACKET() antlr.TerminalNode {
	return s.GetToken(CqlParserRR_BRACKET, 0)
}

func (s *SyntaxBracketRrContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SyntaxBracketRrContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SyntaxBracketRrContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterSyntaxBracketRr(s)
	}
}

func (s *SyntaxBracketRrContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitSyntaxBracketRr(s)
	}
}

func (p *CqlParser) SyntaxBracketRr() (localctx ISyntaxBracketRrContext) {
	this := p
	_ = this

	localctx = NewSyntaxBracketRrContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 542, CqlParserRULE_syntaxBracketRr)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2311)
		p.Match(CqlParserRR_BRACKET)
	}

	return localctx
}

// ISyntaxBracketLcContext is an interface to support dynamic dispatch.
type ISyntaxBracketLcContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSyntaxBracketLcContext differentiates from other interfaces.
	IsSyntaxBracketLcContext()
}

type SyntaxBracketLcContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySyntaxBracketLcContext() *SyntaxBracketLcContext {
	var p = new(SyntaxBracketLcContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_syntaxBracketLc
	return p
}

func (*SyntaxBracketLcContext) IsSyntaxBracketLcContext() {}

func NewSyntaxBracketLcContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketLcContext {
	var p = new(SyntaxBracketLcContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_syntaxBracketLc

	return p
}

func (s *SyntaxBracketLcContext) GetParser() antlr.Parser { return s.parser }

func (s *SyntaxBracketLcContext) LC_BRACKET() antlr.TerminalNode {
	return s.GetToken(CqlParserLC_BRACKET, 0)
}

func (s *SyntaxBracketLcContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SyntaxBracketLcContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SyntaxBracketLcContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterSyntaxBracketLc(s)
	}
}

func (s *SyntaxBracketLcContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitSyntaxBracketLc(s)
	}
}

func (p *CqlParser) SyntaxBracketLc() (localctx ISyntaxBracketLcContext) {
	this := p
	_ = this

	localctx = NewSyntaxBracketLcContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 544, CqlParserRULE_syntaxBracketLc)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2313)
		p.Match(CqlParserLC_BRACKET)
	}

	return localctx
}

// ISyntaxBracketRcContext is an interface to support dynamic dispatch.
type ISyntaxBracketRcContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSyntaxBracketRcContext differentiates from other interfaces.
	IsSyntaxBracketRcContext()
}

type SyntaxBracketRcContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySyntaxBracketRcContext() *SyntaxBracketRcContext {
	var p = new(SyntaxBracketRcContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_syntaxBracketRc
	return p
}

func (*SyntaxBracketRcContext) IsSyntaxBracketRcContext() {}

func NewSyntaxBracketRcContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketRcContext {
	var p = new(SyntaxBracketRcContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_syntaxBracketRc

	return p
}

func (s *SyntaxBracketRcContext) GetParser() antlr.Parser { return s.parser }

func (s *SyntaxBracketRcContext) RC_BRACKET() antlr.TerminalNode {
	return s.GetToken(CqlParserRC_BRACKET, 0)
}

func (s *SyntaxBracketRcContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SyntaxBracketRcContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SyntaxBracketRcContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterSyntaxBracketRc(s)
	}
}

func (s *SyntaxBracketRcContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitSyntaxBracketRc(s)
	}
}

func (p *CqlParser) SyntaxBracketRc() (localctx ISyntaxBracketRcContext) {
	this := p
	_ = this

	localctx = NewSyntaxBracketRcContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 546, CqlParserRULE_syntaxBracketRc)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2315)
		p.Match(CqlParserRC_BRACKET)
	}

	return localctx
}

// ISyntaxBracketLaContext is an interface to support dynamic dispatch.
type ISyntaxBracketLaContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSyntaxBracketLaContext differentiates from other interfaces.
	IsSyntaxBracketLaContext()
}

type SyntaxBracketLaContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySyntaxBracketLaContext() *SyntaxBracketLaContext {
	var p = new(SyntaxBracketLaContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_syntaxBracketLa
	return p
}

func (*SyntaxBracketLaContext) IsSyntaxBracketLaContext() {}

func NewSyntaxBracketLaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketLaContext {
	var p = new(SyntaxBracketLaContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_syntaxBracketLa

	return p
}

func (s *SyntaxBracketLaContext) GetParser() antlr.Parser { return s.parser }

func (s *SyntaxBracketLaContext) OPERATOR_LT() antlr.TerminalNode {
	return s.GetToken(CqlParserOPERATOR_LT, 0)
}

func (s *SyntaxBracketLaContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SyntaxBracketLaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SyntaxBracketLaContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterSyntaxBracketLa(s)
	}
}

func (s *SyntaxBracketLaContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitSyntaxBracketLa(s)
	}
}

func (p *CqlParser) SyntaxBracketLa() (localctx ISyntaxBracketLaContext) {
	this := p
	_ = this

	localctx = NewSyntaxBracketLaContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 548, CqlParserRULE_syntaxBracketLa)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2317)
		p.Match(CqlParserOPERATOR_LT)
	}

	return localctx
}

// ISyntaxBracketRaContext is an interface to support dynamic dispatch.
type ISyntaxBracketRaContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSyntaxBracketRaContext differentiates from other interfaces.
	IsSyntaxBracketRaContext()
}

type SyntaxBracketRaContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySyntaxBracketRaContext() *SyntaxBracketRaContext {
	var p = new(SyntaxBracketRaContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_syntaxBracketRa
	return p
}

func (*SyntaxBracketRaContext) IsSyntaxBracketRaContext() {}

func NewSyntaxBracketRaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketRaContext {
	var p = new(SyntaxBracketRaContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_syntaxBracketRa

	return p
}

func (s *SyntaxBracketRaContext) GetParser() antlr.Parser { return s.parser }

func (s *SyntaxBracketRaContext) OPERATOR_GT() antlr.TerminalNode {
	return s.GetToken(CqlParserOPERATOR_GT, 0)
}

func (s *SyntaxBracketRaContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SyntaxBracketRaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SyntaxBracketRaContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterSyntaxBracketRa(s)
	}
}

func (s *SyntaxBracketRaContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitSyntaxBracketRa(s)
	}
}

func (p *CqlParser) SyntaxBracketRa() (localctx ISyntaxBracketRaContext) {
	this := p
	_ = this

	localctx = NewSyntaxBracketRaContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 550, CqlParserRULE_syntaxBracketRa)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2319)
		p.Match(CqlParserOPERATOR_GT)
	}

	return localctx
}

// ISyntaxBracketLsContext is an interface to support dynamic dispatch.
type ISyntaxBracketLsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSyntaxBracketLsContext differentiates from other interfaces.
	IsSyntaxBracketLsContext()
}

type SyntaxBracketLsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySyntaxBracketLsContext() *SyntaxBracketLsContext {
	var p = new(SyntaxBracketLsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_syntaxBracketLs
	return p
}

func (*SyntaxBracketLsContext) IsSyntaxBracketLsContext() {}

func NewSyntaxBracketLsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketLsContext {
	var p = new(SyntaxBracketLsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_syntaxBracketLs

	return p
}

func (s *SyntaxBracketLsContext) GetParser() antlr.Parser { return s.parser }

func (s *SyntaxBracketLsContext) LS_BRACKET() antlr.TerminalNode {
	return s.GetToken(CqlParserLS_BRACKET, 0)
}

func (s *SyntaxBracketLsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SyntaxBracketLsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SyntaxBracketLsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterSyntaxBracketLs(s)
	}
}

func (s *SyntaxBracketLsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitSyntaxBracketLs(s)
	}
}

func (p *CqlParser) SyntaxBracketLs() (localctx ISyntaxBracketLsContext) {
	this := p
	_ = this

	localctx = NewSyntaxBracketLsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 552, CqlParserRULE_syntaxBracketLs)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2321)
		p.Match(CqlParserLS_BRACKET)
	}

	return localctx
}

// ISyntaxBracketRsContext is an interface to support dynamic dispatch.
type ISyntaxBracketRsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSyntaxBracketRsContext differentiates from other interfaces.
	IsSyntaxBracketRsContext()
}

type SyntaxBracketRsContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySyntaxBracketRsContext() *SyntaxBracketRsContext {
	var p = new(SyntaxBracketRsContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_syntaxBracketRs
	return p
}

func (*SyntaxBracketRsContext) IsSyntaxBracketRsContext() {}

func NewSyntaxBracketRsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketRsContext {
	var p = new(SyntaxBracketRsContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_syntaxBracketRs

	return p
}

func (s *SyntaxBracketRsContext) GetParser() antlr.Parser { return s.parser }

func (s *SyntaxBracketRsContext) RS_BRACKET() antlr.TerminalNode {
	return s.GetToken(CqlParserRS_BRACKET, 0)
}

func (s *SyntaxBracketRsContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SyntaxBracketRsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SyntaxBracketRsContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterSyntaxBracketRs(s)
	}
}

func (s *SyntaxBracketRsContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitSyntaxBracketRs(s)
	}
}

func (p *CqlParser) SyntaxBracketRs() (localctx ISyntaxBracketRsContext) {
	this := p
	_ = this

	localctx = NewSyntaxBracketRsContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 554, CqlParserRULE_syntaxBracketRs)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2323)
		p.Match(CqlParserRS_BRACKET)
	}

	return localctx
}

// ISyntaxCommaContext is an interface to support dynamic dispatch.
type ISyntaxCommaContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSyntaxCommaContext differentiates from other interfaces.
	IsSyntaxCommaContext()
}

type SyntaxCommaContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySyntaxCommaContext() *SyntaxCommaContext {
	var p = new(SyntaxCommaContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_syntaxComma
	return p
}

func (*SyntaxCommaContext) IsSyntaxCommaContext() {}

func NewSyntaxCommaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxCommaContext {
	var p = new(SyntaxCommaContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_syntaxComma

	return p
}

func (s *SyntaxCommaContext) GetParser() antlr.Parser { return s.parser }

func (s *SyntaxCommaContext) COMMA() antlr.TerminalNode {
	return s.GetToken(CqlParserCOMMA, 0)
}

func (s *SyntaxCommaContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SyntaxCommaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SyntaxCommaContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterSyntaxComma(s)
	}
}

func (s *SyntaxCommaContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitSyntaxComma(s)
	}
}

func (p *CqlParser) SyntaxComma() (localctx ISyntaxCommaContext) {
	this := p
	_ = this

	localctx = NewSyntaxCommaContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 556, CqlParserRULE_syntaxComma)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2325)
		p.Match(CqlParserCOMMA)
	}

	return localctx
}

// ISyntaxColonContext is an interface to support dynamic dispatch.
type ISyntaxColonContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSyntaxColonContext differentiates from other interfaces.
	IsSyntaxColonContext()
}

type SyntaxColonContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySyntaxColonContext() *SyntaxColonContext {
	var p = new(SyntaxColonContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = CqlParserRULE_syntaxColon
	return p
}

func (*SyntaxColonContext) IsSyntaxColonContext() {}

func NewSyntaxColonContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxColonContext {
	var p = new(SyntaxColonContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = CqlParserRULE_syntaxColon

	return p
}

func (s *SyntaxColonContext) GetParser() antlr.Parser { return s.parser }

func (s *SyntaxColonContext) COLON() antlr.TerminalNode {
	return s.GetToken(CqlParserCOLON, 0)
}

func (s *SyntaxColonContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *SyntaxColonContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *SyntaxColonContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.EnterSyntaxColon(s)
	}
}

func (s *SyntaxColonContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(CqlParserListener); ok {
		listenerT.ExitSyntaxColon(s)
	}
}

func (p *CqlParser) SyntaxColon() (localctx ISyntaxColonContext) {
	this := p
	_ = this

	localctx = NewSyntaxColonContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 558, CqlParserRULE_syntaxColon)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2327)
		p.Match(CqlParserCOLON)
	}

	return localctx
}
