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

package parser // Sql

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

var literalNames = []string{
	"", "'::'", "';'", "'.'", "'('", "')'", "','", "'='", "'*'", "'+'", "'-'", 
	"'~'", "'||'", "'/'", "'%'", "'<<'", "'>>'", "'&'", "'|'", "'<'", "'<='", 
	"'>'", "'>='", "'=='", "'!='", "'<>'",
}
var symbolicNames = []string{
	"", "", "SCOL", "DOT", "OPEN_PAR", "CLOSE_PAR", "COMMA", "ASSIGN", "STAR", 
	"PLUS", "MINUS", "TILDE", "PIPE2", "DIV", "MOD", "LT2", "GT2", "AMP", "PIPE", 
	"LT", "LT_EQ", "GT", "GT_EQ", "EQ", "NOT_EQ1", "NOT_EQ2", "K_ABORT", "K_ACTION", 
	"K_ADD", "K_AFTER", "K_ALL", "K_ALTER", "K_ANALYZE", "K_AND", "K_AS", "K_ASC", 
	"K_ATTACH", "K_AUTOINCREMENT", "K_BEFORE", "K_BEGIN", "K_BETWEEN", "K_BY", 
	"K_CASCADE", "K_CASE", "K_CAST", "K_CHECK", "K_COLLATE", "K_COLUMN", "K_COMMIT", 
	"K_CONFLICT", "K_CONSTRAINT", "K_CREATE", "K_CROSS", "K_CURRENT_DATE", 
	"K_CURRENT_TIME", "K_CURRENT_TIMESTAMP", "K_DATABASE", "K_DEFAULT", "K_DEFERRABLE", 
	"K_DEFERRED", "K_DELETE", "K_DESC", "K_DETACH", "K_DISTINCT", "K_DROP", 
	"K_EACH", "K_ELSE", "K_END", "K_ENABLE", "K_DISABLE", "K_NOVALIDATE", "K_ESCAPE", 
	"K_EXCEPT", "K_EXCLUSIVE", "K_EXISTS", "K_EXPLAIN", "K_FAIL", "K_FOR", 
	"K_FOREIGN", "K_FROM", "K_FULL", "K_GLOB", "K_GROUP", "K_HAVING", "K_IF", 
	"K_IGNORE", "K_IMMEDIATE", "K_IN", "K_INDEX", "K_INDEXED", "K_INITIALLY", 
	"K_INNER", "K_INSERT", "K_INSTEAD", "K_INTERSECT", "K_INTO", "K_IS", "K_ISNULL", 
	"K_JOIN", "K_KEY", "K_LEFT", "K_LIKE", "K_LIMIT", "K_MATCH", "K_NATURAL", 
	"K_NEXTVAL", "K_NO", "K_NOT", "K_NOTNULL", "K_NULL", "K_OF", "K_OFFSET", 
	"K_ON", "K_ONLY", "K_OR", "K_ORDER", "K_OUTER", "K_PLAN", "K_PRAGMA", "K_PRIMARY", 
	"K_QUERY", "K_RAISE", "K_RECURSIVE", "K_REFERENCES", "K_REGEXP", "K_REINDEX", 
	"K_RELEASE", "K_RENAME", "K_REPLACE", "K_RESTRICT", "K_RIGHT", "K_ROLLBACK", 
	"K_ROW", "K_SAVEPOINT", "K_SELECT", "K_SET", "K_TABLE", "K_TEMP", "K_TEMPORARY", 
	"K_THEN", "K_TO", "K_TRANSACTION", "K_TRIGGER", "K_UNION", "K_UNIQUE", 
	"K_UPDATE", "K_USING", "K_VACUUM", "K_VALUES", "K_VIEW", "K_FORCE", "K_VIRTUAL", 
	"K_WHEN", "K_WHERE", "K_WITH", "K_WITHOUT", "IDENTIFIER", "NUMERIC_LITERAL", 
	"BIND_PARAMETER", "STRING_LITERAL", "BLOB_LITERAL", "SINGLE_LINE_COMMENT", 
	"MULTILINE_COMMENT", "SPACES", "UNEXPECTED_CHAR",
}

var ruleNames = []string{
	"parse", "error", "sql_stmt_list", "sql_stmt", "alter_table_stmt", "alter_table_add_constraint", 
	"alter_table_add", "analyze_stmt", "attach_stmt", "begin_stmt", "commit_stmt", 
	"compound_select_stmt", "create_index_stmt", "create_table_stmt", "create_trigger_stmt", 
	"create_view_stmt", "create_force_view_stmt", "create_virtual_table_stmt", 
	"delete_stmt", "delete_stmt_limited", "detach_stmt", "drop_index_stmt", 
	"drop_table_stmt", "drop_trigger_stmt", "drop_view_stmt", "factored_select_stmt", 
	"insert_stmt", "pragma_stmt", "reindex_stmt", "release_stmt", "rollback_stmt", 
	"savepoint_stmt", "simple_select_stmt", "select_stmt", "select_or_values", 
	"update_stmt", "update_stmt_limited", "vacuum_stmt", "column_def", "type_name", 
	"column_constraint", "column_constraint_primary_key", "column_constraint_foreign_key", 
	"column_constraint_not_null", "column_constraint_null", "column_default", 
	"column_default_value", "conflict_clause", "expr", "foreign_key_clause", 
	"fk_target_column_name", "raise_function", "indexed_column", "table_constraint", 
	"table_constraint_primary_key", "table_constraint_foreign_key", "table_constraint_unique", 
	"table_constraint_key", "fk_origin_column_name", "with_clause", "qualified_table_name", 
	"ordering_term", "pragma_value", "common_table_expression", "result_column", 
	"table_or_subquery", "join_clause", "join_operator", "join_constraint", 
	"select_core", "compound_operator", "cte_table_name", "signed_number", 
	"literal_value", "unary_operator", "error_message", "module_argument", 
	"column_alias", "keyword", "unknown", "name", "function_name", "database_name", 
	"source_table_name", "table_name", "table_or_index_name", "new_table_name", 
	"column_name", "collation_name", "foreign_table", "index_name", "trigger_name", 
	"view_name", "module_name", "pragma_name", "savepoint_name", "table_alias", 
	"transaction_name", "any_name",
}
var decisionToDFA = make([]*antlr.DFA, len(deserializedATN.DecisionToState))

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

type SqlParser struct {
	*antlr.BaseParser
}

func NewSqlParser(input antlr.TokenStream) *SqlParser {
	this := new(SqlParser)

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

	return this
}

// SqlParser tokens.
const (
	SqlParserEOF = antlr.TokenEOF
	SqlParserT__0 = 1
	SqlParserSCOL = 2
	SqlParserDOT = 3
	SqlParserOPEN_PAR = 4
	SqlParserCLOSE_PAR = 5
	SqlParserCOMMA = 6
	SqlParserASSIGN = 7
	SqlParserSTAR = 8
	SqlParserPLUS = 9
	SqlParserMINUS = 10
	SqlParserTILDE = 11
	SqlParserPIPE2 = 12
	SqlParserDIV = 13
	SqlParserMOD = 14
	SqlParserLT2 = 15
	SqlParserGT2 = 16
	SqlParserAMP = 17
	SqlParserPIPE = 18
	SqlParserLT = 19
	SqlParserLT_EQ = 20
	SqlParserGT = 21
	SqlParserGT_EQ = 22
	SqlParserEQ = 23
	SqlParserNOT_EQ1 = 24
	SqlParserNOT_EQ2 = 25
	SqlParserK_ABORT = 26
	SqlParserK_ACTION = 27
	SqlParserK_ADD = 28
	SqlParserK_AFTER = 29
	SqlParserK_ALL = 30
	SqlParserK_ALTER = 31
	SqlParserK_ANALYZE = 32
	SqlParserK_AND = 33
	SqlParserK_AS = 34
	SqlParserK_ASC = 35
	SqlParserK_ATTACH = 36
	SqlParserK_AUTOINCREMENT = 37
	SqlParserK_BEFORE = 38
	SqlParserK_BEGIN = 39
	SqlParserK_BETWEEN = 40
	SqlParserK_BY = 41
	SqlParserK_CASCADE = 42
	SqlParserK_CASE = 43
	SqlParserK_CAST = 44
	SqlParserK_CHECK = 45
	SqlParserK_COLLATE = 46
	SqlParserK_COLUMN = 47
	SqlParserK_COMMIT = 48
	SqlParserK_CONFLICT = 49
	SqlParserK_CONSTRAINT = 50
	SqlParserK_CREATE = 51
	SqlParserK_CROSS = 52
	SqlParserK_CURRENT_DATE = 53
	SqlParserK_CURRENT_TIME = 54
	SqlParserK_CURRENT_TIMESTAMP = 55
	SqlParserK_DATABASE = 56
	SqlParserK_DEFAULT = 57
	SqlParserK_DEFERRABLE = 58
	SqlParserK_DEFERRED = 59
	SqlParserK_DELETE = 60
	SqlParserK_DESC = 61
	SqlParserK_DETACH = 62
	SqlParserK_DISTINCT = 63
	SqlParserK_DROP = 64
	SqlParserK_EACH = 65
	SqlParserK_ELSE = 66
	SqlParserK_END = 67
	SqlParserK_ENABLE = 68
	SqlParserK_DISABLE = 69
	SqlParserK_NOVALIDATE = 70
	SqlParserK_ESCAPE = 71
	SqlParserK_EXCEPT = 72
	SqlParserK_EXCLUSIVE = 73
	SqlParserK_EXISTS = 74
	SqlParserK_EXPLAIN = 75
	SqlParserK_FAIL = 76
	SqlParserK_FOR = 77
	SqlParserK_FOREIGN = 78
	SqlParserK_FROM = 79
	SqlParserK_FULL = 80
	SqlParserK_GLOB = 81
	SqlParserK_GROUP = 82
	SqlParserK_HAVING = 83
	SqlParserK_IF = 84
	SqlParserK_IGNORE = 85
	SqlParserK_IMMEDIATE = 86
	SqlParserK_IN = 87
	SqlParserK_INDEX = 88
	SqlParserK_INDEXED = 89
	SqlParserK_INITIALLY = 90
	SqlParserK_INNER = 91
	SqlParserK_INSERT = 92
	SqlParserK_INSTEAD = 93
	SqlParserK_INTERSECT = 94
	SqlParserK_INTO = 95
	SqlParserK_IS = 96
	SqlParserK_ISNULL = 97
	SqlParserK_JOIN = 98
	SqlParserK_KEY = 99
	SqlParserK_LEFT = 100
	SqlParserK_LIKE = 101
	SqlParserK_LIMIT = 102
	SqlParserK_MATCH = 103
	SqlParserK_NATURAL = 104
	SqlParserK_NEXTVAL = 105
	SqlParserK_NO = 106
	SqlParserK_NOT = 107
	SqlParserK_NOTNULL = 108
	SqlParserK_NULL = 109
	SqlParserK_OF = 110
	SqlParserK_OFFSET = 111
	SqlParserK_ON = 112
	SqlParserK_ONLY = 113
	SqlParserK_OR = 114
	SqlParserK_ORDER = 115
	SqlParserK_OUTER = 116
	SqlParserK_PLAN = 117
	SqlParserK_PRAGMA = 118
	SqlParserK_PRIMARY = 119
	SqlParserK_QUERY = 120
	SqlParserK_RAISE = 121
	SqlParserK_RECURSIVE = 122
	SqlParserK_REFERENCES = 123
	SqlParserK_REGEXP = 124
	SqlParserK_REINDEX = 125
	SqlParserK_RELEASE = 126
	SqlParserK_RENAME = 127
	SqlParserK_REPLACE = 128
	SqlParserK_RESTRICT = 129
	SqlParserK_RIGHT = 130
	SqlParserK_ROLLBACK = 131
	SqlParserK_ROW = 132
	SqlParserK_SAVEPOINT = 133
	SqlParserK_SELECT = 134
	SqlParserK_SET = 135
	SqlParserK_TABLE = 136
	SqlParserK_TEMP = 137
	SqlParserK_TEMPORARY = 138
	SqlParserK_THEN = 139
	SqlParserK_TO = 140
	SqlParserK_TRANSACTION = 141
	SqlParserK_TRIGGER = 142
	SqlParserK_UNION = 143
	SqlParserK_UNIQUE = 144
	SqlParserK_UPDATE = 145
	SqlParserK_USING = 146
	SqlParserK_VACUUM = 147
	SqlParserK_VALUES = 148
	SqlParserK_VIEW = 149
	SqlParserK_FORCE = 150
	SqlParserK_VIRTUAL = 151
	SqlParserK_WHEN = 152
	SqlParserK_WHERE = 153
	SqlParserK_WITH = 154
	SqlParserK_WITHOUT = 155
	SqlParserIDENTIFIER = 156
	SqlParserNUMERIC_LITERAL = 157
	SqlParserBIND_PARAMETER = 158
	SqlParserSTRING_LITERAL = 159
	SqlParserBLOB_LITERAL = 160
	SqlParserSINGLE_LINE_COMMENT = 161
	SqlParserMULTILINE_COMMENT = 162
	SqlParserSPACES = 163
	SqlParserUNEXPECTED_CHAR = 164
)

// SqlParser rules.
const (
	SqlParserRULE_parse = 0
	SqlParserRULE_error = 1
	SqlParserRULE_sql_stmt_list = 2
	SqlParserRULE_sql_stmt = 3
	SqlParserRULE_alter_table_stmt = 4
	SqlParserRULE_alter_table_add_constraint = 5
	SqlParserRULE_alter_table_add = 6
	SqlParserRULE_analyze_stmt = 7
	SqlParserRULE_attach_stmt = 8
	SqlParserRULE_begin_stmt = 9
	SqlParserRULE_commit_stmt = 10
	SqlParserRULE_compound_select_stmt = 11
	SqlParserRULE_create_index_stmt = 12
	SqlParserRULE_create_table_stmt = 13
	SqlParserRULE_create_trigger_stmt = 14
	SqlParserRULE_create_view_stmt = 15
	SqlParserRULE_create_force_view_stmt = 16
	SqlParserRULE_create_virtual_table_stmt = 17
	SqlParserRULE_delete_stmt = 18
	SqlParserRULE_delete_stmt_limited = 19
	SqlParserRULE_detach_stmt = 20
	SqlParserRULE_drop_index_stmt = 21
	SqlParserRULE_drop_table_stmt = 22
	SqlParserRULE_drop_trigger_stmt = 23
	SqlParserRULE_drop_view_stmt = 24
	SqlParserRULE_factored_select_stmt = 25
	SqlParserRULE_insert_stmt = 26
	SqlParserRULE_pragma_stmt = 27
	SqlParserRULE_reindex_stmt = 28
	SqlParserRULE_release_stmt = 29
	SqlParserRULE_rollback_stmt = 30
	SqlParserRULE_savepoint_stmt = 31
	SqlParserRULE_simple_select_stmt = 32
	SqlParserRULE_select_stmt = 33
	SqlParserRULE_select_or_values = 34
	SqlParserRULE_update_stmt = 35
	SqlParserRULE_update_stmt_limited = 36
	SqlParserRULE_vacuum_stmt = 37
	SqlParserRULE_column_def = 38
	SqlParserRULE_type_name = 39
	SqlParserRULE_column_constraint = 40
	SqlParserRULE_column_constraint_primary_key = 41
	SqlParserRULE_column_constraint_foreign_key = 42
	SqlParserRULE_column_constraint_not_null = 43
	SqlParserRULE_column_constraint_null = 44
	SqlParserRULE_column_default = 45
	SqlParserRULE_column_default_value = 46
	SqlParserRULE_conflict_clause = 47
	SqlParserRULE_expr = 48
	SqlParserRULE_foreign_key_clause = 49
	SqlParserRULE_fk_target_column_name = 50
	SqlParserRULE_raise_function = 51
	SqlParserRULE_indexed_column = 52
	SqlParserRULE_table_constraint = 53
	SqlParserRULE_table_constraint_primary_key = 54
	SqlParserRULE_table_constraint_foreign_key = 55
	SqlParserRULE_table_constraint_unique = 56
	SqlParserRULE_table_constraint_key = 57
	SqlParserRULE_fk_origin_column_name = 58
	SqlParserRULE_with_clause = 59
	SqlParserRULE_qualified_table_name = 60
	SqlParserRULE_ordering_term = 61
	SqlParserRULE_pragma_value = 62
	SqlParserRULE_common_table_expression = 63
	SqlParserRULE_result_column = 64
	SqlParserRULE_table_or_subquery = 65
	SqlParserRULE_join_clause = 66
	SqlParserRULE_join_operator = 67
	SqlParserRULE_join_constraint = 68
	SqlParserRULE_select_core = 69
	SqlParserRULE_compound_operator = 70
	SqlParserRULE_cte_table_name = 71
	SqlParserRULE_signed_number = 72
	SqlParserRULE_literal_value = 73
	SqlParserRULE_unary_operator = 74
	SqlParserRULE_error_message = 75
	SqlParserRULE_module_argument = 76
	SqlParserRULE_column_alias = 77
	SqlParserRULE_keyword = 78
	SqlParserRULE_unknown = 79
	SqlParserRULE_name = 80
	SqlParserRULE_function_name = 81
	SqlParserRULE_database_name = 82
	SqlParserRULE_source_table_name = 83
	SqlParserRULE_table_name = 84
	SqlParserRULE_table_or_index_name = 85
	SqlParserRULE_new_table_name = 86
	SqlParserRULE_column_name = 87
	SqlParserRULE_collation_name = 88
	SqlParserRULE_foreign_table = 89
	SqlParserRULE_index_name = 90
	SqlParserRULE_trigger_name = 91
	SqlParserRULE_view_name = 92
	SqlParserRULE_module_name = 93
	SqlParserRULE_pragma_name = 94
	SqlParserRULE_savepoint_name = 95
	SqlParserRULE_table_alias = 96
	SqlParserRULE_transaction_name = 97
	SqlParserRULE_any_name = 98
)

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

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

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

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

func NewEmptyParseContext() *ParseContext {
	var p = new(ParseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_parse
	return p
}

func (*ParseContext) IsParseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_parse

	return p
}

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

func (s *ParseContext) EOF() antlr.TerminalNode {
	return s.GetToken(SqlParserEOF, 0)
}

func (s *ParseContext) AllSql_stmt_list() []ISql_stmt_listContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISql_stmt_listContext)(nil)).Elem())
	var tst = make([]ISql_stmt_listContext, len(ts))

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

	return tst
}

func (s *ParseContext) Sql_stmt_list(i int) ISql_stmt_listContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISql_stmt_listContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISql_stmt_listContext)
}

func (s *ParseContext) AllError() []IErrorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IErrorContext)(nil)).Elem())
	var tst = make([]IErrorContext, len(ts))

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

	return tst
}

func (s *ParseContext) Error(i int) IErrorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IErrorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IErrorContext)
}

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

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


func (s *ParseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterParse(s)
	}
}

func (s *ParseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitParse(s)
	}
}




func (p *SqlParser) Parse() (localctx IParseContext) {
	localctx = NewParseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 0, SqlParserRULE_parse)
	var _la int


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

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

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


	for _la == SqlParserSCOL || _la == SqlParserK_ALTER || ((((_la - 32)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 32))) & ((1 << (SqlParserK_ANALYZE - 32)) | (1 << (SqlParserK_ATTACH - 32)) | (1 << (SqlParserK_BEGIN - 32)) | (1 << (SqlParserK_COMMIT - 32)) | (1 << (SqlParserK_CREATE - 32)) | (1 << (SqlParserK_DELETE - 32)) | (1 << (SqlParserK_DETACH - 32)))) != 0) || ((((_la - 64)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 64))) & ((1 << (SqlParserK_DROP - 64)) | (1 << (SqlParserK_END - 64)) | (1 << (SqlParserK_EXPLAIN - 64)) | (1 << (SqlParserK_INSERT - 64)))) != 0) || ((((_la - 118)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 118))) & ((1 << (SqlParserK_PRAGMA - 118)) | (1 << (SqlParserK_REINDEX - 118)) | (1 << (SqlParserK_RELEASE - 118)) | (1 << (SqlParserK_REPLACE - 118)) | (1 << (SqlParserK_ROLLBACK - 118)) | (1 << (SqlParserK_SAVEPOINT - 118)) | (1 << (SqlParserK_SELECT - 118)) | (1 << (SqlParserK_UPDATE - 118)) | (1 << (SqlParserK_VACUUM - 118)) | (1 << (SqlParserK_VALUES - 118)))) != 0) || _la == SqlParserK_WITH || _la == SqlParserUNEXPECTED_CHAR {
		p.SetState(200)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SqlParserSCOL, SqlParserK_ALTER, SqlParserK_ANALYZE, SqlParserK_ATTACH, SqlParserK_BEGIN, SqlParserK_COMMIT, SqlParserK_CREATE, SqlParserK_DELETE, SqlParserK_DETACH, SqlParserK_DROP, SqlParserK_END, SqlParserK_EXPLAIN, SqlParserK_INSERT, SqlParserK_PRAGMA, SqlParserK_REINDEX, SqlParserK_RELEASE, SqlParserK_REPLACE, SqlParserK_ROLLBACK, SqlParserK_SAVEPOINT, SqlParserK_SELECT, SqlParserK_UPDATE, SqlParserK_VACUUM, SqlParserK_VALUES, SqlParserK_WITH:
			{
				p.SetState(198)
				p.Sql_stmt_list()
			}


		case SqlParserUNEXPECTED_CHAR:
			{
				p.SetState(199)
				p.Error()
			}



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

		p.SetState(204)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(205)
		p.Match(SqlParserEOF)
	}



	return localctx
}


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

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

	// Get_UNEXPECTED_CHAR returns the _UNEXPECTED_CHAR token.
	Get_UNEXPECTED_CHAR() antlr.Token 


	// Set_UNEXPECTED_CHAR sets the _UNEXPECTED_CHAR token.
	Set_UNEXPECTED_CHAR(antlr.Token) 


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

type ErrorContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
	_UNEXPECTED_CHAR antlr.Token
}

func NewEmptyErrorContext() *ErrorContext {
	var p = new(ErrorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_error
	return p
}

func (*ErrorContext) IsErrorContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_error

	return p
}

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

func (s *ErrorContext) Get_UNEXPECTED_CHAR() antlr.Token { return s._UNEXPECTED_CHAR }


func (s *ErrorContext) Set_UNEXPECTED_CHAR(v antlr.Token) { s._UNEXPECTED_CHAR = v }


func (s *ErrorContext) UNEXPECTED_CHAR() antlr.TerminalNode {
	return s.GetToken(SqlParserUNEXPECTED_CHAR, 0)
}

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

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


func (s *ErrorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterError(s)
	}
}

func (s *ErrorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitError(s)
	}
}




func (p *SqlParser) Error() (localctx IErrorContext) {
	localctx = NewErrorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 2, SqlParserRULE_error)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(207)

		var _m = p.Match(SqlParserUNEXPECTED_CHAR)

		localctx.(*ErrorContext)._UNEXPECTED_CHAR = _m
	}

	     //throw new RuntimeException("UNEXPECTED_CHAR=" + (func() string { if localctx.(*ErrorContext).Get_UNEXPECTED_CHAR() == nil { return "" } else { return localctx.(*ErrorContext).Get_UNEXPECTED_CHAR().GetText() }}()));
	   



	return localctx
}


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

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

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

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

func NewEmptySql_stmt_listContext() *Sql_stmt_listContext {
	var p = new(Sql_stmt_listContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_sql_stmt_list
	return p
}

func (*Sql_stmt_listContext) IsSql_stmt_listContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_sql_stmt_list

	return p
}

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

func (s *Sql_stmt_listContext) AllSql_stmt() []ISql_stmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISql_stmtContext)(nil)).Elem())
	var tst = make([]ISql_stmtContext, len(ts))

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

	return tst
}

func (s *Sql_stmt_listContext) Sql_stmt(i int) ISql_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISql_stmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISql_stmtContext)
}

func (s *Sql_stmt_listContext) AllSCOL() []antlr.TerminalNode {
	return s.GetTokens(SqlParserSCOL)
}

func (s *Sql_stmt_listContext) SCOL(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserSCOL, i)
}

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

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


func (s *Sql_stmt_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterSql_stmt_list(s)
	}
}

func (s *Sql_stmt_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitSql_stmt_list(s)
	}
}




func (p *SqlParser) Sql_stmt_list() (localctx ISql_stmt_listContext) {
	localctx = NewSql_stmt_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, SqlParserRULE_sql_stmt_list)
	var _la int


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

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


	for _la == SqlParserSCOL {
		{
			p.SetState(210)
			p.Match(SqlParserSCOL)
		}


		p.SetState(215)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(216)
		p.Sql_stmt()
	}
	p.SetState(225)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 4, p.GetParserRuleContext())

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


			for ok := true; ok; ok = _la == SqlParserSCOL {
				{
					p.SetState(217)
					p.Match(SqlParserSCOL)
				}


				p.SetState(220)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(222)
				p.Sql_stmt()
			}


		}
		p.SetState(227)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 4, p.GetParserRuleContext())
	}
	p.SetState(231)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 5, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(228)
				p.Match(SqlParserSCOL)
			}


		}
		p.SetState(233)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 5, p.GetParserRuleContext())
	}



	return localctx
}


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

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

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

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

func NewEmptySql_stmtContext() *Sql_stmtContext {
	var p = new(Sql_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_sql_stmt
	return p
}

func (*Sql_stmtContext) IsSql_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_sql_stmt

	return p
}

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

func (s *Sql_stmtContext) Alter_table_stmt() IAlter_table_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlter_table_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlter_table_stmtContext)
}

func (s *Sql_stmtContext) Analyze_stmt() IAnalyze_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnalyze_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAnalyze_stmtContext)
}

func (s *Sql_stmtContext) Attach_stmt() IAttach_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAttach_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAttach_stmtContext)
}

func (s *Sql_stmtContext) Begin_stmt() IBegin_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBegin_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBegin_stmtContext)
}

func (s *Sql_stmtContext) Commit_stmt() ICommit_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommit_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICommit_stmtContext)
}

func (s *Sql_stmtContext) Compound_select_stmt() ICompound_select_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompound_select_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICompound_select_stmtContext)
}

func (s *Sql_stmtContext) Create_index_stmt() ICreate_index_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreate_index_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreate_index_stmtContext)
}

func (s *Sql_stmtContext) Create_table_stmt() ICreate_table_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreate_table_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreate_table_stmtContext)
}

func (s *Sql_stmtContext) Create_trigger_stmt() ICreate_trigger_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreate_trigger_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreate_trigger_stmtContext)
}

func (s *Sql_stmtContext) Create_view_stmt() ICreate_view_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreate_view_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreate_view_stmtContext)
}

func (s *Sql_stmtContext) Create_force_view_stmt() ICreate_force_view_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreate_force_view_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreate_force_view_stmtContext)
}

func (s *Sql_stmtContext) Create_virtual_table_stmt() ICreate_virtual_table_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICreate_virtual_table_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICreate_virtual_table_stmtContext)
}

func (s *Sql_stmtContext) Delete_stmt() IDelete_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDelete_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDelete_stmtContext)
}

func (s *Sql_stmtContext) Delete_stmt_limited() IDelete_stmt_limitedContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDelete_stmt_limitedContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDelete_stmt_limitedContext)
}

func (s *Sql_stmtContext) Detach_stmt() IDetach_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDetach_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDetach_stmtContext)
}

func (s *Sql_stmtContext) Drop_index_stmt() IDrop_index_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDrop_index_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDrop_index_stmtContext)
}

func (s *Sql_stmtContext) Drop_table_stmt() IDrop_table_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDrop_table_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDrop_table_stmtContext)
}

func (s *Sql_stmtContext) Drop_trigger_stmt() IDrop_trigger_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDrop_trigger_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDrop_trigger_stmtContext)
}

func (s *Sql_stmtContext) Drop_view_stmt() IDrop_view_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDrop_view_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDrop_view_stmtContext)
}

func (s *Sql_stmtContext) Factored_select_stmt() IFactored_select_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFactored_select_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFactored_select_stmtContext)
}

func (s *Sql_stmtContext) Insert_stmt() IInsert_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInsert_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInsert_stmtContext)
}

func (s *Sql_stmtContext) Pragma_stmt() IPragma_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPragma_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPragma_stmtContext)
}

func (s *Sql_stmtContext) Reindex_stmt() IReindex_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReindex_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IReindex_stmtContext)
}

func (s *Sql_stmtContext) Release_stmt() IRelease_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRelease_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRelease_stmtContext)
}

func (s *Sql_stmtContext) Rollback_stmt() IRollback_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRollback_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRollback_stmtContext)
}

func (s *Sql_stmtContext) Savepoint_stmt() ISavepoint_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISavepoint_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISavepoint_stmtContext)
}

func (s *Sql_stmtContext) Simple_select_stmt() ISimple_select_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISimple_select_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISimple_select_stmtContext)
}

func (s *Sql_stmtContext) Select_stmt() ISelect_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

func (s *Sql_stmtContext) Update_stmt() IUpdate_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUpdate_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUpdate_stmtContext)
}

func (s *Sql_stmtContext) Update_stmt_limited() IUpdate_stmt_limitedContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUpdate_stmt_limitedContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUpdate_stmt_limitedContext)
}

func (s *Sql_stmtContext) Vacuum_stmt() IVacuum_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IVacuum_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IVacuum_stmtContext)
}

func (s *Sql_stmtContext) K_EXPLAIN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXPLAIN, 0)
}

func (s *Sql_stmtContext) K_QUERY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_QUERY, 0)
}

func (s *Sql_stmtContext) K_PLAN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_PLAN, 0)
}

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

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


func (s *Sql_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterSql_stmt(s)
	}
}

func (s *Sql_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitSql_stmt(s)
	}
}




func (p *SqlParser) Sql_stmt() (localctx ISql_stmtContext) {
	localctx = NewSql_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 6, SqlParserRULE_sql_stmt)
	var _la int


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

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

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


	if _la == SqlParserK_EXPLAIN {
		{
			p.SetState(234)
			p.Match(SqlParserK_EXPLAIN)
		}
		p.SetState(237)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserK_QUERY {
			{
				p.SetState(235)
				p.Match(SqlParserK_QUERY)
			}
			{
				p.SetState(236)
				p.Match(SqlParserK_PLAN)
			}

		}

	}
	p.SetState(272)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 8, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(241)
			p.Alter_table_stmt()
		}


	case 2:
		{
			p.SetState(242)
			p.Analyze_stmt()
		}


	case 3:
		{
			p.SetState(243)
			p.Attach_stmt()
		}


	case 4:
		{
			p.SetState(244)
			p.Begin_stmt()
		}


	case 5:
		{
			p.SetState(245)
			p.Commit_stmt()
		}


	case 6:
		{
			p.SetState(246)
			p.Compound_select_stmt()
		}


	case 7:
		{
			p.SetState(247)
			p.Create_index_stmt()
		}


	case 8:
		{
			p.SetState(248)
			p.Create_table_stmt()
		}


	case 9:
		{
			p.SetState(249)
			p.Create_trigger_stmt()
		}


	case 10:
		{
			p.SetState(250)
			p.Create_view_stmt()
		}


	case 11:
		{
			p.SetState(251)
			p.Create_force_view_stmt()
		}


	case 12:
		{
			p.SetState(252)
			p.Create_virtual_table_stmt()
		}


	case 13:
		{
			p.SetState(253)
			p.Delete_stmt()
		}


	case 14:
		{
			p.SetState(254)
			p.Delete_stmt_limited()
		}


	case 15:
		{
			p.SetState(255)
			p.Detach_stmt()
		}


	case 16:
		{
			p.SetState(256)
			p.Drop_index_stmt()
		}


	case 17:
		{
			p.SetState(257)
			p.Drop_table_stmt()
		}


	case 18:
		{
			p.SetState(258)
			p.Drop_trigger_stmt()
		}


	case 19:
		{
			p.SetState(259)
			p.Drop_view_stmt()
		}


	case 20:
		{
			p.SetState(260)
			p.Factored_select_stmt()
		}


	case 21:
		{
			p.SetState(261)
			p.Insert_stmt()
		}


	case 22:
		{
			p.SetState(262)
			p.Pragma_stmt()
		}


	case 23:
		{
			p.SetState(263)
			p.Reindex_stmt()
		}


	case 24:
		{
			p.SetState(264)
			p.Release_stmt()
		}


	case 25:
		{
			p.SetState(265)
			p.Rollback_stmt()
		}


	case 26:
		{
			p.SetState(266)
			p.Savepoint_stmt()
		}


	case 27:
		{
			p.SetState(267)
			p.Simple_select_stmt()
		}


	case 28:
		{
			p.SetState(268)
			p.Select_stmt()
		}


	case 29:
		{
			p.SetState(269)
			p.Update_stmt()
		}


	case 30:
		{
			p.SetState(270)
			p.Update_stmt_limited()
		}


	case 31:
		{
			p.SetState(271)
			p.Vacuum_stmt()
		}

	}



	return localctx
}


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

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

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

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

func NewEmptyAlter_table_stmtContext() *Alter_table_stmtContext {
	var p = new(Alter_table_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_alter_table_stmt
	return p
}

func (*Alter_table_stmtContext) IsAlter_table_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_alter_table_stmt

	return p
}

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

func (s *Alter_table_stmtContext) K_ALTER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ALTER, 0)
}

func (s *Alter_table_stmtContext) K_TABLE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TABLE, 0)
}

func (s *Alter_table_stmtContext) Source_table_name() ISource_table_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISource_table_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISource_table_nameContext)
}

func (s *Alter_table_stmtContext) K_RENAME() antlr.TerminalNode {
	return s.GetToken(SqlParserK_RENAME, 0)
}

func (s *Alter_table_stmtContext) K_TO() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TO, 0)
}

func (s *Alter_table_stmtContext) New_table_name() INew_table_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INew_table_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INew_table_nameContext)
}

func (s *Alter_table_stmtContext) Alter_table_add() IAlter_table_addContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlter_table_addContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlter_table_addContext)
}

func (s *Alter_table_stmtContext) K_ADD() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ADD, 0)
}

func (s *Alter_table_stmtContext) Column_def() IColumn_defContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_defContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumn_defContext)
}

func (s *Alter_table_stmtContext) Alter_table_add_constraint() IAlter_table_add_constraintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAlter_table_add_constraintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAlter_table_add_constraintContext)
}

func (s *Alter_table_stmtContext) K_ONLY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ONLY, 0)
}

func (s *Alter_table_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Alter_table_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

func (s *Alter_table_stmtContext) K_ENABLE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ENABLE, 0)
}

func (s *Alter_table_stmtContext) K_COLUMN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_COLUMN, 0)
}

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

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


func (s *Alter_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterAlter_table_stmt(s)
	}
}

func (s *Alter_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitAlter_table_stmt(s)
	}
}




func (p *SqlParser) Alter_table_stmt() (localctx IAlter_table_stmtContext) {
	localctx = NewAlter_table_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 8, SqlParserRULE_alter_table_stmt)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(274)
		p.Match(SqlParserK_ALTER)
	}
	{
		p.SetState(275)
		p.Match(SqlParserK_TABLE)
	}
	p.SetState(277)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_ONLY {
		{
			p.SetState(276)
			p.Match(SqlParserK_ONLY)
		}

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


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 10, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(279)
			p.Database_name()
		}
		{
			p.SetState(280)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(284)
		p.Source_table_name()
	}
	p.SetState(295)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 12, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(285)
			p.Match(SqlParserK_RENAME)
		}
		{
			p.SetState(286)
			p.Match(SqlParserK_TO)
		}
		{
			p.SetState(287)
			p.New_table_name()
		}


	case 2:
		{
			p.SetState(288)
			p.Alter_table_add()
		}


	case 3:
		{
			p.SetState(289)
			p.Match(SqlParserK_ADD)
		}
		p.SetState(291)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 11, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(290)
				p.Match(SqlParserK_COLUMN)
			}


		}
		{
			p.SetState(293)
			p.Column_def()
		}


	case 4:
		{
			p.SetState(294)
			p.Alter_table_add_constraint()
		}

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


	if _la == SqlParserK_ENABLE {
		{
			p.SetState(297)
			p.Match(SqlParserK_ENABLE)
		}

	}



	return localctx
}


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

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

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

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

func NewEmptyAlter_table_add_constraintContext() *Alter_table_add_constraintContext {
	var p = new(Alter_table_add_constraintContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_alter_table_add_constraint
	return p
}

func (*Alter_table_add_constraintContext) IsAlter_table_add_constraintContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_alter_table_add_constraint

	return p
}

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

func (s *Alter_table_add_constraintContext) K_ADD() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ADD, 0)
}

func (s *Alter_table_add_constraintContext) K_CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CONSTRAINT, 0)
}

func (s *Alter_table_add_constraintContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Alter_table_add_constraintContext) Table_constraint() ITable_constraintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_constraintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_constraintContext)
}

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

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


func (s *Alter_table_add_constraintContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterAlter_table_add_constraint(s)
	}
}

func (s *Alter_table_add_constraintContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitAlter_table_add_constraint(s)
	}
}




func (p *SqlParser) Alter_table_add_constraint() (localctx IAlter_table_add_constraintContext) {
	localctx = NewAlter_table_add_constraintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 10, SqlParserRULE_alter_table_add_constraint)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(300)
		p.Match(SqlParserK_ADD)
	}
	{
		p.SetState(301)
		p.Match(SqlParserK_CONSTRAINT)
	}
	{
		p.SetState(302)
		p.Any_name()
	}
	{
		p.SetState(303)
		p.Table_constraint()
	}



	return localctx
}


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

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

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

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

func NewEmptyAlter_table_addContext() *Alter_table_addContext {
	var p = new(Alter_table_addContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_alter_table_add
	return p
}

func (*Alter_table_addContext) IsAlter_table_addContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_alter_table_add

	return p
}

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

func (s *Alter_table_addContext) K_ADD() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ADD, 0)
}

func (s *Alter_table_addContext) Table_constraint() ITable_constraintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_constraintContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_constraintContext)
}

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

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


func (s *Alter_table_addContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterAlter_table_add(s)
	}
}

func (s *Alter_table_addContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitAlter_table_add(s)
	}
}




func (p *SqlParser) Alter_table_add() (localctx IAlter_table_addContext) {
	localctx = NewAlter_table_addContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 12, SqlParserRULE_alter_table_add)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(305)
		p.Match(SqlParserK_ADD)
	}
	{
		p.SetState(306)
		p.Table_constraint()
	}



	return localctx
}


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

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

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

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

func NewEmptyAnalyze_stmtContext() *Analyze_stmtContext {
	var p = new(Analyze_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_analyze_stmt
	return p
}

func (*Analyze_stmtContext) IsAnalyze_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_analyze_stmt

	return p
}

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

func (s *Analyze_stmtContext) K_ANALYZE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ANALYZE, 0)
}

func (s *Analyze_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Analyze_stmtContext) Table_or_index_name() ITable_or_index_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_or_index_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_or_index_nameContext)
}

func (s *Analyze_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

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

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


func (s *Analyze_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterAnalyze_stmt(s)
	}
}

func (s *Analyze_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitAnalyze_stmt(s)
	}
}




func (p *SqlParser) Analyze_stmt() (localctx IAnalyze_stmtContext) {
	localctx = NewAnalyze_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 14, SqlParserRULE_analyze_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(308)
		p.Match(SqlParserK_ANALYZE)
	}
	p.SetState(315)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 14, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(309)
			p.Database_name()
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 14, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(310)
			p.Table_or_index_name()
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 14, p.GetParserRuleContext()) == 3 {
		{
			p.SetState(311)
			p.Database_name()
		}
		{
			p.SetState(312)
			p.Match(SqlParserDOT)
		}
		{
			p.SetState(313)
			p.Table_or_index_name()
		}


	}



	return localctx
}


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

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

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

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

func NewEmptyAttach_stmtContext() *Attach_stmtContext {
	var p = new(Attach_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_attach_stmt
	return p
}

func (*Attach_stmtContext) IsAttach_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_attach_stmt

	return p
}

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

func (s *Attach_stmtContext) K_ATTACH() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ATTACH, 0)
}

func (s *Attach_stmtContext) Expr() IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Attach_stmtContext) K_AS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AS, 0)
}

func (s *Attach_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Attach_stmtContext) K_DATABASE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DATABASE, 0)
}

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

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


func (s *Attach_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterAttach_stmt(s)
	}
}

func (s *Attach_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitAttach_stmt(s)
	}
}




func (p *SqlParser) Attach_stmt() (localctx IAttach_stmtContext) {
	localctx = NewAttach_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, SqlParserRULE_attach_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(317)
		p.Match(SqlParserK_ATTACH)
	}
	p.SetState(319)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 15, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(318)
			p.Match(SqlParserK_DATABASE)
		}


	}
	{
		p.SetState(321)
		p.expr(0)
	}
	{
		p.SetState(322)
		p.Match(SqlParserK_AS)
	}
	{
		p.SetState(323)
		p.Database_name()
	}



	return localctx
}


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

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

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

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

func NewEmptyBegin_stmtContext() *Begin_stmtContext {
	var p = new(Begin_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_begin_stmt
	return p
}

func (*Begin_stmtContext) IsBegin_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_begin_stmt

	return p
}

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

func (s *Begin_stmtContext) K_BEGIN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BEGIN, 0)
}

func (s *Begin_stmtContext) K_TRANSACTION() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TRANSACTION, 0)
}

func (s *Begin_stmtContext) K_DEFERRED() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DEFERRED, 0)
}

func (s *Begin_stmtContext) K_IMMEDIATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IMMEDIATE, 0)
}

func (s *Begin_stmtContext) K_EXCLUSIVE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXCLUSIVE, 0)
}

func (s *Begin_stmtContext) Transaction_name() ITransaction_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITransaction_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITransaction_nameContext)
}

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

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


func (s *Begin_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterBegin_stmt(s)
	}
}

func (s *Begin_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitBegin_stmt(s)
	}
}




func (p *SqlParser) Begin_stmt() (localctx IBegin_stmtContext) {
	localctx = NewBegin_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, SqlParserRULE_begin_stmt)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(325)
		p.Match(SqlParserK_BEGIN)
	}
	p.SetState(327)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if ((((_la - 59)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 59))) & ((1 << (SqlParserK_DEFERRED - 59)) | (1 << (SqlParserK_EXCLUSIVE - 59)) | (1 << (SqlParserK_IMMEDIATE - 59)))) != 0) {
		{
			p.SetState(326)
			_la = p.GetTokenStream().LA(1)

			if !(((((_la - 59)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 59))) & ((1 << (SqlParserK_DEFERRED - 59)) | (1 << (SqlParserK_EXCLUSIVE - 59)) | (1 << (SqlParserK_IMMEDIATE - 59)))) != 0)) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

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


	if _la == SqlParserK_TRANSACTION {
		{
			p.SetState(329)
			p.Match(SqlParserK_TRANSACTION)
		}
		p.SetState(331)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 17, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(330)
				p.Transaction_name()
			}


		}

	}



	return localctx
}


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

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

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

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

func NewEmptyCommit_stmtContext() *Commit_stmtContext {
	var p = new(Commit_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_commit_stmt
	return p
}

func (*Commit_stmtContext) IsCommit_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_commit_stmt

	return p
}

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

func (s *Commit_stmtContext) K_COMMIT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_COMMIT, 0)
}

func (s *Commit_stmtContext) K_END() antlr.TerminalNode {
	return s.GetToken(SqlParserK_END, 0)
}

func (s *Commit_stmtContext) K_TRANSACTION() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TRANSACTION, 0)
}

func (s *Commit_stmtContext) Transaction_name() ITransaction_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITransaction_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITransaction_nameContext)
}

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

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


func (s *Commit_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterCommit_stmt(s)
	}
}

func (s *Commit_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitCommit_stmt(s)
	}
}




func (p *SqlParser) Commit_stmt() (localctx ICommit_stmtContext) {
	localctx = NewCommit_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 20, SqlParserRULE_commit_stmt)
	var _la int


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

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

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

		if !(_la == SqlParserK_COMMIT || _la == SqlParserK_END) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(340)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_TRANSACTION {
		{
			p.SetState(336)
			p.Match(SqlParserK_TRANSACTION)
		}
		p.SetState(338)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 19, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(337)
				p.Transaction_name()
			}


		}

	}



	return localctx
}


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

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

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

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

func NewEmptyCompound_select_stmtContext() *Compound_select_stmtContext {
	var p = new(Compound_select_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_compound_select_stmt
	return p
}

func (*Compound_select_stmtContext) IsCompound_select_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_compound_select_stmt

	return p
}

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

func (s *Compound_select_stmtContext) AllSelect_core() []ISelect_coreContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISelect_coreContext)(nil)).Elem())
	var tst = make([]ISelect_coreContext, len(ts))

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

	return tst
}

func (s *Compound_select_stmtContext) Select_core(i int) ISelect_coreContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_coreContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISelect_coreContext)
}

func (s *Compound_select_stmtContext) K_WITH() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WITH, 0)
}

func (s *Compound_select_stmtContext) AllCommon_table_expression() []ICommon_table_expressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICommon_table_expressionContext)(nil)).Elem())
	var tst = make([]ICommon_table_expressionContext, len(ts))

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

	return tst
}

func (s *Compound_select_stmtContext) Common_table_expression(i int) ICommon_table_expressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommon_table_expressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICommon_table_expressionContext)
}

func (s *Compound_select_stmtContext) K_ORDER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ORDER, 0)
}

func (s *Compound_select_stmtContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BY, 0)
}

func (s *Compound_select_stmtContext) AllOrdering_term() []IOrdering_termContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IOrdering_termContext)(nil)).Elem())
	var tst = make([]IOrdering_termContext, len(ts))

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

	return tst
}

func (s *Compound_select_stmtContext) Ordering_term(i int) IOrdering_termContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrdering_termContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IOrdering_termContext)
}

func (s *Compound_select_stmtContext) K_LIMIT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_LIMIT, 0)
}

func (s *Compound_select_stmtContext) AllExpr() []IExprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExprContext)(nil)).Elem())
	var tst = make([]IExprContext, len(ts))

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

	return tst
}

func (s *Compound_select_stmtContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Compound_select_stmtContext) AllK_UNION() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_UNION)
}

func (s *Compound_select_stmtContext) K_UNION(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_UNION, i)
}

func (s *Compound_select_stmtContext) AllK_INTERSECT() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_INTERSECT)
}

func (s *Compound_select_stmtContext) K_INTERSECT(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_INTERSECT, i)
}

func (s *Compound_select_stmtContext) AllK_EXCEPT() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_EXCEPT)
}

func (s *Compound_select_stmtContext) K_EXCEPT(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXCEPT, i)
}

func (s *Compound_select_stmtContext) K_RECURSIVE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_RECURSIVE, 0)
}

func (s *Compound_select_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

func (s *Compound_select_stmtContext) K_OFFSET() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OFFSET, 0)
}

func (s *Compound_select_stmtContext) AllK_ALL() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_ALL)
}

func (s *Compound_select_stmtContext) K_ALL(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_ALL, i)
}

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

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


func (s *Compound_select_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterCompound_select_stmt(s)
	}
}

func (s *Compound_select_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitCompound_select_stmt(s)
	}
}




func (p *SqlParser) Compound_select_stmt() (localctx ICompound_select_stmtContext) {
	localctx = NewCompound_select_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 22, SqlParserRULE_compound_select_stmt)
	var _la int


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

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

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


	if _la == SqlParserK_WITH {
		{
			p.SetState(342)
			p.Match(SqlParserK_WITH)
		}
		p.SetState(344)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 21, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(343)
				p.Match(SqlParserK_RECURSIVE)
			}


		}
		{
			p.SetState(346)
			p.Common_table_expression()
		}
		p.SetState(351)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(347)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(348)
				p.Common_table_expression()
			}


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

	}
	{
		p.SetState(356)
		p.Select_core()
	}
	p.SetState(366)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	for ok := true; ok; ok = _la == SqlParserK_EXCEPT || _la == SqlParserK_INTERSECT || _la == SqlParserK_UNION {
		p.SetState(363)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SqlParserK_UNION:
			{
				p.SetState(357)
				p.Match(SqlParserK_UNION)
			}
			p.SetState(359)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			if _la == SqlParserK_ALL {
				{
					p.SetState(358)
					p.Match(SqlParserK_ALL)
				}

			}


		case SqlParserK_INTERSECT:
			{
				p.SetState(361)
				p.Match(SqlParserK_INTERSECT)
			}


		case SqlParserK_EXCEPT:
			{
				p.SetState(362)
				p.Match(SqlParserK_EXCEPT)
			}



		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}
		{
			p.SetState(365)
			p.Select_core()
		}


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


	if _la == SqlParserK_ORDER {
		{
			p.SetState(370)
			p.Match(SqlParserK_ORDER)
		}
		{
			p.SetState(371)
			p.Match(SqlParserK_BY)
		}
		{
			p.SetState(372)
			p.Ordering_term()
		}
		p.SetState(377)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(373)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(374)
				p.Ordering_term()
			}


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

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


	if _la == SqlParserK_LIMIT {
		{
			p.SetState(382)
			p.Match(SqlParserK_LIMIT)
		}
		{
			p.SetState(383)
			p.expr(0)
		}
		p.SetState(386)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserCOMMA || _la == SqlParserK_OFFSET {
			{
				p.SetState(384)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SqlParserCOMMA || _la == SqlParserK_OFFSET) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(385)
				p.expr(0)
			}

		}

	}



	return localctx
}


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

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

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

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

func NewEmptyCreate_index_stmtContext() *Create_index_stmtContext {
	var p = new(Create_index_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_create_index_stmt
	return p
}

func (*Create_index_stmtContext) IsCreate_index_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_create_index_stmt

	return p
}

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

func (s *Create_index_stmtContext) K_CREATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CREATE, 0)
}

func (s *Create_index_stmtContext) K_INDEX() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INDEX, 0)
}

func (s *Create_index_stmtContext) Index_name() IIndex_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndex_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndex_nameContext)
}

func (s *Create_index_stmtContext) K_ON() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ON, 0)
}

func (s *Create_index_stmtContext) Table_name() ITable_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Create_index_stmtContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Create_index_stmtContext) AllIndexed_column() []IIndexed_columnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIndexed_columnContext)(nil)).Elem())
	var tst = make([]IIndexed_columnContext, len(ts))

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

	return tst
}

func (s *Create_index_stmtContext) Indexed_column(i int) IIndexed_columnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexed_columnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIndexed_columnContext)
}

func (s *Create_index_stmtContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Create_index_stmtContext) K_UNIQUE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_UNIQUE, 0)
}

func (s *Create_index_stmtContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IF, 0)
}

func (s *Create_index_stmtContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOT, 0)
}

func (s *Create_index_stmtContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXISTS, 0)
}

func (s *Create_index_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Create_index_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

func (s *Create_index_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

func (s *Create_index_stmtContext) K_WHERE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WHERE, 0)
}

func (s *Create_index_stmtContext) Expr() IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

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

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


func (s *Create_index_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterCreate_index_stmt(s)
	}
}

func (s *Create_index_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitCreate_index_stmt(s)
	}
}




func (p *SqlParser) Create_index_stmt() (localctx ICreate_index_stmtContext) {
	localctx = NewCreate_index_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, SqlParserRULE_create_index_stmt)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(390)
		p.Match(SqlParserK_CREATE)
	}
	p.SetState(392)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_UNIQUE {
		{
			p.SetState(391)
			p.Match(SqlParserK_UNIQUE)
		}

	}
	{
		p.SetState(394)
		p.Match(SqlParserK_INDEX)
	}
	p.SetState(398)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 32, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(395)
			p.Match(SqlParserK_IF)
		}
		{
			p.SetState(396)
			p.Match(SqlParserK_NOT)
		}
		{
			p.SetState(397)
			p.Match(SqlParserK_EXISTS)
		}


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


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 33, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(400)
			p.Database_name()
		}
		{
			p.SetState(401)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(405)
		p.Index_name()
	}
	{
		p.SetState(406)
		p.Match(SqlParserK_ON)
	}
	{
		p.SetState(407)
		p.Table_name()
	}
	{
		p.SetState(408)
		p.Match(SqlParserOPEN_PAR)
	}
	{
		p.SetState(409)
		p.Indexed_column()
	}
	p.SetState(414)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	for _la == SqlParserCOMMA {
		{
			p.SetState(410)
			p.Match(SqlParserCOMMA)
		}
		{
			p.SetState(411)
			p.Indexed_column()
		}


		p.SetState(416)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(417)
		p.Match(SqlParserCLOSE_PAR)
	}
	p.SetState(420)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_WHERE {
		{
			p.SetState(418)
			p.Match(SqlParserK_WHERE)
		}
		{
			p.SetState(419)
			p.expr(0)
		}

	}



	return localctx
}


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

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

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

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

func NewEmptyCreate_table_stmtContext() *Create_table_stmtContext {
	var p = new(Create_table_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_create_table_stmt
	return p
}

func (*Create_table_stmtContext) IsCreate_table_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_create_table_stmt

	return p
}

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

func (s *Create_table_stmtContext) K_CREATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CREATE, 0)
}

func (s *Create_table_stmtContext) K_TABLE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TABLE, 0)
}

func (s *Create_table_stmtContext) Table_name() ITable_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Create_table_stmtContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Create_table_stmtContext) AllColumn_def() []IColumn_defContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumn_defContext)(nil)).Elem())
	var tst = make([]IColumn_defContext, len(ts))

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

	return tst
}

func (s *Create_table_stmtContext) Column_def(i int) IColumn_defContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_defContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumn_defContext)
}

func (s *Create_table_stmtContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Create_table_stmtContext) K_AS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AS, 0)
}

func (s *Create_table_stmtContext) Select_stmt() ISelect_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

func (s *Create_table_stmtContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IF, 0)
}

func (s *Create_table_stmtContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOT, 0)
}

func (s *Create_table_stmtContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXISTS, 0)
}

func (s *Create_table_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Create_table_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

func (s *Create_table_stmtContext) K_TEMP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TEMP, 0)
}

func (s *Create_table_stmtContext) K_TEMPORARY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TEMPORARY, 0)
}

func (s *Create_table_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

func (s *Create_table_stmtContext) AllTable_constraint() []ITable_constraintContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITable_constraintContext)(nil)).Elem())
	var tst = make([]ITable_constraintContext, len(ts))

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

	return tst
}

func (s *Create_table_stmtContext) Table_constraint(i int) ITable_constraintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_constraintContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITable_constraintContext)
}

func (s *Create_table_stmtContext) K_WITHOUT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WITHOUT, 0)
}

func (s *Create_table_stmtContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(SqlParserIDENTIFIER, 0)
}

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

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


func (s *Create_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterCreate_table_stmt(s)
	}
}

func (s *Create_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitCreate_table_stmt(s)
	}
}




func (p *SqlParser) Create_table_stmt() (localctx ICreate_table_stmtContext) {
	localctx = NewCreate_table_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 26, SqlParserRULE_create_table_stmt)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(422)
		p.Match(SqlParserK_CREATE)
	}
	p.SetState(424)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_TEMP || _la == SqlParserK_TEMPORARY {
		{
			p.SetState(423)
			_la = p.GetTokenStream().LA(1)

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

	}
	{
		p.SetState(426)
		p.Match(SqlParserK_TABLE)
	}
	p.SetState(430)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 37, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(427)
			p.Match(SqlParserK_IF)
		}
		{
			p.SetState(428)
			p.Match(SqlParserK_NOT)
		}
		{
			p.SetState(429)
			p.Match(SqlParserK_EXISTS)
		}


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


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 38, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(432)
			p.Database_name()
		}
		{
			p.SetState(433)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(437)
		p.Table_name()
	}
	p.SetState(456)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SqlParserOPEN_PAR:
		{
			p.SetState(438)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(439)
			p.Column_def()
		}
		p.SetState(446)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			p.SetState(444)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 39, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(440)
					p.Match(SqlParserCOMMA)
				}
				{
					p.SetState(441)
					p.Table_constraint()
				}


			case 2:
				{
					p.SetState(442)
					p.Match(SqlParserCOMMA)
				}
				{
					p.SetState(443)
					p.Column_def()
				}

			}

			p.SetState(448)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(449)
			p.Match(SqlParserCLOSE_PAR)
		}
		p.SetState(452)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserK_WITHOUT {
			{
				p.SetState(450)
				p.Match(SqlParserK_WITHOUT)
			}
			{
				p.SetState(451)
				p.Match(SqlParserIDENTIFIER)
			}

		}


	case SqlParserK_AS:
		{
			p.SetState(454)
			p.Match(SqlParserK_AS)
		}
		{
			p.SetState(455)
			p.Select_stmt()
		}



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



	return localctx
}


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

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

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

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

func NewEmptyCreate_trigger_stmtContext() *Create_trigger_stmtContext {
	var p = new(Create_trigger_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_create_trigger_stmt
	return p
}

func (*Create_trigger_stmtContext) IsCreate_trigger_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_create_trigger_stmt

	return p
}

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

func (s *Create_trigger_stmtContext) K_CREATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CREATE, 0)
}

func (s *Create_trigger_stmtContext) K_TRIGGER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TRIGGER, 0)
}

func (s *Create_trigger_stmtContext) Trigger_name() ITrigger_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITrigger_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITrigger_nameContext)
}

func (s *Create_trigger_stmtContext) K_ON() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ON, 0)
}

func (s *Create_trigger_stmtContext) Table_name() ITable_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Create_trigger_stmtContext) K_BEGIN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BEGIN, 0)
}

func (s *Create_trigger_stmtContext) K_END() antlr.TerminalNode {
	return s.GetToken(SqlParserK_END, 0)
}

func (s *Create_trigger_stmtContext) K_DELETE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DELETE, 0)
}

func (s *Create_trigger_stmtContext) K_INSERT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INSERT, 0)
}

func (s *Create_trigger_stmtContext) K_UPDATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_UPDATE, 0)
}

func (s *Create_trigger_stmtContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IF, 0)
}

func (s *Create_trigger_stmtContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOT, 0)
}

func (s *Create_trigger_stmtContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXISTS, 0)
}

func (s *Create_trigger_stmtContext) AllDatabase_name() []IDatabase_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem())
	var tst = make([]IDatabase_nameContext, len(ts))

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

	return tst
}

func (s *Create_trigger_stmtContext) Database_name(i int) IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Create_trigger_stmtContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(SqlParserDOT)
}

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

func (s *Create_trigger_stmtContext) K_BEFORE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BEFORE, 0)
}

func (s *Create_trigger_stmtContext) K_AFTER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AFTER, 0)
}

func (s *Create_trigger_stmtContext) K_INSTEAD() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INSTEAD, 0)
}

func (s *Create_trigger_stmtContext) AllK_OF() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_OF)
}

func (s *Create_trigger_stmtContext) K_OF(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_OF, i)
}

func (s *Create_trigger_stmtContext) K_FOR() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FOR, 0)
}

func (s *Create_trigger_stmtContext) K_EACH() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EACH, 0)
}

func (s *Create_trigger_stmtContext) K_ROW() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ROW, 0)
}

func (s *Create_trigger_stmtContext) K_WHEN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WHEN, 0)
}

func (s *Create_trigger_stmtContext) Expr() IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Create_trigger_stmtContext) AllSCOL() []antlr.TerminalNode {
	return s.GetTokens(SqlParserSCOL)
}

func (s *Create_trigger_stmtContext) SCOL(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserSCOL, i)
}

func (s *Create_trigger_stmtContext) K_TEMP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TEMP, 0)
}

func (s *Create_trigger_stmtContext) K_TEMPORARY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TEMPORARY, 0)
}

func (s *Create_trigger_stmtContext) AllColumn_name() []IColumn_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem())
	var tst = make([]IColumn_nameContext, len(ts))

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

	return tst
}

func (s *Create_trigger_stmtContext) Column_name(i int) IColumn_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

func (s *Create_trigger_stmtContext) AllUpdate_stmt() []IUpdate_stmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IUpdate_stmtContext)(nil)).Elem())
	var tst = make([]IUpdate_stmtContext, len(ts))

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

	return tst
}

func (s *Create_trigger_stmtContext) Update_stmt(i int) IUpdate_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUpdate_stmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IUpdate_stmtContext)
}

func (s *Create_trigger_stmtContext) AllInsert_stmt() []IInsert_stmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IInsert_stmtContext)(nil)).Elem())
	var tst = make([]IInsert_stmtContext, len(ts))

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

	return tst
}

func (s *Create_trigger_stmtContext) Insert_stmt(i int) IInsert_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInsert_stmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IInsert_stmtContext)
}

func (s *Create_trigger_stmtContext) AllDelete_stmt() []IDelete_stmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IDelete_stmtContext)(nil)).Elem())
	var tst = make([]IDelete_stmtContext, len(ts))

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

	return tst
}

func (s *Create_trigger_stmtContext) Delete_stmt(i int) IDelete_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDelete_stmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IDelete_stmtContext)
}

func (s *Create_trigger_stmtContext) AllSelect_stmt() []ISelect_stmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISelect_stmtContext)(nil)).Elem())
	var tst = make([]ISelect_stmtContext, len(ts))

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

	return tst
}

func (s *Create_trigger_stmtContext) Select_stmt(i int) ISelect_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_stmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

func (s *Create_trigger_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

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

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


func (s *Create_trigger_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterCreate_trigger_stmt(s)
	}
}

func (s *Create_trigger_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitCreate_trigger_stmt(s)
	}
}




func (p *SqlParser) Create_trigger_stmt() (localctx ICreate_trigger_stmtContext) {
	localctx = NewCreate_trigger_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, SqlParserRULE_create_trigger_stmt)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(458)
		p.Match(SqlParserK_CREATE)
	}
	p.SetState(460)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_TEMP || _la == SqlParserK_TEMPORARY {
		{
			p.SetState(459)
			_la = p.GetTokenStream().LA(1)

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

	}
	{
		p.SetState(462)
		p.Match(SqlParserK_TRIGGER)
	}
	p.SetState(466)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 44, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(463)
			p.Match(SqlParserK_IF)
		}
		{
			p.SetState(464)
			p.Match(SqlParserK_NOT)
		}
		{
			p.SetState(465)
			p.Match(SqlParserK_EXISTS)
		}


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


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 45, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(468)
			p.Database_name()
		}
		{
			p.SetState(469)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(473)
		p.Trigger_name()
	}
	p.SetState(478)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SqlParserK_BEFORE:
		{
			p.SetState(474)
			p.Match(SqlParserK_BEFORE)
		}


	case SqlParserK_AFTER:
		{
			p.SetState(475)
			p.Match(SqlParserK_AFTER)
		}


	case SqlParserK_INSTEAD:
		{
			p.SetState(476)
			p.Match(SqlParserK_INSTEAD)
		}
		{
			p.SetState(477)
			p.Match(SqlParserK_OF)
		}


	case SqlParserK_DELETE, SqlParserK_INSERT, SqlParserK_UPDATE:



	default:
	}
	p.SetState(494)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SqlParserK_DELETE:
		{
			p.SetState(480)
			p.Match(SqlParserK_DELETE)
		}


	case SqlParserK_INSERT:
		{
			p.SetState(481)
			p.Match(SqlParserK_INSERT)
		}


	case SqlParserK_UPDATE:
		{
			p.SetState(482)
			p.Match(SqlParserK_UPDATE)
		}
		p.SetState(492)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserK_OF {
			{
				p.SetState(483)
				p.Match(SqlParserK_OF)
			}
			{
				p.SetState(484)
				p.Column_name()
			}
			p.SetState(489)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			for _la == SqlParserCOMMA {
				{
					p.SetState(485)
					p.Match(SqlParserCOMMA)
				}
				{
					p.SetState(486)
					p.Column_name()
				}


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

		}



	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(496)
		p.Match(SqlParserK_ON)
	}
	p.SetState(500)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 50, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(497)
			p.Database_name()
		}
		{
			p.SetState(498)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(502)
		p.Table_name()
	}
	p.SetState(506)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_FOR {
		{
			p.SetState(503)
			p.Match(SqlParserK_FOR)
		}
		{
			p.SetState(504)
			p.Match(SqlParserK_EACH)
		}
		{
			p.SetState(505)
			p.Match(SqlParserK_ROW)
		}

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


	if _la == SqlParserK_WHEN {
		{
			p.SetState(508)
			p.Match(SqlParserK_WHEN)
		}
		{
			p.SetState(509)
			p.expr(0)
		}

	}
	{
		p.SetState(512)
		p.Match(SqlParserK_BEGIN)
	}
	p.SetState(521)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	for ok := true; ok; ok = _la == SqlParserK_DELETE || _la == SqlParserK_INSERT || ((((_la - 128)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 128))) & ((1 << (SqlParserK_REPLACE - 128)) | (1 << (SqlParserK_SELECT - 128)) | (1 << (SqlParserK_UPDATE - 128)) | (1 << (SqlParserK_VALUES - 128)) | (1 << (SqlParserK_WITH - 128)))) != 0) {
		p.SetState(517)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 53, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(513)
				p.Update_stmt()
			}


		case 2:
			{
				p.SetState(514)
				p.Insert_stmt()
			}


		case 3:
			{
				p.SetState(515)
				p.Delete_stmt()
			}


		case 4:
			{
				p.SetState(516)
				p.Select_stmt()
			}

		}
		{
			p.SetState(519)
			p.Match(SqlParserSCOL)
		}


		p.SetState(523)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(525)
		p.Match(SqlParserK_END)
	}



	return localctx
}


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

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

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

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

func NewEmptyCreate_view_stmtContext() *Create_view_stmtContext {
	var p = new(Create_view_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_create_view_stmt
	return p
}

func (*Create_view_stmtContext) IsCreate_view_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_create_view_stmt

	return p
}

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

func (s *Create_view_stmtContext) K_CREATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CREATE, 0)
}

func (s *Create_view_stmtContext) K_VIEW() antlr.TerminalNode {
	return s.GetToken(SqlParserK_VIEW, 0)
}

func (s *Create_view_stmtContext) View_name() IView_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IView_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IView_nameContext)
}

func (s *Create_view_stmtContext) K_AS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AS, 0)
}

func (s *Create_view_stmtContext) Select_stmt() ISelect_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

func (s *Create_view_stmtContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IF, 0)
}

func (s *Create_view_stmtContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOT, 0)
}

func (s *Create_view_stmtContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXISTS, 0)
}

func (s *Create_view_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Create_view_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

func (s *Create_view_stmtContext) K_TEMP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TEMP, 0)
}

func (s *Create_view_stmtContext) K_TEMPORARY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TEMPORARY, 0)
}

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

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


func (s *Create_view_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterCreate_view_stmt(s)
	}
}

func (s *Create_view_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitCreate_view_stmt(s)
	}
}




func (p *SqlParser) Create_view_stmt() (localctx ICreate_view_stmtContext) {
	localctx = NewCreate_view_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, SqlParserRULE_create_view_stmt)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(527)
		p.Match(SqlParserK_CREATE)
	}
	p.SetState(529)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_TEMP || _la == SqlParserK_TEMPORARY {
		{
			p.SetState(528)
			_la = p.GetTokenStream().LA(1)

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

	}
	{
		p.SetState(531)
		p.Match(SqlParserK_VIEW)
	}
	p.SetState(535)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 56, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(532)
			p.Match(SqlParserK_IF)
		}
		{
			p.SetState(533)
			p.Match(SqlParserK_NOT)
		}
		{
			p.SetState(534)
			p.Match(SqlParserK_EXISTS)
		}


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


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 57, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(537)
			p.Database_name()
		}
		{
			p.SetState(538)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(542)
		p.View_name()
	}
	{
		p.SetState(543)
		p.Match(SqlParserK_AS)
	}
	{
		p.SetState(544)
		p.Select_stmt()
	}



	return localctx
}


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

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

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

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

func NewEmptyCreate_force_view_stmtContext() *Create_force_view_stmtContext {
	var p = new(Create_force_view_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_create_force_view_stmt
	return p
}

func (*Create_force_view_stmtContext) IsCreate_force_view_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_create_force_view_stmt

	return p
}

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

func (s *Create_force_view_stmtContext) K_CREATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CREATE, 0)
}

func (s *Create_force_view_stmtContext) K_FORCE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FORCE, 0)
}

func (s *Create_force_view_stmtContext) K_VIEW() antlr.TerminalNode {
	return s.GetToken(SqlParserK_VIEW, 0)
}

func (s *Create_force_view_stmtContext) View_name() IView_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IView_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IView_nameContext)
}

func (s *Create_force_view_stmtContext) K_AS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AS, 0)
}

func (s *Create_force_view_stmtContext) Select_stmt() ISelect_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

func (s *Create_force_view_stmtContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IF, 0)
}

func (s *Create_force_view_stmtContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOT, 0)
}

func (s *Create_force_view_stmtContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXISTS, 0)
}

func (s *Create_force_view_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Create_force_view_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

func (s *Create_force_view_stmtContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Create_force_view_stmtContext) AllColumn_name() []IColumn_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem())
	var tst = make([]IColumn_nameContext, len(ts))

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

	return tst
}

func (s *Create_force_view_stmtContext) Column_name(i int) IColumn_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

func (s *Create_force_view_stmtContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Create_force_view_stmtContext) K_TEMP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TEMP, 0)
}

func (s *Create_force_view_stmtContext) K_TEMPORARY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TEMPORARY, 0)
}

func (s *Create_force_view_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

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

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


func (s *Create_force_view_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterCreate_force_view_stmt(s)
	}
}

func (s *Create_force_view_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitCreate_force_view_stmt(s)
	}
}




func (p *SqlParser) Create_force_view_stmt() (localctx ICreate_force_view_stmtContext) {
	localctx = NewCreate_force_view_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, SqlParserRULE_create_force_view_stmt)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(546)
		p.Match(SqlParserK_CREATE)
	}
	p.SetState(548)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_TEMP || _la == SqlParserK_TEMPORARY {
		{
			p.SetState(547)
			_la = p.GetTokenStream().LA(1)

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

	}
	{
		p.SetState(550)
		p.Match(SqlParserK_FORCE)
	}
	{
		p.SetState(551)
		p.Match(SqlParserK_VIEW)
	}
	p.SetState(555)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 59, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(552)
			p.Match(SqlParserK_IF)
		}
		{
			p.SetState(553)
			p.Match(SqlParserK_NOT)
		}
		{
			p.SetState(554)
			p.Match(SqlParserK_EXISTS)
		}


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


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 60, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(557)
			p.Database_name()
		}
		{
			p.SetState(558)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(562)
		p.View_name()
	}
	p.SetState(574)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserOPEN_PAR {
		{
			p.SetState(563)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(564)
			p.Column_name()
		}
		p.SetState(569)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(565)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(566)
				p.Column_name()
			}


			p.SetState(571)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(572)
			p.Match(SqlParserCLOSE_PAR)
		}

	}
	{
		p.SetState(576)
		p.Match(SqlParserK_AS)
	}
	{
		p.SetState(577)
		p.Select_stmt()
	}



	return localctx
}


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

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

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

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

func NewEmptyCreate_virtual_table_stmtContext() *Create_virtual_table_stmtContext {
	var p = new(Create_virtual_table_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_create_virtual_table_stmt
	return p
}

func (*Create_virtual_table_stmtContext) IsCreate_virtual_table_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_create_virtual_table_stmt

	return p
}

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

func (s *Create_virtual_table_stmtContext) K_CREATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CREATE, 0)
}

func (s *Create_virtual_table_stmtContext) K_VIRTUAL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_VIRTUAL, 0)
}

func (s *Create_virtual_table_stmtContext) K_TABLE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TABLE, 0)
}

func (s *Create_virtual_table_stmtContext) Table_name() ITable_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Create_virtual_table_stmtContext) K_USING() antlr.TerminalNode {
	return s.GetToken(SqlParserK_USING, 0)
}

func (s *Create_virtual_table_stmtContext) Module_name() IModule_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModule_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IModule_nameContext)
}

func (s *Create_virtual_table_stmtContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IF, 0)
}

func (s *Create_virtual_table_stmtContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOT, 0)
}

func (s *Create_virtual_table_stmtContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXISTS, 0)
}

func (s *Create_virtual_table_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Create_virtual_table_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

func (s *Create_virtual_table_stmtContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Create_virtual_table_stmtContext) AllModule_argument() []IModule_argumentContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IModule_argumentContext)(nil)).Elem())
	var tst = make([]IModule_argumentContext, len(ts))

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

	return tst
}

func (s *Create_virtual_table_stmtContext) Module_argument(i int) IModule_argumentContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IModule_argumentContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IModule_argumentContext)
}

func (s *Create_virtual_table_stmtContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Create_virtual_table_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

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

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


func (s *Create_virtual_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterCreate_virtual_table_stmt(s)
	}
}

func (s *Create_virtual_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitCreate_virtual_table_stmt(s)
	}
}




func (p *SqlParser) Create_virtual_table_stmt() (localctx ICreate_virtual_table_stmtContext) {
	localctx = NewCreate_virtual_table_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 34, SqlParserRULE_create_virtual_table_stmt)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(579)
		p.Match(SqlParserK_CREATE)
	}
	{
		p.SetState(580)
		p.Match(SqlParserK_VIRTUAL)
	}
	{
		p.SetState(581)
		p.Match(SqlParserK_TABLE)
	}
	p.SetState(585)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 63, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(582)
			p.Match(SqlParserK_IF)
		}
		{
			p.SetState(583)
			p.Match(SqlParserK_NOT)
		}
		{
			p.SetState(584)
			p.Match(SqlParserK_EXISTS)
		}


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


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 64, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(587)
			p.Database_name()
		}
		{
			p.SetState(588)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(592)
		p.Table_name()
	}
	{
		p.SetState(593)
		p.Match(SqlParserK_USING)
	}
	{
		p.SetState(594)
		p.Module_name()
	}
	p.SetState(606)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserOPEN_PAR {
		{
			p.SetState(595)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(596)
			p.Module_argument()
		}
		p.SetState(601)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(597)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(598)
				p.Module_argument()
			}


			p.SetState(603)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(604)
			p.Match(SqlParserCLOSE_PAR)
		}

	}



	return localctx
}


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

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

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

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

func NewEmptyDelete_stmtContext() *Delete_stmtContext {
	var p = new(Delete_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_delete_stmt
	return p
}

func (*Delete_stmtContext) IsDelete_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_delete_stmt

	return p
}

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

func (s *Delete_stmtContext) K_DELETE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DELETE, 0)
}

func (s *Delete_stmtContext) K_FROM() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FROM, 0)
}

func (s *Delete_stmtContext) Qualified_table_name() IQualified_table_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IQualified_table_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IQualified_table_nameContext)
}

func (s *Delete_stmtContext) With_clause() IWith_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWith_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWith_clauseContext)
}

func (s *Delete_stmtContext) K_WHERE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WHERE, 0)
}

func (s *Delete_stmtContext) Expr() IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

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

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


func (s *Delete_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterDelete_stmt(s)
	}
}

func (s *Delete_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitDelete_stmt(s)
	}
}




func (p *SqlParser) Delete_stmt() (localctx IDelete_stmtContext) {
	localctx = NewDelete_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, SqlParserRULE_delete_stmt)
	var _la int


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

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

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


	if _la == SqlParserK_WITH {
		{
			p.SetState(608)
			p.With_clause()
		}

	}
	{
		p.SetState(611)
		p.Match(SqlParserK_DELETE)
	}
	{
		p.SetState(612)
		p.Match(SqlParserK_FROM)
	}
	{
		p.SetState(613)
		p.Qualified_table_name()
	}
	p.SetState(616)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_WHERE {
		{
			p.SetState(614)
			p.Match(SqlParserK_WHERE)
		}
		{
			p.SetState(615)
			p.expr(0)
		}

	}



	return localctx
}


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

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

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

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

func NewEmptyDelete_stmt_limitedContext() *Delete_stmt_limitedContext {
	var p = new(Delete_stmt_limitedContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_delete_stmt_limited
	return p
}

func (*Delete_stmt_limitedContext) IsDelete_stmt_limitedContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_delete_stmt_limited

	return p
}

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

func (s *Delete_stmt_limitedContext) K_DELETE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DELETE, 0)
}

func (s *Delete_stmt_limitedContext) K_FROM() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FROM, 0)
}

func (s *Delete_stmt_limitedContext) Qualified_table_name() IQualified_table_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IQualified_table_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IQualified_table_nameContext)
}

func (s *Delete_stmt_limitedContext) With_clause() IWith_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWith_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWith_clauseContext)
}

func (s *Delete_stmt_limitedContext) K_WHERE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WHERE, 0)
}

func (s *Delete_stmt_limitedContext) AllExpr() []IExprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExprContext)(nil)).Elem())
	var tst = make([]IExprContext, len(ts))

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

	return tst
}

func (s *Delete_stmt_limitedContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Delete_stmt_limitedContext) K_LIMIT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_LIMIT, 0)
}

func (s *Delete_stmt_limitedContext) K_ORDER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ORDER, 0)
}

func (s *Delete_stmt_limitedContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BY, 0)
}

func (s *Delete_stmt_limitedContext) AllOrdering_term() []IOrdering_termContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IOrdering_termContext)(nil)).Elem())
	var tst = make([]IOrdering_termContext, len(ts))

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

	return tst
}

func (s *Delete_stmt_limitedContext) Ordering_term(i int) IOrdering_termContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrdering_termContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IOrdering_termContext)
}

func (s *Delete_stmt_limitedContext) K_OFFSET() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OFFSET, 0)
}

func (s *Delete_stmt_limitedContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

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

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


func (s *Delete_stmt_limitedContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterDelete_stmt_limited(s)
	}
}

func (s *Delete_stmt_limitedContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitDelete_stmt_limited(s)
	}
}




func (p *SqlParser) Delete_stmt_limited() (localctx IDelete_stmt_limitedContext) {
	localctx = NewDelete_stmt_limitedContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, SqlParserRULE_delete_stmt_limited)
	var _la int


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

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

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


	if _la == SqlParserK_WITH {
		{
			p.SetState(618)
			p.With_clause()
		}

	}
	{
		p.SetState(621)
		p.Match(SqlParserK_DELETE)
	}
	{
		p.SetState(622)
		p.Match(SqlParserK_FROM)
	}
	{
		p.SetState(623)
		p.Qualified_table_name()
	}
	p.SetState(626)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_WHERE {
		{
			p.SetState(624)
			p.Match(SqlParserK_WHERE)
		}
		{
			p.SetState(625)
			p.expr(0)
		}

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


	if _la == SqlParserK_LIMIT || _la == SqlParserK_ORDER {
		p.SetState(638)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserK_ORDER {
			{
				p.SetState(628)
				p.Match(SqlParserK_ORDER)
			}
			{
				p.SetState(629)
				p.Match(SqlParserK_BY)
			}
			{
				p.SetState(630)
				p.Ordering_term()
			}
			p.SetState(635)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			for _la == SqlParserCOMMA {
				{
					p.SetState(631)
					p.Match(SqlParserCOMMA)
				}
				{
					p.SetState(632)
					p.Ordering_term()
				}


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

		}
		{
			p.SetState(640)
			p.Match(SqlParserK_LIMIT)
		}
		{
			p.SetState(641)
			p.expr(0)
		}
		p.SetState(644)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserCOMMA || _la == SqlParserK_OFFSET {
			{
				p.SetState(642)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SqlParserCOMMA || _la == SqlParserK_OFFSET) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(643)
				p.expr(0)
			}

		}

	}



	return localctx
}


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

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

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

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

func NewEmptyDetach_stmtContext() *Detach_stmtContext {
	var p = new(Detach_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_detach_stmt
	return p
}

func (*Detach_stmtContext) IsDetach_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_detach_stmt

	return p
}

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

func (s *Detach_stmtContext) K_DETACH() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DETACH, 0)
}

func (s *Detach_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Detach_stmtContext) K_DATABASE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DATABASE, 0)
}

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

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


func (s *Detach_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterDetach_stmt(s)
	}
}

func (s *Detach_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitDetach_stmt(s)
	}
}




func (p *SqlParser) Detach_stmt() (localctx IDetach_stmtContext) {
	localctx = NewDetach_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, SqlParserRULE_detach_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(648)
		p.Match(SqlParserK_DETACH)
	}
	p.SetState(650)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 75, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(649)
			p.Match(SqlParserK_DATABASE)
		}


	}
	{
		p.SetState(652)
		p.Database_name()
	}



	return localctx
}


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

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

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

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

func NewEmptyDrop_index_stmtContext() *Drop_index_stmtContext {
	var p = new(Drop_index_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_drop_index_stmt
	return p
}

func (*Drop_index_stmtContext) IsDrop_index_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_drop_index_stmt

	return p
}

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

func (s *Drop_index_stmtContext) K_DROP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DROP, 0)
}

func (s *Drop_index_stmtContext) K_INDEX() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INDEX, 0)
}

func (s *Drop_index_stmtContext) Index_name() IIndex_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndex_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndex_nameContext)
}

func (s *Drop_index_stmtContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IF, 0)
}

func (s *Drop_index_stmtContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXISTS, 0)
}

func (s *Drop_index_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Drop_index_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

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

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


func (s *Drop_index_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterDrop_index_stmt(s)
	}
}

func (s *Drop_index_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitDrop_index_stmt(s)
	}
}




func (p *SqlParser) Drop_index_stmt() (localctx IDrop_index_stmtContext) {
	localctx = NewDrop_index_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, SqlParserRULE_drop_index_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(654)
		p.Match(SqlParserK_DROP)
	}
	{
		p.SetState(655)
		p.Match(SqlParserK_INDEX)
	}
	p.SetState(658)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 76, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(656)
			p.Match(SqlParserK_IF)
		}
		{
			p.SetState(657)
			p.Match(SqlParserK_EXISTS)
		}


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


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 77, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(660)
			p.Database_name()
		}
		{
			p.SetState(661)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(665)
		p.Index_name()
	}



	return localctx
}


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

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

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

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

func NewEmptyDrop_table_stmtContext() *Drop_table_stmtContext {
	var p = new(Drop_table_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_drop_table_stmt
	return p
}

func (*Drop_table_stmtContext) IsDrop_table_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_drop_table_stmt

	return p
}

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

func (s *Drop_table_stmtContext) K_DROP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DROP, 0)
}

func (s *Drop_table_stmtContext) K_TABLE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TABLE, 0)
}

func (s *Drop_table_stmtContext) Table_name() ITable_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Drop_table_stmtContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IF, 0)
}

func (s *Drop_table_stmtContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXISTS, 0)
}

func (s *Drop_table_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Drop_table_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

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

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


func (s *Drop_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterDrop_table_stmt(s)
	}
}

func (s *Drop_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitDrop_table_stmt(s)
	}
}




func (p *SqlParser) Drop_table_stmt() (localctx IDrop_table_stmtContext) {
	localctx = NewDrop_table_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, SqlParserRULE_drop_table_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(667)
		p.Match(SqlParserK_DROP)
	}
	{
		p.SetState(668)
		p.Match(SqlParserK_TABLE)
	}
	p.SetState(671)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 78, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(669)
			p.Match(SqlParserK_IF)
		}
		{
			p.SetState(670)
			p.Match(SqlParserK_EXISTS)
		}


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


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 79, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(673)
			p.Database_name()
		}
		{
			p.SetState(674)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(678)
		p.Table_name()
	}



	return localctx
}


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

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

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

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

func NewEmptyDrop_trigger_stmtContext() *Drop_trigger_stmtContext {
	var p = new(Drop_trigger_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_drop_trigger_stmt
	return p
}

func (*Drop_trigger_stmtContext) IsDrop_trigger_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_drop_trigger_stmt

	return p
}

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

func (s *Drop_trigger_stmtContext) K_DROP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DROP, 0)
}

func (s *Drop_trigger_stmtContext) K_TRIGGER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TRIGGER, 0)
}

func (s *Drop_trigger_stmtContext) Trigger_name() ITrigger_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITrigger_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITrigger_nameContext)
}

func (s *Drop_trigger_stmtContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IF, 0)
}

func (s *Drop_trigger_stmtContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXISTS, 0)
}

func (s *Drop_trigger_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Drop_trigger_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

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

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


func (s *Drop_trigger_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterDrop_trigger_stmt(s)
	}
}

func (s *Drop_trigger_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitDrop_trigger_stmt(s)
	}
}




func (p *SqlParser) Drop_trigger_stmt() (localctx IDrop_trigger_stmtContext) {
	localctx = NewDrop_trigger_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, SqlParserRULE_drop_trigger_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(680)
		p.Match(SqlParserK_DROP)
	}
	{
		p.SetState(681)
		p.Match(SqlParserK_TRIGGER)
	}
	p.SetState(684)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 80, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(682)
			p.Match(SqlParserK_IF)
		}
		{
			p.SetState(683)
			p.Match(SqlParserK_EXISTS)
		}


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


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 81, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(686)
			p.Database_name()
		}
		{
			p.SetState(687)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(691)
		p.Trigger_name()
	}



	return localctx
}


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

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

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

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

func NewEmptyDrop_view_stmtContext() *Drop_view_stmtContext {
	var p = new(Drop_view_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_drop_view_stmt
	return p
}

func (*Drop_view_stmtContext) IsDrop_view_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_drop_view_stmt

	return p
}

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

func (s *Drop_view_stmtContext) K_DROP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DROP, 0)
}

func (s *Drop_view_stmtContext) K_VIEW() antlr.TerminalNode {
	return s.GetToken(SqlParserK_VIEW, 0)
}

func (s *Drop_view_stmtContext) View_name() IView_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IView_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IView_nameContext)
}

func (s *Drop_view_stmtContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IF, 0)
}

func (s *Drop_view_stmtContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXISTS, 0)
}

func (s *Drop_view_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Drop_view_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

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

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


func (s *Drop_view_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterDrop_view_stmt(s)
	}
}

func (s *Drop_view_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitDrop_view_stmt(s)
	}
}




func (p *SqlParser) Drop_view_stmt() (localctx IDrop_view_stmtContext) {
	localctx = NewDrop_view_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, SqlParserRULE_drop_view_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(693)
		p.Match(SqlParserK_DROP)
	}
	{
		p.SetState(694)
		p.Match(SqlParserK_VIEW)
	}
	p.SetState(697)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 82, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(695)
			p.Match(SqlParserK_IF)
		}
		{
			p.SetState(696)
			p.Match(SqlParserK_EXISTS)
		}


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


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 83, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(699)
			p.Database_name()
		}
		{
			p.SetState(700)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(704)
		p.View_name()
	}



	return localctx
}


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

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

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

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

func NewEmptyFactored_select_stmtContext() *Factored_select_stmtContext {
	var p = new(Factored_select_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_factored_select_stmt
	return p
}

func (*Factored_select_stmtContext) IsFactored_select_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_factored_select_stmt

	return p
}

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

func (s *Factored_select_stmtContext) AllSelect_core() []ISelect_coreContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISelect_coreContext)(nil)).Elem())
	var tst = make([]ISelect_coreContext, len(ts))

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

	return tst
}

func (s *Factored_select_stmtContext) Select_core(i int) ISelect_coreContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_coreContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISelect_coreContext)
}

func (s *Factored_select_stmtContext) K_WITH() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WITH, 0)
}

func (s *Factored_select_stmtContext) AllCommon_table_expression() []ICommon_table_expressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICommon_table_expressionContext)(nil)).Elem())
	var tst = make([]ICommon_table_expressionContext, len(ts))

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

	return tst
}

func (s *Factored_select_stmtContext) Common_table_expression(i int) ICommon_table_expressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommon_table_expressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICommon_table_expressionContext)
}

func (s *Factored_select_stmtContext) AllCompound_operator() []ICompound_operatorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICompound_operatorContext)(nil)).Elem())
	var tst = make([]ICompound_operatorContext, len(ts))

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

	return tst
}

func (s *Factored_select_stmtContext) Compound_operator(i int) ICompound_operatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompound_operatorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICompound_operatorContext)
}

func (s *Factored_select_stmtContext) K_ORDER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ORDER, 0)
}

func (s *Factored_select_stmtContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BY, 0)
}

func (s *Factored_select_stmtContext) AllOrdering_term() []IOrdering_termContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IOrdering_termContext)(nil)).Elem())
	var tst = make([]IOrdering_termContext, len(ts))

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

	return tst
}

func (s *Factored_select_stmtContext) Ordering_term(i int) IOrdering_termContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrdering_termContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IOrdering_termContext)
}

func (s *Factored_select_stmtContext) K_LIMIT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_LIMIT, 0)
}

func (s *Factored_select_stmtContext) AllExpr() []IExprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExprContext)(nil)).Elem())
	var tst = make([]IExprContext, len(ts))

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

	return tst
}

func (s *Factored_select_stmtContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Factored_select_stmtContext) K_RECURSIVE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_RECURSIVE, 0)
}

func (s *Factored_select_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

func (s *Factored_select_stmtContext) K_OFFSET() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OFFSET, 0)
}

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

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


func (s *Factored_select_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterFactored_select_stmt(s)
	}
}

func (s *Factored_select_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitFactored_select_stmt(s)
	}
}




func (p *SqlParser) Factored_select_stmt() (localctx IFactored_select_stmtContext) {
	localctx = NewFactored_select_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 50, SqlParserRULE_factored_select_stmt)
	var _la int


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

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

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


	if _la == SqlParserK_WITH {
		{
			p.SetState(706)
			p.Match(SqlParserK_WITH)
		}
		p.SetState(708)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 84, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(707)
				p.Match(SqlParserK_RECURSIVE)
			}


		}
		{
			p.SetState(710)
			p.Common_table_expression()
		}
		p.SetState(715)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(711)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(712)
				p.Common_table_expression()
			}


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

	}
	{
		p.SetState(720)
		p.Select_core()
	}
	p.SetState(726)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	for _la == SqlParserK_EXCEPT || _la == SqlParserK_INTERSECT || _la == SqlParserK_UNION {
		{
			p.SetState(721)
			p.Compound_operator()
		}
		{
			p.SetState(722)
			p.Select_core()
		}


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


	if _la == SqlParserK_ORDER {
		{
			p.SetState(729)
			p.Match(SqlParserK_ORDER)
		}
		{
			p.SetState(730)
			p.Match(SqlParserK_BY)
		}
		{
			p.SetState(731)
			p.Ordering_term()
		}
		p.SetState(736)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(732)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(733)
				p.Ordering_term()
			}


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

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


	if _la == SqlParserK_LIMIT {
		{
			p.SetState(741)
			p.Match(SqlParserK_LIMIT)
		}
		{
			p.SetState(742)
			p.expr(0)
		}
		p.SetState(745)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserCOMMA || _la == SqlParserK_OFFSET {
			{
				p.SetState(743)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SqlParserCOMMA || _la == SqlParserK_OFFSET) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(744)
				p.expr(0)
			}

		}

	}



	return localctx
}


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

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

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

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

func NewEmptyInsert_stmtContext() *Insert_stmtContext {
	var p = new(Insert_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_insert_stmt
	return p
}

func (*Insert_stmtContext) IsInsert_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_insert_stmt

	return p
}

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

func (s *Insert_stmtContext) K_INTO() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INTO, 0)
}

func (s *Insert_stmtContext) Table_name() ITable_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Insert_stmtContext) K_INSERT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INSERT, 0)
}

func (s *Insert_stmtContext) K_REPLACE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_REPLACE, 0)
}

func (s *Insert_stmtContext) K_OR() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OR, 0)
}

func (s *Insert_stmtContext) K_ROLLBACK() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ROLLBACK, 0)
}

func (s *Insert_stmtContext) K_ABORT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ABORT, 0)
}

func (s *Insert_stmtContext) K_FAIL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FAIL, 0)
}

func (s *Insert_stmtContext) K_IGNORE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IGNORE, 0)
}

func (s *Insert_stmtContext) K_VALUES() antlr.TerminalNode {
	return s.GetToken(SqlParserK_VALUES, 0)
}

func (s *Insert_stmtContext) AllOPEN_PAR() []antlr.TerminalNode {
	return s.GetTokens(SqlParserOPEN_PAR)
}

func (s *Insert_stmtContext) OPEN_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, i)
}

func (s *Insert_stmtContext) AllExpr() []IExprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExprContext)(nil)).Elem())
	var tst = make([]IExprContext, len(ts))

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

	return tst
}

func (s *Insert_stmtContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Insert_stmtContext) AllCLOSE_PAR() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCLOSE_PAR)
}

func (s *Insert_stmtContext) CLOSE_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, i)
}

func (s *Insert_stmtContext) Select_stmt() ISelect_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

func (s *Insert_stmtContext) K_DEFAULT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DEFAULT, 0)
}

func (s *Insert_stmtContext) With_clause() IWith_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWith_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWith_clauseContext)
}

func (s *Insert_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Insert_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

func (s *Insert_stmtContext) AllColumn_name() []IColumn_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem())
	var tst = make([]IColumn_nameContext, len(ts))

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

	return tst
}

func (s *Insert_stmtContext) Column_name(i int) IColumn_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

func (s *Insert_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

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

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


func (s *Insert_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterInsert_stmt(s)
	}
}

func (s *Insert_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitInsert_stmt(s)
	}
}




func (p *SqlParser) Insert_stmt() (localctx IInsert_stmtContext) {
	localctx = NewInsert_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, SqlParserRULE_insert_stmt)
	var _la int


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

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

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


	if _la == SqlParserK_WITH {
		{
			p.SetState(749)
			p.With_clause()
		}

	}
	p.SetState(769)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 93, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(752)
			p.Match(SqlParserK_INSERT)
		}


	case 2:
		{
			p.SetState(753)
			p.Match(SqlParserK_REPLACE)
		}


	case 3:
		{
			p.SetState(754)
			p.Match(SqlParserK_INSERT)
		}
		{
			p.SetState(755)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(756)
			p.Match(SqlParserK_REPLACE)
		}


	case 4:
		{
			p.SetState(757)
			p.Match(SqlParserK_INSERT)
		}
		{
			p.SetState(758)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(759)
			p.Match(SqlParserK_ROLLBACK)
		}


	case 5:
		{
			p.SetState(760)
			p.Match(SqlParserK_INSERT)
		}
		{
			p.SetState(761)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(762)
			p.Match(SqlParserK_ABORT)
		}


	case 6:
		{
			p.SetState(763)
			p.Match(SqlParserK_INSERT)
		}
		{
			p.SetState(764)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(765)
			p.Match(SqlParserK_FAIL)
		}


	case 7:
		{
			p.SetState(766)
			p.Match(SqlParserK_INSERT)
		}
		{
			p.SetState(767)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(768)
			p.Match(SqlParserK_IGNORE)
		}

	}
	{
		p.SetState(771)
		p.Match(SqlParserK_INTO)
	}
	p.SetState(775)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 94, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(772)
			p.Database_name()
		}
		{
			p.SetState(773)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(777)
		p.Table_name()
	}
	p.SetState(789)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserOPEN_PAR {
		{
			p.SetState(778)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(779)
			p.Column_name()
		}
		p.SetState(784)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(780)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(781)
				p.Column_name()
			}


			p.SetState(786)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(787)
			p.Match(SqlParserCLOSE_PAR)
		}

	}
	p.SetState(822)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 100, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(791)
			p.Match(SqlParserK_VALUES)
		}
		{
			p.SetState(792)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(793)
			p.expr(0)
		}
		p.SetState(798)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(794)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(795)
				p.expr(0)
			}


			p.SetState(800)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(801)
			p.Match(SqlParserCLOSE_PAR)
		}
		p.SetState(816)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(802)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(803)
				p.Match(SqlParserOPEN_PAR)
			}
			{
				p.SetState(804)
				p.expr(0)
			}
			p.SetState(809)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			for _la == SqlParserCOMMA {
				{
					p.SetState(805)
					p.Match(SqlParserCOMMA)
				}
				{
					p.SetState(806)
					p.expr(0)
				}


				p.SetState(811)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(812)
				p.Match(SqlParserCLOSE_PAR)
			}


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


	case 2:
		{
			p.SetState(819)
			p.Select_stmt()
		}


	case 3:
		{
			p.SetState(820)
			p.Match(SqlParserK_DEFAULT)
		}
		{
			p.SetState(821)
			p.Match(SqlParserK_VALUES)
		}

	}



	return localctx
}


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

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

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

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

func NewEmptyPragma_stmtContext() *Pragma_stmtContext {
	var p = new(Pragma_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_pragma_stmt
	return p
}

func (*Pragma_stmtContext) IsPragma_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_pragma_stmt

	return p
}

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

func (s *Pragma_stmtContext) K_PRAGMA() antlr.TerminalNode {
	return s.GetToken(SqlParserK_PRAGMA, 0)
}

func (s *Pragma_stmtContext) Pragma_name() IPragma_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPragma_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPragma_nameContext)
}

func (s *Pragma_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Pragma_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

func (s *Pragma_stmtContext) ASSIGN() antlr.TerminalNode {
	return s.GetToken(SqlParserASSIGN, 0)
}

func (s *Pragma_stmtContext) Pragma_value() IPragma_valueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPragma_valueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPragma_valueContext)
}

func (s *Pragma_stmtContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Pragma_stmtContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

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

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


func (s *Pragma_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterPragma_stmt(s)
	}
}

func (s *Pragma_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitPragma_stmt(s)
	}
}




func (p *SqlParser) Pragma_stmt() (localctx IPragma_stmtContext) {
	localctx = NewPragma_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 54, SqlParserRULE_pragma_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(824)
		p.Match(SqlParserK_PRAGMA)
	}
	p.SetState(828)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 101, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(825)
			p.Database_name()
		}
		{
			p.SetState(826)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(830)
		p.Pragma_name()
	}
	p.SetState(837)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SqlParserASSIGN:
		{
			p.SetState(831)
			p.Match(SqlParserASSIGN)
		}
		{
			p.SetState(832)
			p.Pragma_value()
		}


	case SqlParserOPEN_PAR:
		{
			p.SetState(833)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(834)
			p.Pragma_value()
		}
		{
			p.SetState(835)
			p.Match(SqlParserCLOSE_PAR)
		}


	case SqlParserEOF, SqlParserSCOL, SqlParserK_ALTER, SqlParserK_ANALYZE, SqlParserK_ATTACH, SqlParserK_BEGIN, SqlParserK_COMMIT, SqlParserK_CREATE, SqlParserK_DELETE, SqlParserK_DETACH, SqlParserK_DROP, SqlParserK_END, SqlParserK_EXPLAIN, SqlParserK_INSERT, SqlParserK_PRAGMA, SqlParserK_REINDEX, SqlParserK_RELEASE, SqlParserK_REPLACE, SqlParserK_ROLLBACK, SqlParserK_SAVEPOINT, SqlParserK_SELECT, SqlParserK_UPDATE, SqlParserK_VACUUM, SqlParserK_VALUES, SqlParserK_WITH, SqlParserUNEXPECTED_CHAR:



	default:
	}



	return localctx
}


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

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

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

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

func NewEmptyReindex_stmtContext() *Reindex_stmtContext {
	var p = new(Reindex_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_reindex_stmt
	return p
}

func (*Reindex_stmtContext) IsReindex_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_reindex_stmt

	return p
}

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

func (s *Reindex_stmtContext) K_REINDEX() antlr.TerminalNode {
	return s.GetToken(SqlParserK_REINDEX, 0)
}

func (s *Reindex_stmtContext) Collation_name() ICollation_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollation_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICollation_nameContext)
}

func (s *Reindex_stmtContext) Table_name() ITable_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Reindex_stmtContext) Index_name() IIndex_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndex_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndex_nameContext)
}

func (s *Reindex_stmtContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Reindex_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

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

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


func (s *Reindex_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterReindex_stmt(s)
	}
}

func (s *Reindex_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitReindex_stmt(s)
	}
}




func (p *SqlParser) Reindex_stmt() (localctx IReindex_stmtContext) {
	localctx = NewReindex_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, SqlParserRULE_reindex_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(839)
		p.Match(SqlParserK_REINDEX)
	}
	p.SetState(850)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 105, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(840)
			p.Collation_name()
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 105, p.GetParserRuleContext()) == 2 {
		p.SetState(844)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 103, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(841)
				p.Database_name()
			}
			{
				p.SetState(842)
				p.Match(SqlParserDOT)
			}


		}
		p.SetState(848)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 104, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(846)
				p.Table_name()
			}


		case 2:
			{
				p.SetState(847)
				p.Index_name()
			}

		}


	}



	return localctx
}


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

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

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

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

func NewEmptyRelease_stmtContext() *Release_stmtContext {
	var p = new(Release_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_release_stmt
	return p
}

func (*Release_stmtContext) IsRelease_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_release_stmt

	return p
}

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

func (s *Release_stmtContext) K_RELEASE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_RELEASE, 0)
}

func (s *Release_stmtContext) Savepoint_name() ISavepoint_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISavepoint_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISavepoint_nameContext)
}

func (s *Release_stmtContext) K_SAVEPOINT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_SAVEPOINT, 0)
}

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

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


func (s *Release_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterRelease_stmt(s)
	}
}

func (s *Release_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitRelease_stmt(s)
	}
}




func (p *SqlParser) Release_stmt() (localctx IRelease_stmtContext) {
	localctx = NewRelease_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, SqlParserRULE_release_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(852)
		p.Match(SqlParserK_RELEASE)
	}
	p.SetState(854)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 106, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(853)
			p.Match(SqlParserK_SAVEPOINT)
		}


	}
	{
		p.SetState(856)
		p.Savepoint_name()
	}



	return localctx
}


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

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

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

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

func NewEmptyRollback_stmtContext() *Rollback_stmtContext {
	var p = new(Rollback_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_rollback_stmt
	return p
}

func (*Rollback_stmtContext) IsRollback_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_rollback_stmt

	return p
}

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

func (s *Rollback_stmtContext) K_ROLLBACK() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ROLLBACK, 0)
}

func (s *Rollback_stmtContext) K_TRANSACTION() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TRANSACTION, 0)
}

func (s *Rollback_stmtContext) K_TO() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TO, 0)
}

func (s *Rollback_stmtContext) Savepoint_name() ISavepoint_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISavepoint_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISavepoint_nameContext)
}

func (s *Rollback_stmtContext) Transaction_name() ITransaction_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITransaction_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITransaction_nameContext)
}

func (s *Rollback_stmtContext) K_SAVEPOINT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_SAVEPOINT, 0)
}

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

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


func (s *Rollback_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterRollback_stmt(s)
	}
}

func (s *Rollback_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitRollback_stmt(s)
	}
}




func (p *SqlParser) Rollback_stmt() (localctx IRollback_stmtContext) {
	localctx = NewRollback_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 60, SqlParserRULE_rollback_stmt)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(858)
		p.Match(SqlParserK_ROLLBACK)
	}
	p.SetState(863)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_TRANSACTION {
		{
			p.SetState(859)
			p.Match(SqlParserK_TRANSACTION)
		}
		p.SetState(861)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 107, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(860)
				p.Transaction_name()
			}


		}

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


	if _la == SqlParserK_TO {
		{
			p.SetState(865)
			p.Match(SqlParserK_TO)
		}
		p.SetState(867)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 109, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(866)
				p.Match(SqlParserK_SAVEPOINT)
			}


		}
		{
			p.SetState(869)
			p.Savepoint_name()
		}

	}



	return localctx
}


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

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

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

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

func NewEmptySavepoint_stmtContext() *Savepoint_stmtContext {
	var p = new(Savepoint_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_savepoint_stmt
	return p
}

func (*Savepoint_stmtContext) IsSavepoint_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_savepoint_stmt

	return p
}

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

func (s *Savepoint_stmtContext) K_SAVEPOINT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_SAVEPOINT, 0)
}

func (s *Savepoint_stmtContext) Savepoint_name() ISavepoint_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISavepoint_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISavepoint_nameContext)
}

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

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


func (s *Savepoint_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterSavepoint_stmt(s)
	}
}

func (s *Savepoint_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitSavepoint_stmt(s)
	}
}




func (p *SqlParser) Savepoint_stmt() (localctx ISavepoint_stmtContext) {
	localctx = NewSavepoint_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 62, SqlParserRULE_savepoint_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(872)
		p.Match(SqlParserK_SAVEPOINT)
	}
	{
		p.SetState(873)
		p.Savepoint_name()
	}



	return localctx
}


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

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

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

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

func NewEmptySimple_select_stmtContext() *Simple_select_stmtContext {
	var p = new(Simple_select_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_simple_select_stmt
	return p
}

func (*Simple_select_stmtContext) IsSimple_select_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_simple_select_stmt

	return p
}

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

func (s *Simple_select_stmtContext) Select_core() ISelect_coreContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_coreContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelect_coreContext)
}

func (s *Simple_select_stmtContext) K_WITH() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WITH, 0)
}

func (s *Simple_select_stmtContext) AllCommon_table_expression() []ICommon_table_expressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICommon_table_expressionContext)(nil)).Elem())
	var tst = make([]ICommon_table_expressionContext, len(ts))

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

	return tst
}

func (s *Simple_select_stmtContext) Common_table_expression(i int) ICommon_table_expressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommon_table_expressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICommon_table_expressionContext)
}

func (s *Simple_select_stmtContext) K_ORDER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ORDER, 0)
}

func (s *Simple_select_stmtContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BY, 0)
}

func (s *Simple_select_stmtContext) AllOrdering_term() []IOrdering_termContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IOrdering_termContext)(nil)).Elem())
	var tst = make([]IOrdering_termContext, len(ts))

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

	return tst
}

func (s *Simple_select_stmtContext) Ordering_term(i int) IOrdering_termContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrdering_termContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IOrdering_termContext)
}

func (s *Simple_select_stmtContext) K_LIMIT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_LIMIT, 0)
}

func (s *Simple_select_stmtContext) AllExpr() []IExprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExprContext)(nil)).Elem())
	var tst = make([]IExprContext, len(ts))

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

	return tst
}

func (s *Simple_select_stmtContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Simple_select_stmtContext) K_RECURSIVE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_RECURSIVE, 0)
}

func (s *Simple_select_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

func (s *Simple_select_stmtContext) K_OFFSET() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OFFSET, 0)
}

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

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


func (s *Simple_select_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterSimple_select_stmt(s)
	}
}

func (s *Simple_select_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitSimple_select_stmt(s)
	}
}




func (p *SqlParser) Simple_select_stmt() (localctx ISimple_select_stmtContext) {
	localctx = NewSimple_select_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 64, SqlParserRULE_simple_select_stmt)
	var _la int


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

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

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


	if _la == SqlParserK_WITH {
		{
			p.SetState(875)
			p.Match(SqlParserK_WITH)
		}
		p.SetState(877)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 111, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(876)
				p.Match(SqlParserK_RECURSIVE)
			}


		}
		{
			p.SetState(879)
			p.Common_table_expression()
		}
		p.SetState(884)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(880)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(881)
				p.Common_table_expression()
			}


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

	}
	{
		p.SetState(889)
		p.Select_core()
	}
	p.SetState(900)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_ORDER {
		{
			p.SetState(890)
			p.Match(SqlParserK_ORDER)
		}
		{
			p.SetState(891)
			p.Match(SqlParserK_BY)
		}
		{
			p.SetState(892)
			p.Ordering_term()
		}
		p.SetState(897)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(893)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(894)
				p.Ordering_term()
			}


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

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


	if _la == SqlParserK_LIMIT {
		{
			p.SetState(902)
			p.Match(SqlParserK_LIMIT)
		}
		{
			p.SetState(903)
			p.expr(0)
		}
		p.SetState(906)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserCOMMA || _la == SqlParserK_OFFSET {
			{
				p.SetState(904)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SqlParserCOMMA || _la == SqlParserK_OFFSET) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(905)
				p.expr(0)
			}

		}

	}



	return localctx
}


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

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

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

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

func NewEmptySelect_stmtContext() *Select_stmtContext {
	var p = new(Select_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_select_stmt
	return p
}

func (*Select_stmtContext) IsSelect_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_select_stmt

	return p
}

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

func (s *Select_stmtContext) AllSelect_or_values() []ISelect_or_valuesContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISelect_or_valuesContext)(nil)).Elem())
	var tst = make([]ISelect_or_valuesContext, len(ts))

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

	return tst
}

func (s *Select_stmtContext) Select_or_values(i int) ISelect_or_valuesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_or_valuesContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISelect_or_valuesContext)
}

func (s *Select_stmtContext) K_WITH() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WITH, 0)
}

func (s *Select_stmtContext) AllCommon_table_expression() []ICommon_table_expressionContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICommon_table_expressionContext)(nil)).Elem())
	var tst = make([]ICommon_table_expressionContext, len(ts))

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

	return tst
}

func (s *Select_stmtContext) Common_table_expression(i int) ICommon_table_expressionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommon_table_expressionContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICommon_table_expressionContext)
}

func (s *Select_stmtContext) AllCompound_operator() []ICompound_operatorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICompound_operatorContext)(nil)).Elem())
	var tst = make([]ICompound_operatorContext, len(ts))

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

	return tst
}

func (s *Select_stmtContext) Compound_operator(i int) ICompound_operatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompound_operatorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICompound_operatorContext)
}

func (s *Select_stmtContext) K_ORDER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ORDER, 0)
}

func (s *Select_stmtContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BY, 0)
}

func (s *Select_stmtContext) AllOrdering_term() []IOrdering_termContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IOrdering_termContext)(nil)).Elem())
	var tst = make([]IOrdering_termContext, len(ts))

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

	return tst
}

func (s *Select_stmtContext) Ordering_term(i int) IOrdering_termContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrdering_termContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IOrdering_termContext)
}

func (s *Select_stmtContext) K_LIMIT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_LIMIT, 0)
}

func (s *Select_stmtContext) AllExpr() []IExprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExprContext)(nil)).Elem())
	var tst = make([]IExprContext, len(ts))

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

	return tst
}

func (s *Select_stmtContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Select_stmtContext) K_RECURSIVE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_RECURSIVE, 0)
}

func (s *Select_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

func (s *Select_stmtContext) K_OFFSET() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OFFSET, 0)
}

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

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


func (s *Select_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterSelect_stmt(s)
	}
}

func (s *Select_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitSelect_stmt(s)
	}
}




func (p *SqlParser) Select_stmt() (localctx ISelect_stmtContext) {
	localctx = NewSelect_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, SqlParserRULE_select_stmt)
	var _la int


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

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

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


	if _la == SqlParserK_WITH {
		{
			p.SetState(910)
			p.Match(SqlParserK_WITH)
		}
		p.SetState(912)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 118, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(911)
				p.Match(SqlParserK_RECURSIVE)
			}


		}
		{
			p.SetState(914)
			p.Common_table_expression()
		}
		p.SetState(919)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(915)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(916)
				p.Common_table_expression()
			}


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

	}
	{
		p.SetState(924)
		p.Select_or_values()
	}
	p.SetState(930)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	for _la == SqlParserK_EXCEPT || _la == SqlParserK_INTERSECT || _la == SqlParserK_UNION {
		{
			p.SetState(925)
			p.Compound_operator()
		}
		{
			p.SetState(926)
			p.Select_or_values()
		}


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


	if _la == SqlParserK_ORDER {
		{
			p.SetState(933)
			p.Match(SqlParserK_ORDER)
		}
		{
			p.SetState(934)
			p.Match(SqlParserK_BY)
		}
		{
			p.SetState(935)
			p.Ordering_term()
		}
		p.SetState(940)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(936)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(937)
				p.Ordering_term()
			}


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

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


	if _la == SqlParserK_LIMIT {
		{
			p.SetState(945)
			p.Match(SqlParserK_LIMIT)
		}
		{
			p.SetState(946)
			p.expr(0)
		}
		p.SetState(949)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserCOMMA || _la == SqlParserK_OFFSET {
			{
				p.SetState(947)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SqlParserCOMMA || _la == SqlParserK_OFFSET) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(948)
				p.expr(0)
			}

		}

	}



	return localctx
}


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

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

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

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

func NewEmptySelect_or_valuesContext() *Select_or_valuesContext {
	var p = new(Select_or_valuesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_select_or_values
	return p
}

func (*Select_or_valuesContext) IsSelect_or_valuesContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_select_or_values

	return p
}

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

func (s *Select_or_valuesContext) K_SELECT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_SELECT, 0)
}

func (s *Select_or_valuesContext) AllResult_column() []IResult_columnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IResult_columnContext)(nil)).Elem())
	var tst = make([]IResult_columnContext, len(ts))

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

	return tst
}

func (s *Select_or_valuesContext) Result_column(i int) IResult_columnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResult_columnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IResult_columnContext)
}

func (s *Select_or_valuesContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

func (s *Select_or_valuesContext) K_FROM() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FROM, 0)
}

func (s *Select_or_valuesContext) K_WHERE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WHERE, 0)
}

func (s *Select_or_valuesContext) AllExpr() []IExprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExprContext)(nil)).Elem())
	var tst = make([]IExprContext, len(ts))

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

	return tst
}

func (s *Select_or_valuesContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Select_or_valuesContext) K_GROUP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_GROUP, 0)
}

func (s *Select_or_valuesContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BY, 0)
}

func (s *Select_or_valuesContext) K_DISTINCT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DISTINCT, 0)
}

func (s *Select_or_valuesContext) K_ALL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ALL, 0)
}

func (s *Select_or_valuesContext) AllTable_or_subquery() []ITable_or_subqueryContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITable_or_subqueryContext)(nil)).Elem())
	var tst = make([]ITable_or_subqueryContext, len(ts))

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

	return tst
}

func (s *Select_or_valuesContext) Table_or_subquery(i int) ITable_or_subqueryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_or_subqueryContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITable_or_subqueryContext)
}

func (s *Select_or_valuesContext) Join_clause() IJoin_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IJoin_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IJoin_clauseContext)
}

func (s *Select_or_valuesContext) K_HAVING() antlr.TerminalNode {
	return s.GetToken(SqlParserK_HAVING, 0)
}

func (s *Select_or_valuesContext) K_VALUES() antlr.TerminalNode {
	return s.GetToken(SqlParserK_VALUES, 0)
}

func (s *Select_or_valuesContext) AllOPEN_PAR() []antlr.TerminalNode {
	return s.GetTokens(SqlParserOPEN_PAR)
}

func (s *Select_or_valuesContext) OPEN_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, i)
}

func (s *Select_or_valuesContext) AllCLOSE_PAR() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCLOSE_PAR)
}

func (s *Select_or_valuesContext) CLOSE_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, i)
}

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

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


func (s *Select_or_valuesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterSelect_or_values(s)
	}
}

func (s *Select_or_valuesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitSelect_or_values(s)
	}
}




func (p *SqlParser) Select_or_values() (localctx ISelect_or_valuesContext) {
	localctx = NewSelect_or_valuesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, SqlParserRULE_select_or_values)
	var _la int


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

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

	p.SetState(1027)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SqlParserK_SELECT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(953)
			p.Match(SqlParserK_SELECT)
		}
		p.SetState(955)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 126, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(954)
				_la = p.GetTokenStream().LA(1)

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


		}
		{
			p.SetState(957)
			p.Result_column()
		}
		p.SetState(962)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(958)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(959)
				p.Result_column()
			}


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


		if _la == SqlParserK_FROM {
			{
				p.SetState(965)
				p.Match(SqlParserK_FROM)
			}
			p.SetState(975)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 129, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(966)
					p.Table_or_subquery()
				}
				p.SetState(971)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)


				for _la == SqlParserCOMMA {
					{
						p.SetState(967)
						p.Match(SqlParserCOMMA)
					}
					{
						p.SetState(968)
						p.Table_or_subquery()
					}


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


			case 2:
				{
					p.SetState(974)
					p.Join_clause()
				}

			}

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


		if _la == SqlParserK_WHERE {
			{
				p.SetState(979)
				p.Match(SqlParserK_WHERE)
			}
			{
				p.SetState(980)
				p.expr(0)
			}

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


		if _la == SqlParserK_GROUP {
			{
				p.SetState(983)
				p.Match(SqlParserK_GROUP)
			}
			{
				p.SetState(984)
				p.Match(SqlParserK_BY)
			}
			{
				p.SetState(985)
				p.expr(0)
			}
			p.SetState(990)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			for _la == SqlParserCOMMA {
				{
					p.SetState(986)
					p.Match(SqlParserCOMMA)
				}
				{
					p.SetState(987)
					p.expr(0)
				}


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


			if _la == SqlParserK_HAVING {
				{
					p.SetState(993)
					p.Match(SqlParserK_HAVING)
				}
				{
					p.SetState(994)
					p.expr(0)
				}

			}

		}


	case SqlParserK_VALUES:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(999)
			p.Match(SqlParserK_VALUES)
		}
		{
			p.SetState(1000)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1001)
			p.expr(0)
		}
		p.SetState(1006)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(1002)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(1003)
				p.expr(0)
			}


			p.SetState(1008)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1009)
			p.Match(SqlParserCLOSE_PAR)
		}
		p.SetState(1024)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(1010)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(1011)
				p.Match(SqlParserOPEN_PAR)
			}
			{
				p.SetState(1012)
				p.expr(0)
			}
			p.SetState(1017)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			for _la == SqlParserCOMMA {
				{
					p.SetState(1013)
					p.Match(SqlParserCOMMA)
				}
				{
					p.SetState(1014)
					p.expr(0)
				}


				p.SetState(1019)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(1020)
				p.Match(SqlParserCLOSE_PAR)
			}


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



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


	return localctx
}


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

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

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

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

func NewEmptyUpdate_stmtContext() *Update_stmtContext {
	var p = new(Update_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_update_stmt
	return p
}

func (*Update_stmtContext) IsUpdate_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_update_stmt

	return p
}

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

func (s *Update_stmtContext) K_UPDATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_UPDATE, 0)
}

func (s *Update_stmtContext) Qualified_table_name() IQualified_table_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IQualified_table_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IQualified_table_nameContext)
}

func (s *Update_stmtContext) K_SET() antlr.TerminalNode {
	return s.GetToken(SqlParserK_SET, 0)
}

func (s *Update_stmtContext) AllColumn_name() []IColumn_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem())
	var tst = make([]IColumn_nameContext, len(ts))

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

	return tst
}

func (s *Update_stmtContext) Column_name(i int) IColumn_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

func (s *Update_stmtContext) AllASSIGN() []antlr.TerminalNode {
	return s.GetTokens(SqlParserASSIGN)
}

func (s *Update_stmtContext) ASSIGN(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserASSIGN, i)
}

func (s *Update_stmtContext) AllExpr() []IExprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExprContext)(nil)).Elem())
	var tst = make([]IExprContext, len(ts))

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

	return tst
}

func (s *Update_stmtContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Update_stmtContext) With_clause() IWith_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWith_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWith_clauseContext)
}

func (s *Update_stmtContext) K_OR() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OR, 0)
}

func (s *Update_stmtContext) K_ROLLBACK() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ROLLBACK, 0)
}

func (s *Update_stmtContext) K_ABORT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ABORT, 0)
}

func (s *Update_stmtContext) K_REPLACE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_REPLACE, 0)
}

func (s *Update_stmtContext) K_FAIL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FAIL, 0)
}

func (s *Update_stmtContext) K_IGNORE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IGNORE, 0)
}

func (s *Update_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

func (s *Update_stmtContext) K_WHERE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WHERE, 0)
}

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

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


func (s *Update_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterUpdate_stmt(s)
	}
}

func (s *Update_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitUpdate_stmt(s)
	}
}




func (p *SqlParser) Update_stmt() (localctx IUpdate_stmtContext) {
	localctx = NewUpdate_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, SqlParserRULE_update_stmt)
	var _la int


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

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

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


	if _la == SqlParserK_WITH {
		{
			p.SetState(1029)
			p.With_clause()
		}

	}
	{
		p.SetState(1032)
		p.Match(SqlParserK_UPDATE)
	}
	p.SetState(1043)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 140, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1033)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(1034)
			p.Match(SqlParserK_ROLLBACK)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 140, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(1035)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(1036)
			p.Match(SqlParserK_ABORT)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 140, p.GetParserRuleContext()) == 3 {
		{
			p.SetState(1037)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(1038)
			p.Match(SqlParserK_REPLACE)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 140, p.GetParserRuleContext()) == 4 {
		{
			p.SetState(1039)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(1040)
			p.Match(SqlParserK_FAIL)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 140, p.GetParserRuleContext()) == 5 {
		{
			p.SetState(1041)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(1042)
			p.Match(SqlParserK_IGNORE)
		}


	}
	{
		p.SetState(1045)
		p.Qualified_table_name()
	}
	{
		p.SetState(1046)
		p.Match(SqlParserK_SET)
	}
	{
		p.SetState(1047)
		p.Column_name()
	}
	{
		p.SetState(1048)
		p.Match(SqlParserASSIGN)
	}
	{
		p.SetState(1049)
		p.expr(0)
	}
	p.SetState(1057)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	for _la == SqlParserCOMMA {
		{
			p.SetState(1050)
			p.Match(SqlParserCOMMA)
		}
		{
			p.SetState(1051)
			p.Column_name()
		}
		{
			p.SetState(1052)
			p.Match(SqlParserASSIGN)
		}
		{
			p.SetState(1053)
			p.expr(0)
		}


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


	if _la == SqlParserK_WHERE {
		{
			p.SetState(1060)
			p.Match(SqlParserK_WHERE)
		}
		{
			p.SetState(1061)
			p.expr(0)
		}

	}



	return localctx
}


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

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

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

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

func NewEmptyUpdate_stmt_limitedContext() *Update_stmt_limitedContext {
	var p = new(Update_stmt_limitedContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_update_stmt_limited
	return p
}

func (*Update_stmt_limitedContext) IsUpdate_stmt_limitedContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_update_stmt_limited

	return p
}

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

func (s *Update_stmt_limitedContext) K_UPDATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_UPDATE, 0)
}

func (s *Update_stmt_limitedContext) Qualified_table_name() IQualified_table_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IQualified_table_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IQualified_table_nameContext)
}

func (s *Update_stmt_limitedContext) K_SET() antlr.TerminalNode {
	return s.GetToken(SqlParserK_SET, 0)
}

func (s *Update_stmt_limitedContext) AllColumn_name() []IColumn_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem())
	var tst = make([]IColumn_nameContext, len(ts))

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

	return tst
}

func (s *Update_stmt_limitedContext) Column_name(i int) IColumn_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

func (s *Update_stmt_limitedContext) AllASSIGN() []antlr.TerminalNode {
	return s.GetTokens(SqlParserASSIGN)
}

func (s *Update_stmt_limitedContext) ASSIGN(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserASSIGN, i)
}

func (s *Update_stmt_limitedContext) AllExpr() []IExprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExprContext)(nil)).Elem())
	var tst = make([]IExprContext, len(ts))

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

	return tst
}

func (s *Update_stmt_limitedContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Update_stmt_limitedContext) With_clause() IWith_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWith_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWith_clauseContext)
}

func (s *Update_stmt_limitedContext) K_OR() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OR, 0)
}

func (s *Update_stmt_limitedContext) K_ROLLBACK() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ROLLBACK, 0)
}

func (s *Update_stmt_limitedContext) K_ABORT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ABORT, 0)
}

func (s *Update_stmt_limitedContext) K_REPLACE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_REPLACE, 0)
}

func (s *Update_stmt_limitedContext) K_FAIL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FAIL, 0)
}

func (s *Update_stmt_limitedContext) K_IGNORE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IGNORE, 0)
}

func (s *Update_stmt_limitedContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

func (s *Update_stmt_limitedContext) K_WHERE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WHERE, 0)
}

func (s *Update_stmt_limitedContext) K_LIMIT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_LIMIT, 0)
}

func (s *Update_stmt_limitedContext) K_ORDER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ORDER, 0)
}

func (s *Update_stmt_limitedContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BY, 0)
}

func (s *Update_stmt_limitedContext) AllOrdering_term() []IOrdering_termContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IOrdering_termContext)(nil)).Elem())
	var tst = make([]IOrdering_termContext, len(ts))

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

	return tst
}

func (s *Update_stmt_limitedContext) Ordering_term(i int) IOrdering_termContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrdering_termContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IOrdering_termContext)
}

func (s *Update_stmt_limitedContext) K_OFFSET() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OFFSET, 0)
}

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

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


func (s *Update_stmt_limitedContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterUpdate_stmt_limited(s)
	}
}

func (s *Update_stmt_limitedContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitUpdate_stmt_limited(s)
	}
}




func (p *SqlParser) Update_stmt_limited() (localctx IUpdate_stmt_limitedContext) {
	localctx = NewUpdate_stmt_limitedContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, SqlParserRULE_update_stmt_limited)
	var _la int


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

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

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


	if _la == SqlParserK_WITH {
		{
			p.SetState(1064)
			p.With_clause()
		}

	}
	{
		p.SetState(1067)
		p.Match(SqlParserK_UPDATE)
	}
	p.SetState(1078)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 144, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1068)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(1069)
			p.Match(SqlParserK_ROLLBACK)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 144, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(1070)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(1071)
			p.Match(SqlParserK_ABORT)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 144, p.GetParserRuleContext()) == 3 {
		{
			p.SetState(1072)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(1073)
			p.Match(SqlParserK_REPLACE)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 144, p.GetParserRuleContext()) == 4 {
		{
			p.SetState(1074)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(1075)
			p.Match(SqlParserK_FAIL)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 144, p.GetParserRuleContext()) == 5 {
		{
			p.SetState(1076)
			p.Match(SqlParserK_OR)
		}
		{
			p.SetState(1077)
			p.Match(SqlParserK_IGNORE)
		}


	}
	{
		p.SetState(1080)
		p.Qualified_table_name()
	}
	{
		p.SetState(1081)
		p.Match(SqlParserK_SET)
	}
	{
		p.SetState(1082)
		p.Column_name()
	}
	{
		p.SetState(1083)
		p.Match(SqlParserASSIGN)
	}
	{
		p.SetState(1084)
		p.expr(0)
	}
	p.SetState(1092)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	for _la == SqlParserCOMMA {
		{
			p.SetState(1085)
			p.Match(SqlParserCOMMA)
		}
		{
			p.SetState(1086)
			p.Column_name()
		}
		{
			p.SetState(1087)
			p.Match(SqlParserASSIGN)
		}
		{
			p.SetState(1088)
			p.expr(0)
		}


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


	if _la == SqlParserK_WHERE {
		{
			p.SetState(1095)
			p.Match(SqlParserK_WHERE)
		}
		{
			p.SetState(1096)
			p.expr(0)
		}

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


	if _la == SqlParserK_LIMIT || _la == SqlParserK_ORDER {
		p.SetState(1109)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserK_ORDER {
			{
				p.SetState(1099)
				p.Match(SqlParserK_ORDER)
			}
			{
				p.SetState(1100)
				p.Match(SqlParserK_BY)
			}
			{
				p.SetState(1101)
				p.Ordering_term()
			}
			p.SetState(1106)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			for _la == SqlParserCOMMA {
				{
					p.SetState(1102)
					p.Match(SqlParserCOMMA)
				}
				{
					p.SetState(1103)
					p.Ordering_term()
				}


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

		}
		{
			p.SetState(1111)
			p.Match(SqlParserK_LIMIT)
		}
		{
			p.SetState(1112)
			p.expr(0)
		}
		p.SetState(1115)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserCOMMA || _la == SqlParserK_OFFSET {
			{
				p.SetState(1113)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SqlParserCOMMA || _la == SqlParserK_OFFSET) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(1114)
				p.expr(0)
			}

		}

	}



	return localctx
}


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

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

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

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

func NewEmptyVacuum_stmtContext() *Vacuum_stmtContext {
	var p = new(Vacuum_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_vacuum_stmt
	return p
}

func (*Vacuum_stmtContext) IsVacuum_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_vacuum_stmt

	return p
}

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

func (s *Vacuum_stmtContext) K_VACUUM() antlr.TerminalNode {
	return s.GetToken(SqlParserK_VACUUM, 0)
}

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

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


func (s *Vacuum_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterVacuum_stmt(s)
	}
}

func (s *Vacuum_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitVacuum_stmt(s)
	}
}




func (p *SqlParser) Vacuum_stmt() (localctx IVacuum_stmtContext) {
	localctx = NewVacuum_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, SqlParserRULE_vacuum_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1119)
		p.Match(SqlParserK_VACUUM)
	}



	return localctx
}


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

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

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

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

func NewEmptyColumn_defContext() *Column_defContext {
	var p = new(Column_defContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_column_def
	return p
}

func (*Column_defContext) IsColumn_defContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_column_def

	return p
}

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

func (s *Column_defContext) Column_name() IColumn_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

func (s *Column_defContext) AllColumn_constraint() []IColumn_constraintContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumn_constraintContext)(nil)).Elem())
	var tst = make([]IColumn_constraintContext, len(ts))

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

	return tst
}

func (s *Column_defContext) Column_constraint(i int) IColumn_constraintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_constraintContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumn_constraintContext)
}

func (s *Column_defContext) AllType_name() []IType_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IType_nameContext)(nil)).Elem())
	var tst = make([]IType_nameContext, len(ts))

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

	return tst
}

func (s *Column_defContext) Type_name(i int) IType_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IType_nameContext)
}

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

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


func (s *Column_defContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterColumn_def(s)
	}
}

func (s *Column_defContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitColumn_def(s)
	}
}




func (p *SqlParser) Column_def() (localctx IColumn_defContext) {
	localctx = NewColumn_defContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 76, SqlParserRULE_column_def)

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

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

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			p.SetState(1124)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 151, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(1122)
					p.Column_constraint()
				}


			case 2:
				{
					p.SetState(1123)
					p.Type_name()
				}

			}

		}
		p.SetState(1128)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 152, p.GetParserRuleContext())
	}



	return localctx
}


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

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

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

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

func NewEmptyType_nameContext() *Type_nameContext {
	var p = new(Type_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_type_name
	return p
}

func (*Type_nameContext) IsType_nameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_type_name

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Type_nameContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Type_nameContext) AllSigned_number() []ISigned_numberContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISigned_numberContext)(nil)).Elem())
	var tst = make([]ISigned_numberContext, len(ts))

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

	return tst
}

func (s *Type_nameContext) Signed_number(i int) ISigned_numberContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISigned_numberContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISigned_numberContext)
}

func (s *Type_nameContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Type_nameContext) COMMA() antlr.TerminalNode {
	return s.GetToken(SqlParserCOMMA, 0)
}

func (s *Type_nameContext) AllAny_name() []IAny_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAny_nameContext)(nil)).Elem())
	var tst = make([]IAny_nameContext, len(ts))

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

	return tst
}

func (s *Type_nameContext) Any_name(i int) IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

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

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


func (s *Type_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterType_name(s)
	}
}

func (s *Type_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitType_name(s)
	}
}




func (p *SqlParser) Type_name() (localctx IType_nameContext) {
	localctx = NewType_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, SqlParserRULE_type_name)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1129)
		p.Name()
	}
	p.SetState(1149)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 156, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1130)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1131)
			p.Signed_number()
		}
		p.SetState(1133)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if (((_la) & -(0x1f+1)) == 0 && ((1 << uint(_la)) & ((1 << SqlParserOPEN_PAR) | (1 << SqlParserK_ABORT) | (1 << SqlParserK_ACTION) | (1 << SqlParserK_ADD) | (1 << SqlParserK_AFTER) | (1 << SqlParserK_ALL) | (1 << SqlParserK_ALTER))) != 0) || ((((_la - 32)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 32))) & ((1 << (SqlParserK_ANALYZE - 32)) | (1 << (SqlParserK_AND - 32)) | (1 << (SqlParserK_AS - 32)) | (1 << (SqlParserK_ASC - 32)) | (1 << (SqlParserK_ATTACH - 32)) | (1 << (SqlParserK_AUTOINCREMENT - 32)) | (1 << (SqlParserK_BEFORE - 32)) | (1 << (SqlParserK_BEGIN - 32)) | (1 << (SqlParserK_BETWEEN - 32)) | (1 << (SqlParserK_BY - 32)) | (1 << (SqlParserK_CASCADE - 32)) | (1 << (SqlParserK_CASE - 32)) | (1 << (SqlParserK_CAST - 32)) | (1 << (SqlParserK_CHECK - 32)) | (1 << (SqlParserK_COLLATE - 32)) | (1 << (SqlParserK_COLUMN - 32)) | (1 << (SqlParserK_COMMIT - 32)) | (1 << (SqlParserK_CONFLICT - 32)) | (1 << (SqlParserK_CONSTRAINT - 32)) | (1 << (SqlParserK_CREATE - 32)) | (1 << (SqlParserK_CROSS - 32)) | (1 << (SqlParserK_CURRENT_DATE - 32)) | (1 << (SqlParserK_CURRENT_TIME - 32)) | (1 << (SqlParserK_CURRENT_TIMESTAMP - 32)) | (1 << (SqlParserK_DATABASE - 32)) | (1 << (SqlParserK_DEFAULT - 32)) | (1 << (SqlParserK_DEFERRABLE - 32)) | (1 << (SqlParserK_DEFERRED - 32)) | (1 << (SqlParserK_DELETE - 32)) | (1 << (SqlParserK_DESC - 32)) | (1 << (SqlParserK_DETACH - 32)) | (1 << (SqlParserK_DISTINCT - 32)))) != 0) || ((((_la - 64)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 64))) & ((1 << (SqlParserK_DROP - 64)) | (1 << (SqlParserK_EACH - 64)) | (1 << (SqlParserK_ELSE - 64)) | (1 << (SqlParserK_END - 64)) | (1 << (SqlParserK_ENABLE - 64)) | (1 << (SqlParserK_ESCAPE - 64)) | (1 << (SqlParserK_EXCEPT - 64)) | (1 << (SqlParserK_EXCLUSIVE - 64)) | (1 << (SqlParserK_EXISTS - 64)) | (1 << (SqlParserK_EXPLAIN - 64)) | (1 << (SqlParserK_FAIL - 64)) | (1 << (SqlParserK_FOR - 64)) | (1 << (SqlParserK_FOREIGN - 64)) | (1 << (SqlParserK_FROM - 64)) | (1 << (SqlParserK_FULL - 64)) | (1 << (SqlParserK_GLOB - 64)) | (1 << (SqlParserK_GROUP - 64)) | (1 << (SqlParserK_HAVING - 64)) | (1 << (SqlParserK_IF - 64)) | (1 << (SqlParserK_IGNORE - 64)) | (1 << (SqlParserK_IMMEDIATE - 64)) | (1 << (SqlParserK_IN - 64)) | (1 << (SqlParserK_INDEX - 64)) | (1 << (SqlParserK_INDEXED - 64)) | (1 << (SqlParserK_INITIALLY - 64)) | (1 << (SqlParserK_INNER - 64)) | (1 << (SqlParserK_INSERT - 64)) | (1 << (SqlParserK_INSTEAD - 64)) | (1 << (SqlParserK_INTERSECT - 64)) | (1 << (SqlParserK_INTO - 64)))) != 0) || ((((_la - 96)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 96))) & ((1 << (SqlParserK_IS - 96)) | (1 << (SqlParserK_ISNULL - 96)) | (1 << (SqlParserK_JOIN - 96)) | (1 << (SqlParserK_KEY - 96)) | (1 << (SqlParserK_LEFT - 96)) | (1 << (SqlParserK_LIKE - 96)) | (1 << (SqlParserK_LIMIT - 96)) | (1 << (SqlParserK_MATCH - 96)) | (1 << (SqlParserK_NATURAL - 96)) | (1 << (SqlParserK_NEXTVAL - 96)) | (1 << (SqlParserK_NO - 96)) | (1 << (SqlParserK_NOT - 96)) | (1 << (SqlParserK_NOTNULL - 96)) | (1 << (SqlParserK_NULL - 96)) | (1 << (SqlParserK_OF - 96)) | (1 << (SqlParserK_OFFSET - 96)) | (1 << (SqlParserK_ON - 96)) | (1 << (SqlParserK_OR - 96)) | (1 << (SqlParserK_ORDER - 96)) | (1 << (SqlParserK_OUTER - 96)) | (1 << (SqlParserK_PLAN - 96)) | (1 << (SqlParserK_PRAGMA - 96)) | (1 << (SqlParserK_PRIMARY - 96)) | (1 << (SqlParserK_QUERY - 96)) | (1 << (SqlParserK_RAISE - 96)) | (1 << (SqlParserK_RECURSIVE - 96)) | (1 << (SqlParserK_REFERENCES - 96)) | (1 << (SqlParserK_REGEXP - 96)) | (1 << (SqlParserK_REINDEX - 96)) | (1 << (SqlParserK_RELEASE - 96)) | (1 << (SqlParserK_RENAME - 96)))) != 0) || ((((_la - 128)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 128))) & ((1 << (SqlParserK_REPLACE - 128)) | (1 << (SqlParserK_RESTRICT - 128)) | (1 << (SqlParserK_RIGHT - 128)) | (1 << (SqlParserK_ROLLBACK - 128)) | (1 << (SqlParserK_ROW - 128)) | (1 << (SqlParserK_SAVEPOINT - 128)) | (1 << (SqlParserK_SELECT - 128)) | (1 << (SqlParserK_SET - 128)) | (1 << (SqlParserK_TABLE - 128)) | (1 << (SqlParserK_TEMP - 128)) | (1 << (SqlParserK_TEMPORARY - 128)) | (1 << (SqlParserK_THEN - 128)) | (1 << (SqlParserK_TO - 128)) | (1 << (SqlParserK_TRANSACTION - 128)) | (1 << (SqlParserK_TRIGGER - 128)) | (1 << (SqlParserK_UNION - 128)) | (1 << (SqlParserK_UNIQUE - 128)) | (1 << (SqlParserK_UPDATE - 128)) | (1 << (SqlParserK_USING - 128)) | (1 << (SqlParserK_VACUUM - 128)) | (1 << (SqlParserK_VALUES - 128)) | (1 << (SqlParserK_VIEW - 128)) | (1 << (SqlParserK_VIRTUAL - 128)) | (1 << (SqlParserK_WHEN - 128)) | (1 << (SqlParserK_WHERE - 128)) | (1 << (SqlParserK_WITH - 128)) | (1 << (SqlParserK_WITHOUT - 128)) | (1 << (SqlParserIDENTIFIER - 128)) | (1 << (SqlParserSTRING_LITERAL - 128)))) != 0) {
			{
				p.SetState(1132)
				p.Any_name()
			}

		}
		{
			p.SetState(1135)
			p.Match(SqlParserCLOSE_PAR)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 156, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(1137)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1138)
			p.Signed_number()
		}
		p.SetState(1140)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if (((_la) & -(0x1f+1)) == 0 && ((1 << uint(_la)) & ((1 << SqlParserOPEN_PAR) | (1 << SqlParserK_ABORT) | (1 << SqlParserK_ACTION) | (1 << SqlParserK_ADD) | (1 << SqlParserK_AFTER) | (1 << SqlParserK_ALL) | (1 << SqlParserK_ALTER))) != 0) || ((((_la - 32)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 32))) & ((1 << (SqlParserK_ANALYZE - 32)) | (1 << (SqlParserK_AND - 32)) | (1 << (SqlParserK_AS - 32)) | (1 << (SqlParserK_ASC - 32)) | (1 << (SqlParserK_ATTACH - 32)) | (1 << (SqlParserK_AUTOINCREMENT - 32)) | (1 << (SqlParserK_BEFORE - 32)) | (1 << (SqlParserK_BEGIN - 32)) | (1 << (SqlParserK_BETWEEN - 32)) | (1 << (SqlParserK_BY - 32)) | (1 << (SqlParserK_CASCADE - 32)) | (1 << (SqlParserK_CASE - 32)) | (1 << (SqlParserK_CAST - 32)) | (1 << (SqlParserK_CHECK - 32)) | (1 << (SqlParserK_COLLATE - 32)) | (1 << (SqlParserK_COLUMN - 32)) | (1 << (SqlParserK_COMMIT - 32)) | (1 << (SqlParserK_CONFLICT - 32)) | (1 << (SqlParserK_CONSTRAINT - 32)) | (1 << (SqlParserK_CREATE - 32)) | (1 << (SqlParserK_CROSS - 32)) | (1 << (SqlParserK_CURRENT_DATE - 32)) | (1 << (SqlParserK_CURRENT_TIME - 32)) | (1 << (SqlParserK_CURRENT_TIMESTAMP - 32)) | (1 << (SqlParserK_DATABASE - 32)) | (1 << (SqlParserK_DEFAULT - 32)) | (1 << (SqlParserK_DEFERRABLE - 32)) | (1 << (SqlParserK_DEFERRED - 32)) | (1 << (SqlParserK_DELETE - 32)) | (1 << (SqlParserK_DESC - 32)) | (1 << (SqlParserK_DETACH - 32)) | (1 << (SqlParserK_DISTINCT - 32)))) != 0) || ((((_la - 64)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 64))) & ((1 << (SqlParserK_DROP - 64)) | (1 << (SqlParserK_EACH - 64)) | (1 << (SqlParserK_ELSE - 64)) | (1 << (SqlParserK_END - 64)) | (1 << (SqlParserK_ENABLE - 64)) | (1 << (SqlParserK_ESCAPE - 64)) | (1 << (SqlParserK_EXCEPT - 64)) | (1 << (SqlParserK_EXCLUSIVE - 64)) | (1 << (SqlParserK_EXISTS - 64)) | (1 << (SqlParserK_EXPLAIN - 64)) | (1 << (SqlParserK_FAIL - 64)) | (1 << (SqlParserK_FOR - 64)) | (1 << (SqlParserK_FOREIGN - 64)) | (1 << (SqlParserK_FROM - 64)) | (1 << (SqlParserK_FULL - 64)) | (1 << (SqlParserK_GLOB - 64)) | (1 << (SqlParserK_GROUP - 64)) | (1 << (SqlParserK_HAVING - 64)) | (1 << (SqlParserK_IF - 64)) | (1 << (SqlParserK_IGNORE - 64)) | (1 << (SqlParserK_IMMEDIATE - 64)) | (1 << (SqlParserK_IN - 64)) | (1 << (SqlParserK_INDEX - 64)) | (1 << (SqlParserK_INDEXED - 64)) | (1 << (SqlParserK_INITIALLY - 64)) | (1 << (SqlParserK_INNER - 64)) | (1 << (SqlParserK_INSERT - 64)) | (1 << (SqlParserK_INSTEAD - 64)) | (1 << (SqlParserK_INTERSECT - 64)) | (1 << (SqlParserK_INTO - 64)))) != 0) || ((((_la - 96)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 96))) & ((1 << (SqlParserK_IS - 96)) | (1 << (SqlParserK_ISNULL - 96)) | (1 << (SqlParserK_JOIN - 96)) | (1 << (SqlParserK_KEY - 96)) | (1 << (SqlParserK_LEFT - 96)) | (1 << (SqlParserK_LIKE - 96)) | (1 << (SqlParserK_LIMIT - 96)) | (1 << (SqlParserK_MATCH - 96)) | (1 << (SqlParserK_NATURAL - 96)) | (1 << (SqlParserK_NEXTVAL - 96)) | (1 << (SqlParserK_NO - 96)) | (1 << (SqlParserK_NOT - 96)) | (1 << (SqlParserK_NOTNULL - 96)) | (1 << (SqlParserK_NULL - 96)) | (1 << (SqlParserK_OF - 96)) | (1 << (SqlParserK_OFFSET - 96)) | (1 << (SqlParserK_ON - 96)) | (1 << (SqlParserK_OR - 96)) | (1 << (SqlParserK_ORDER - 96)) | (1 << (SqlParserK_OUTER - 96)) | (1 << (SqlParserK_PLAN - 96)) | (1 << (SqlParserK_PRAGMA - 96)) | (1 << (SqlParserK_PRIMARY - 96)) | (1 << (SqlParserK_QUERY - 96)) | (1 << (SqlParserK_RAISE - 96)) | (1 << (SqlParserK_RECURSIVE - 96)) | (1 << (SqlParserK_REFERENCES - 96)) | (1 << (SqlParserK_REGEXP - 96)) | (1 << (SqlParserK_REINDEX - 96)) | (1 << (SqlParserK_RELEASE - 96)) | (1 << (SqlParserK_RENAME - 96)))) != 0) || ((((_la - 128)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 128))) & ((1 << (SqlParserK_REPLACE - 128)) | (1 << (SqlParserK_RESTRICT - 128)) | (1 << (SqlParserK_RIGHT - 128)) | (1 << (SqlParserK_ROLLBACK - 128)) | (1 << (SqlParserK_ROW - 128)) | (1 << (SqlParserK_SAVEPOINT - 128)) | (1 << (SqlParserK_SELECT - 128)) | (1 << (SqlParserK_SET - 128)) | (1 << (SqlParserK_TABLE - 128)) | (1 << (SqlParserK_TEMP - 128)) | (1 << (SqlParserK_TEMPORARY - 128)) | (1 << (SqlParserK_THEN - 128)) | (1 << (SqlParserK_TO - 128)) | (1 << (SqlParserK_TRANSACTION - 128)) | (1 << (SqlParserK_TRIGGER - 128)) | (1 << (SqlParserK_UNION - 128)) | (1 << (SqlParserK_UNIQUE - 128)) | (1 << (SqlParserK_UPDATE - 128)) | (1 << (SqlParserK_USING - 128)) | (1 << (SqlParserK_VACUUM - 128)) | (1 << (SqlParserK_VALUES - 128)) | (1 << (SqlParserK_VIEW - 128)) | (1 << (SqlParserK_VIRTUAL - 128)) | (1 << (SqlParserK_WHEN - 128)) | (1 << (SqlParserK_WHERE - 128)) | (1 << (SqlParserK_WITH - 128)) | (1 << (SqlParserK_WITHOUT - 128)) | (1 << (SqlParserIDENTIFIER - 128)) | (1 << (SqlParserSTRING_LITERAL - 128)))) != 0) {
			{
				p.SetState(1139)
				p.Any_name()
			}

		}
		{
			p.SetState(1142)
			p.Match(SqlParserCOMMA)
		}
		{
			p.SetState(1143)
			p.Signed_number()
		}
		p.SetState(1145)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if (((_la) & -(0x1f+1)) == 0 && ((1 << uint(_la)) & ((1 << SqlParserOPEN_PAR) | (1 << SqlParserK_ABORT) | (1 << SqlParserK_ACTION) | (1 << SqlParserK_ADD) | (1 << SqlParserK_AFTER) | (1 << SqlParserK_ALL) | (1 << SqlParserK_ALTER))) != 0) || ((((_la - 32)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 32))) & ((1 << (SqlParserK_ANALYZE - 32)) | (1 << (SqlParserK_AND - 32)) | (1 << (SqlParserK_AS - 32)) | (1 << (SqlParserK_ASC - 32)) | (1 << (SqlParserK_ATTACH - 32)) | (1 << (SqlParserK_AUTOINCREMENT - 32)) | (1 << (SqlParserK_BEFORE - 32)) | (1 << (SqlParserK_BEGIN - 32)) | (1 << (SqlParserK_BETWEEN - 32)) | (1 << (SqlParserK_BY - 32)) | (1 << (SqlParserK_CASCADE - 32)) | (1 << (SqlParserK_CASE - 32)) | (1 << (SqlParserK_CAST - 32)) | (1 << (SqlParserK_CHECK - 32)) | (1 << (SqlParserK_COLLATE - 32)) | (1 << (SqlParserK_COLUMN - 32)) | (1 << (SqlParserK_COMMIT - 32)) | (1 << (SqlParserK_CONFLICT - 32)) | (1 << (SqlParserK_CONSTRAINT - 32)) | (1 << (SqlParserK_CREATE - 32)) | (1 << (SqlParserK_CROSS - 32)) | (1 << (SqlParserK_CURRENT_DATE - 32)) | (1 << (SqlParserK_CURRENT_TIME - 32)) | (1 << (SqlParserK_CURRENT_TIMESTAMP - 32)) | (1 << (SqlParserK_DATABASE - 32)) | (1 << (SqlParserK_DEFAULT - 32)) | (1 << (SqlParserK_DEFERRABLE - 32)) | (1 << (SqlParserK_DEFERRED - 32)) | (1 << (SqlParserK_DELETE - 32)) | (1 << (SqlParserK_DESC - 32)) | (1 << (SqlParserK_DETACH - 32)) | (1 << (SqlParserK_DISTINCT - 32)))) != 0) || ((((_la - 64)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 64))) & ((1 << (SqlParserK_DROP - 64)) | (1 << (SqlParserK_EACH - 64)) | (1 << (SqlParserK_ELSE - 64)) | (1 << (SqlParserK_END - 64)) | (1 << (SqlParserK_ENABLE - 64)) | (1 << (SqlParserK_ESCAPE - 64)) | (1 << (SqlParserK_EXCEPT - 64)) | (1 << (SqlParserK_EXCLUSIVE - 64)) | (1 << (SqlParserK_EXISTS - 64)) | (1 << (SqlParserK_EXPLAIN - 64)) | (1 << (SqlParserK_FAIL - 64)) | (1 << (SqlParserK_FOR - 64)) | (1 << (SqlParserK_FOREIGN - 64)) | (1 << (SqlParserK_FROM - 64)) | (1 << (SqlParserK_FULL - 64)) | (1 << (SqlParserK_GLOB - 64)) | (1 << (SqlParserK_GROUP - 64)) | (1 << (SqlParserK_HAVING - 64)) | (1 << (SqlParserK_IF - 64)) | (1 << (SqlParserK_IGNORE - 64)) | (1 << (SqlParserK_IMMEDIATE - 64)) | (1 << (SqlParserK_IN - 64)) | (1 << (SqlParserK_INDEX - 64)) | (1 << (SqlParserK_INDEXED - 64)) | (1 << (SqlParserK_INITIALLY - 64)) | (1 << (SqlParserK_INNER - 64)) | (1 << (SqlParserK_INSERT - 64)) | (1 << (SqlParserK_INSTEAD - 64)) | (1 << (SqlParserK_INTERSECT - 64)) | (1 << (SqlParserK_INTO - 64)))) != 0) || ((((_la - 96)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 96))) & ((1 << (SqlParserK_IS - 96)) | (1 << (SqlParserK_ISNULL - 96)) | (1 << (SqlParserK_JOIN - 96)) | (1 << (SqlParserK_KEY - 96)) | (1 << (SqlParserK_LEFT - 96)) | (1 << (SqlParserK_LIKE - 96)) | (1 << (SqlParserK_LIMIT - 96)) | (1 << (SqlParserK_MATCH - 96)) | (1 << (SqlParserK_NATURAL - 96)) | (1 << (SqlParserK_NEXTVAL - 96)) | (1 << (SqlParserK_NO - 96)) | (1 << (SqlParserK_NOT - 96)) | (1 << (SqlParserK_NOTNULL - 96)) | (1 << (SqlParserK_NULL - 96)) | (1 << (SqlParserK_OF - 96)) | (1 << (SqlParserK_OFFSET - 96)) | (1 << (SqlParserK_ON - 96)) | (1 << (SqlParserK_OR - 96)) | (1 << (SqlParserK_ORDER - 96)) | (1 << (SqlParserK_OUTER - 96)) | (1 << (SqlParserK_PLAN - 96)) | (1 << (SqlParserK_PRAGMA - 96)) | (1 << (SqlParserK_PRIMARY - 96)) | (1 << (SqlParserK_QUERY - 96)) | (1 << (SqlParserK_RAISE - 96)) | (1 << (SqlParserK_RECURSIVE - 96)) | (1 << (SqlParserK_REFERENCES - 96)) | (1 << (SqlParserK_REGEXP - 96)) | (1 << (SqlParserK_REINDEX - 96)) | (1 << (SqlParserK_RELEASE - 96)) | (1 << (SqlParserK_RENAME - 96)))) != 0) || ((((_la - 128)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 128))) & ((1 << (SqlParserK_REPLACE - 128)) | (1 << (SqlParserK_RESTRICT - 128)) | (1 << (SqlParserK_RIGHT - 128)) | (1 << (SqlParserK_ROLLBACK - 128)) | (1 << (SqlParserK_ROW - 128)) | (1 << (SqlParserK_SAVEPOINT - 128)) | (1 << (SqlParserK_SELECT - 128)) | (1 << (SqlParserK_SET - 128)) | (1 << (SqlParserK_TABLE - 128)) | (1 << (SqlParserK_TEMP - 128)) | (1 << (SqlParserK_TEMPORARY - 128)) | (1 << (SqlParserK_THEN - 128)) | (1 << (SqlParserK_TO - 128)) | (1 << (SqlParserK_TRANSACTION - 128)) | (1 << (SqlParserK_TRIGGER - 128)) | (1 << (SqlParserK_UNION - 128)) | (1 << (SqlParserK_UNIQUE - 128)) | (1 << (SqlParserK_UPDATE - 128)) | (1 << (SqlParserK_USING - 128)) | (1 << (SqlParserK_VACUUM - 128)) | (1 << (SqlParserK_VALUES - 128)) | (1 << (SqlParserK_VIEW - 128)) | (1 << (SqlParserK_VIRTUAL - 128)) | (1 << (SqlParserK_WHEN - 128)) | (1 << (SqlParserK_WHERE - 128)) | (1 << (SqlParserK_WITH - 128)) | (1 << (SqlParserK_WITHOUT - 128)) | (1 << (SqlParserIDENTIFIER - 128)) | (1 << (SqlParserSTRING_LITERAL - 128)))) != 0) {
			{
				p.SetState(1144)
				p.Any_name()
			}

		}
		{
			p.SetState(1147)
			p.Match(SqlParserCLOSE_PAR)
		}


	}



	return localctx
}


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

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

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

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

func NewEmptyColumn_constraintContext() *Column_constraintContext {
	var p = new(Column_constraintContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_column_constraint
	return p
}

func (*Column_constraintContext) IsColumn_constraintContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_column_constraint

	return p
}

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

func (s *Column_constraintContext) Column_constraint_primary_key() IColumn_constraint_primary_keyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_constraint_primary_keyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumn_constraint_primary_keyContext)
}

func (s *Column_constraintContext) Column_constraint_foreign_key() IColumn_constraint_foreign_keyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_constraint_foreign_keyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumn_constraint_foreign_keyContext)
}

func (s *Column_constraintContext) Column_constraint_not_null() IColumn_constraint_not_nullContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_constraint_not_nullContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumn_constraint_not_nullContext)
}

func (s *Column_constraintContext) Column_constraint_null() IColumn_constraint_nullContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_constraint_nullContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumn_constraint_nullContext)
}

func (s *Column_constraintContext) K_UNIQUE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_UNIQUE, 0)
}

func (s *Column_constraintContext) Conflict_clause() IConflict_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConflict_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConflict_clauseContext)
}

func (s *Column_constraintContext) K_CHECK() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CHECK, 0)
}

func (s *Column_constraintContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Column_constraintContext) Expr() IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Column_constraintContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Column_constraintContext) Column_default() IColumn_defaultContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_defaultContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumn_defaultContext)
}

func (s *Column_constraintContext) K_COLLATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_COLLATE, 0)
}

func (s *Column_constraintContext) Collation_name() ICollation_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollation_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICollation_nameContext)
}

func (s *Column_constraintContext) K_CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CONSTRAINT, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

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

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


func (s *Column_constraintContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterColumn_constraint(s)
	}
}

func (s *Column_constraintContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitColumn_constraint(s)
	}
}




func (p *SqlParser) Column_constraint() (localctx IColumn_constraintContext) {
	localctx = NewColumn_constraintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, SqlParserRULE_column_constraint)
	var _la int


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

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

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


	if _la == SqlParserK_CONSTRAINT {
		{
			p.SetState(1151)
			p.Match(SqlParserK_CONSTRAINT)
		}
		{
			p.SetState(1152)
			p.Name()
		}

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

	switch p.GetTokenStream().LA(1) {
	case SqlParserK_PRIMARY:
		{
			p.SetState(1155)
			p.Column_constraint_primary_key()
		}


	case SqlParserK_REFERENCES:
		{
			p.SetState(1156)
			p.Column_constraint_foreign_key()
		}


	case SqlParserK_NOT:
		{
			p.SetState(1157)
			p.Column_constraint_not_null()
		}


	case SqlParserK_NULL:
		{
			p.SetState(1158)
			p.Column_constraint_null()
		}


	case SqlParserK_UNIQUE:
		{
			p.SetState(1159)
			p.Match(SqlParserK_UNIQUE)
		}
		{
			p.SetState(1160)
			p.Conflict_clause()
		}


	case SqlParserK_CHECK:
		{
			p.SetState(1161)
			p.Match(SqlParserK_CHECK)
		}
		{
			p.SetState(1162)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1163)
			p.expr(0)
		}
		{
			p.SetState(1164)
			p.Match(SqlParserCLOSE_PAR)
		}


	case SqlParserK_DEFAULT:
		{
			p.SetState(1166)
			p.Column_default()
		}


	case SqlParserK_COLLATE:
		{
			p.SetState(1167)
			p.Match(SqlParserK_COLLATE)
		}
		{
			p.SetState(1168)
			p.Collation_name()
		}



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



	return localctx
}


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

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

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

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

func NewEmptyColumn_constraint_primary_keyContext() *Column_constraint_primary_keyContext {
	var p = new(Column_constraint_primary_keyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_column_constraint_primary_key
	return p
}

func (*Column_constraint_primary_keyContext) IsColumn_constraint_primary_keyContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_column_constraint_primary_key

	return p
}

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

func (s *Column_constraint_primary_keyContext) K_PRIMARY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_PRIMARY, 0)
}

func (s *Column_constraint_primary_keyContext) K_KEY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_KEY, 0)
}

func (s *Column_constraint_primary_keyContext) Conflict_clause() IConflict_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConflict_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConflict_clauseContext)
}

func (s *Column_constraint_primary_keyContext) K_AUTOINCREMENT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AUTOINCREMENT, 0)
}

func (s *Column_constraint_primary_keyContext) K_ASC() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ASC, 0)
}

func (s *Column_constraint_primary_keyContext) K_DESC() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DESC, 0)
}

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

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


func (s *Column_constraint_primary_keyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterColumn_constraint_primary_key(s)
	}
}

func (s *Column_constraint_primary_keyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitColumn_constraint_primary_key(s)
	}
}




func (p *SqlParser) Column_constraint_primary_key() (localctx IColumn_constraint_primary_keyContext) {
	localctx = NewColumn_constraint_primary_keyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, SqlParserRULE_column_constraint_primary_key)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1171)
		p.Match(SqlParserK_PRIMARY)
	}
	{
		p.SetState(1172)
		p.Match(SqlParserK_KEY)
	}
	p.SetState(1174)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 159, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1173)
			_la = p.GetTokenStream().LA(1)

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


	}
	{
		p.SetState(1176)
		p.Conflict_clause()
	}
	p.SetState(1178)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 160, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1177)
			p.Match(SqlParserK_AUTOINCREMENT)
		}


	}



	return localctx
}


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

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

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

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

func NewEmptyColumn_constraint_foreign_keyContext() *Column_constraint_foreign_keyContext {
	var p = new(Column_constraint_foreign_keyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_column_constraint_foreign_key
	return p
}

func (*Column_constraint_foreign_keyContext) IsColumn_constraint_foreign_keyContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_column_constraint_foreign_key

	return p
}

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

func (s *Column_constraint_foreign_keyContext) Foreign_key_clause() IForeign_key_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForeign_key_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForeign_key_clauseContext)
}

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

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


func (s *Column_constraint_foreign_keyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterColumn_constraint_foreign_key(s)
	}
}

func (s *Column_constraint_foreign_keyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitColumn_constraint_foreign_key(s)
	}
}




func (p *SqlParser) Column_constraint_foreign_key() (localctx IColumn_constraint_foreign_keyContext) {
	localctx = NewColumn_constraint_foreign_keyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 84, SqlParserRULE_column_constraint_foreign_key)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1180)
		p.Foreign_key_clause()
	}



	return localctx
}


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

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

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

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

func NewEmptyColumn_constraint_not_nullContext() *Column_constraint_not_nullContext {
	var p = new(Column_constraint_not_nullContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_column_constraint_not_null
	return p
}

func (*Column_constraint_not_nullContext) IsColumn_constraint_not_nullContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_column_constraint_not_null

	return p
}

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

func (s *Column_constraint_not_nullContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOT, 0)
}

func (s *Column_constraint_not_nullContext) K_NULL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NULL, 0)
}

func (s *Column_constraint_not_nullContext) Conflict_clause() IConflict_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConflict_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConflict_clauseContext)
}

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

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


func (s *Column_constraint_not_nullContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterColumn_constraint_not_null(s)
	}
}

func (s *Column_constraint_not_nullContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitColumn_constraint_not_null(s)
	}
}




func (p *SqlParser) Column_constraint_not_null() (localctx IColumn_constraint_not_nullContext) {
	localctx = NewColumn_constraint_not_nullContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, SqlParserRULE_column_constraint_not_null)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1182)
		p.Match(SqlParserK_NOT)
	}
	{
		p.SetState(1183)
		p.Match(SqlParserK_NULL)
	}
	{
		p.SetState(1184)
		p.Conflict_clause()
	}



	return localctx
}


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

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

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

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

func NewEmptyColumn_constraint_nullContext() *Column_constraint_nullContext {
	var p = new(Column_constraint_nullContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_column_constraint_null
	return p
}

func (*Column_constraint_nullContext) IsColumn_constraint_nullContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_column_constraint_null

	return p
}

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

func (s *Column_constraint_nullContext) K_NULL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NULL, 0)
}

func (s *Column_constraint_nullContext) Conflict_clause() IConflict_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConflict_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConflict_clauseContext)
}

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

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


func (s *Column_constraint_nullContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterColumn_constraint_null(s)
	}
}

func (s *Column_constraint_nullContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitColumn_constraint_null(s)
	}
}




func (p *SqlParser) Column_constraint_null() (localctx IColumn_constraint_nullContext) {
	localctx = NewColumn_constraint_nullContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, SqlParserRULE_column_constraint_null)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1186)
		p.Match(SqlParserK_NULL)
	}
	{
		p.SetState(1187)
		p.Conflict_clause()
	}



	return localctx
}


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

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

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

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

func NewEmptyColumn_defaultContext() *Column_defaultContext {
	var p = new(Column_defaultContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_column_default
	return p
}

func (*Column_defaultContext) IsColumn_defaultContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_column_default

	return p
}

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

func (s *Column_defaultContext) K_DEFAULT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DEFAULT, 0)
}

func (s *Column_defaultContext) Column_default_value() IColumn_default_valueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_default_valueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumn_default_valueContext)
}

func (s *Column_defaultContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Column_defaultContext) Expr() IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Column_defaultContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Column_defaultContext) K_NEXTVAL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NEXTVAL, 0)
}

func (s *Column_defaultContext) AllAny_name() []IAny_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAny_nameContext)(nil)).Elem())
	var tst = make([]IAny_nameContext, len(ts))

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

	return tst
}

func (s *Column_defaultContext) Any_name(i int) IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

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

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


func (s *Column_defaultContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterColumn_default(s)
	}
}

func (s *Column_defaultContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitColumn_default(s)
	}
}




func (p *SqlParser) Column_default() (localctx IColumn_defaultContext) {
	localctx = NewColumn_defaultContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, SqlParserRULE_column_default)
	var _la int


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

	defer func() {
		if err := recover(); err != 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(1189)
		p.Match(SqlParserK_DEFAULT)
	}
	p.SetState(1201)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 161, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1190)
			p.Column_default_value()
		}


	case 2:
		{
			p.SetState(1191)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1192)
			p.expr(0)
		}
		{
			p.SetState(1193)
			p.Match(SqlParserCLOSE_PAR)
		}


	case 3:
		{
			p.SetState(1195)
			p.Match(SqlParserK_NEXTVAL)
		}
		{
			p.SetState(1196)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1197)
			p.expr(0)
		}
		{
			p.SetState(1198)
			p.Match(SqlParserCLOSE_PAR)
		}


	case 4:
		{
			p.SetState(1200)
			p.Any_name()
		}

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


	if _la == SqlParserT__0 {
		{
			p.SetState(1203)
			p.Match(SqlParserT__0)
		}
		p.SetState(1205)
		p.GetErrorHandler().Sync(p)
		_alt = 1
		for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
			switch _alt {
			case 1:
					{
						p.SetState(1204)
						p.Any_name()
					}




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

			p.SetState(1207)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 162, p.GetParserRuleContext())
		}

	}



	return localctx
}


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

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

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

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

func NewEmptyColumn_default_valueContext() *Column_default_valueContext {
	var p = new(Column_default_valueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_column_default_value
	return p
}

func (*Column_default_valueContext) IsColumn_default_valueContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_column_default_value

	return p
}

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

func (s *Column_default_valueContext) Signed_number() ISigned_numberContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISigned_numberContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISigned_numberContext)
}

func (s *Column_default_valueContext) Literal_value() ILiteral_valueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteral_valueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteral_valueContext)
}

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

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


func (s *Column_default_valueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterColumn_default_value(s)
	}
}

func (s *Column_default_valueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitColumn_default_value(s)
	}
}




func (p *SqlParser) Column_default_value() (localctx IColumn_default_valueContext) {
	localctx = NewColumn_default_valueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, SqlParserRULE_column_default_value)

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

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

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1213)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 164, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1211)
			p.Signed_number()
		}


	case 2:
		{
			p.SetState(1212)
			p.Literal_value()
		}

	}



	return localctx
}


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

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

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

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

func NewEmptyConflict_clauseContext() *Conflict_clauseContext {
	var p = new(Conflict_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_conflict_clause
	return p
}

func (*Conflict_clauseContext) IsConflict_clauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_conflict_clause

	return p
}

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

func (s *Conflict_clauseContext) K_ON() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ON, 0)
}

func (s *Conflict_clauseContext) K_CONFLICT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CONFLICT, 0)
}

func (s *Conflict_clauseContext) K_ROLLBACK() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ROLLBACK, 0)
}

func (s *Conflict_clauseContext) K_ABORT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ABORT, 0)
}

func (s *Conflict_clauseContext) K_FAIL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FAIL, 0)
}

func (s *Conflict_clauseContext) K_IGNORE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IGNORE, 0)
}

func (s *Conflict_clauseContext) K_REPLACE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_REPLACE, 0)
}

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

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


func (s *Conflict_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterConflict_clause(s)
	}
}

func (s *Conflict_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitConflict_clause(s)
	}
}




func (p *SqlParser) Conflict_clause() (localctx IConflict_clauseContext) {
	localctx = NewConflict_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, SqlParserRULE_conflict_clause)
	var _la int


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

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

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


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 165, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1215)
			p.Match(SqlParserK_ON)
		}
		{
			p.SetState(1216)
			p.Match(SqlParserK_CONFLICT)
		}
		{
			p.SetState(1217)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SqlParserK_ABORT || _la == SqlParserK_FAIL || _la == SqlParserK_IGNORE || _la == SqlParserK_REPLACE || _la == SqlParserK_ROLLBACK) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}


	}



	return localctx
}


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

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

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

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

func NewEmptyExprContext() *ExprContext {
	var p = new(ExprContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_expr
	return p
}

func (*ExprContext) IsExprContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_expr

	return p
}

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

func (s *ExprContext) Literal_value() ILiteral_valueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILiteral_valueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILiteral_valueContext)
}

func (s *ExprContext) BIND_PARAMETER() antlr.TerminalNode {
	return s.GetToken(SqlParserBIND_PARAMETER, 0)
}

func (s *ExprContext) Column_name() IColumn_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

func (s *ExprContext) Table_name() ITable_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *ExprContext) AllDOT() []antlr.TerminalNode {
	return s.GetTokens(SqlParserDOT)
}

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

func (s *ExprContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *ExprContext) Unary_operator() IUnary_operatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUnary_operatorContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUnary_operatorContext)
}

func (s *ExprContext) AllExpr() []IExprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExprContext)(nil)).Elem())
	var tst = make([]IExprContext, len(ts))

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

	return tst
}

func (s *ExprContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *ExprContext) Function_name() IFunction_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFunction_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFunction_nameContext)
}

func (s *ExprContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *ExprContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *ExprContext) STAR() antlr.TerminalNode {
	return s.GetToken(SqlParserSTAR, 0)
}

func (s *ExprContext) K_DISTINCT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DISTINCT, 0)
}

func (s *ExprContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

func (s *ExprContext) K_CAST() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CAST, 0)
}

func (s *ExprContext) K_AS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AS, 0)
}

func (s *ExprContext) Type_name() IType_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IType_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IType_nameContext)
}

func (s *ExprContext) Select_stmt() ISelect_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

func (s *ExprContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXISTS, 0)
}

func (s *ExprContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOT, 0)
}

func (s *ExprContext) K_CASE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CASE, 0)
}

func (s *ExprContext) K_END() antlr.TerminalNode {
	return s.GetToken(SqlParserK_END, 0)
}

func (s *ExprContext) AllK_WHEN() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_WHEN)
}

func (s *ExprContext) K_WHEN(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_WHEN, i)
}

func (s *ExprContext) AllK_THEN() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_THEN)
}

func (s *ExprContext) K_THEN(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_THEN, i)
}

func (s *ExprContext) K_ELSE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ELSE, 0)
}

func (s *ExprContext) Raise_function() IRaise_functionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRaise_functionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRaise_functionContext)
}

func (s *ExprContext) PIPE2() antlr.TerminalNode {
	return s.GetToken(SqlParserPIPE2, 0)
}

func (s *ExprContext) DIV() antlr.TerminalNode {
	return s.GetToken(SqlParserDIV, 0)
}

func (s *ExprContext) MOD() antlr.TerminalNode {
	return s.GetToken(SqlParserMOD, 0)
}

func (s *ExprContext) PLUS() antlr.TerminalNode {
	return s.GetToken(SqlParserPLUS, 0)
}

func (s *ExprContext) MINUS() antlr.TerminalNode {
	return s.GetToken(SqlParserMINUS, 0)
}

func (s *ExprContext) LT2() antlr.TerminalNode {
	return s.GetToken(SqlParserLT2, 0)
}

func (s *ExprContext) GT2() antlr.TerminalNode {
	return s.GetToken(SqlParserGT2, 0)
}

func (s *ExprContext) AMP() antlr.TerminalNode {
	return s.GetToken(SqlParserAMP, 0)
}

func (s *ExprContext) PIPE() antlr.TerminalNode {
	return s.GetToken(SqlParserPIPE, 0)
}

func (s *ExprContext) LT() antlr.TerminalNode {
	return s.GetToken(SqlParserLT, 0)
}

func (s *ExprContext) LT_EQ() antlr.TerminalNode {
	return s.GetToken(SqlParserLT_EQ, 0)
}

func (s *ExprContext) GT() antlr.TerminalNode {
	return s.GetToken(SqlParserGT, 0)
}

func (s *ExprContext) GT_EQ() antlr.TerminalNode {
	return s.GetToken(SqlParserGT_EQ, 0)
}

func (s *ExprContext) ASSIGN() antlr.TerminalNode {
	return s.GetToken(SqlParserASSIGN, 0)
}

func (s *ExprContext) EQ() antlr.TerminalNode {
	return s.GetToken(SqlParserEQ, 0)
}

func (s *ExprContext) NOT_EQ1() antlr.TerminalNode {
	return s.GetToken(SqlParserNOT_EQ1, 0)
}

func (s *ExprContext) NOT_EQ2() antlr.TerminalNode {
	return s.GetToken(SqlParserNOT_EQ2, 0)
}

func (s *ExprContext) K_IS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IS, 0)
}

func (s *ExprContext) K_IN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IN, 0)
}

func (s *ExprContext) K_LIKE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_LIKE, 0)
}

func (s *ExprContext) K_GLOB() antlr.TerminalNode {
	return s.GetToken(SqlParserK_GLOB, 0)
}

func (s *ExprContext) K_MATCH() antlr.TerminalNode {
	return s.GetToken(SqlParserK_MATCH, 0)
}

func (s *ExprContext) K_REGEXP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_REGEXP, 0)
}

func (s *ExprContext) K_AND() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AND, 0)
}

func (s *ExprContext) K_OR() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OR, 0)
}

func (s *ExprContext) K_BETWEEN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BETWEEN, 0)
}

func (s *ExprContext) K_COLLATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_COLLATE, 0)
}

func (s *ExprContext) Collation_name() ICollation_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollation_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICollation_nameContext)
}

func (s *ExprContext) K_ESCAPE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ESCAPE, 0)
}

func (s *ExprContext) K_ISNULL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ISNULL, 0)
}

func (s *ExprContext) K_NOTNULL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOTNULL, 0)
}

func (s *ExprContext) K_NULL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NULL, 0)
}

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

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


func (s *ExprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterExpr(s)
	}
}

func (s *ExprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitExpr(s)
	}
}





func (p *SqlParser) Expr() (localctx IExprContext) {
	return p.expr(0)
}

func (p *SqlParser) expr(_p int) (localctx IExprContext) {
	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewExprContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IExprContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 96
	p.EnterRecursionRule(localctx, 96, SqlParserRULE_expr, _p)
	var _la int


	defer func() {
		p.UnrollRecursionContexts(_parentctx)
	}()

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

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1296)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 176, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1221)
			p.Literal_value()
		}


	case 2:
		{
			p.SetState(1222)
			p.Match(SqlParserBIND_PARAMETER)
		}


	case 3:
		p.SetState(1231)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 167, p.GetParserRuleContext()) == 1 {
			p.SetState(1226)
			p.GetErrorHandler().Sync(p)


			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 166, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1223)
					p.Database_name()
				}
				{
					p.SetState(1224)
					p.Match(SqlParserDOT)
				}


			}
			{
				p.SetState(1228)
				p.Table_name()
			}
			{
				p.SetState(1229)
				p.Match(SqlParserDOT)
			}


		}
		{
			p.SetState(1233)
			p.Column_name()
		}


	case 4:
		{
			p.SetState(1234)
			p.Unary_operator()
		}
		{
			p.SetState(1235)
			p.expr(21)
		}


	case 5:
		{
			p.SetState(1237)
			p.Function_name()
		}
		{
			p.SetState(1238)
			p.Match(SqlParserOPEN_PAR)
		}
		p.SetState(1251)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SqlParserOPEN_PAR, SqlParserPLUS, SqlParserMINUS, SqlParserTILDE, SqlParserK_ABORT, SqlParserK_ACTION, SqlParserK_ADD, SqlParserK_AFTER, SqlParserK_ALL, SqlParserK_ALTER, SqlParserK_ANALYZE, SqlParserK_AND, SqlParserK_AS, SqlParserK_ASC, SqlParserK_ATTACH, SqlParserK_AUTOINCREMENT, SqlParserK_BEFORE, SqlParserK_BEGIN, SqlParserK_BETWEEN, SqlParserK_BY, SqlParserK_CASCADE, SqlParserK_CASE, SqlParserK_CAST, SqlParserK_CHECK, SqlParserK_COLLATE, SqlParserK_COLUMN, SqlParserK_COMMIT, SqlParserK_CONFLICT, SqlParserK_CONSTRAINT, SqlParserK_CREATE, SqlParserK_CROSS, SqlParserK_CURRENT_DATE, SqlParserK_CURRENT_TIME, SqlParserK_CURRENT_TIMESTAMP, SqlParserK_DATABASE, SqlParserK_DEFAULT, SqlParserK_DEFERRABLE, SqlParserK_DEFERRED, SqlParserK_DELETE, SqlParserK_DESC, SqlParserK_DETACH, SqlParserK_DISTINCT, SqlParserK_DROP, SqlParserK_EACH, SqlParserK_ELSE, SqlParserK_END, SqlParserK_ENABLE, SqlParserK_ESCAPE, SqlParserK_EXCEPT, SqlParserK_EXCLUSIVE, SqlParserK_EXISTS, SqlParserK_EXPLAIN, SqlParserK_FAIL, SqlParserK_FOR, SqlParserK_FOREIGN, SqlParserK_FROM, SqlParserK_FULL, SqlParserK_GLOB, SqlParserK_GROUP, SqlParserK_HAVING, SqlParserK_IF, SqlParserK_IGNORE, SqlParserK_IMMEDIATE, SqlParserK_IN, SqlParserK_INDEX, SqlParserK_INDEXED, SqlParserK_INITIALLY, SqlParserK_INNER, SqlParserK_INSERT, SqlParserK_INSTEAD, SqlParserK_INTERSECT, SqlParserK_INTO, SqlParserK_IS, SqlParserK_ISNULL, SqlParserK_JOIN, SqlParserK_KEY, SqlParserK_LEFT, SqlParserK_LIKE, SqlParserK_LIMIT, SqlParserK_MATCH, SqlParserK_NATURAL, SqlParserK_NEXTVAL, SqlParserK_NO, SqlParserK_NOT, SqlParserK_NOTNULL, SqlParserK_NULL, SqlParserK_OF, SqlParserK_OFFSET, SqlParserK_ON, SqlParserK_OR, SqlParserK_ORDER, SqlParserK_OUTER, SqlParserK_PLAN, SqlParserK_PRAGMA, SqlParserK_PRIMARY, SqlParserK_QUERY, SqlParserK_RAISE, SqlParserK_RECURSIVE, SqlParserK_REFERENCES, SqlParserK_REGEXP, SqlParserK_REINDEX, SqlParserK_RELEASE, SqlParserK_RENAME, SqlParserK_REPLACE, SqlParserK_RESTRICT, SqlParserK_RIGHT, SqlParserK_ROLLBACK, SqlParserK_ROW, SqlParserK_SAVEPOINT, SqlParserK_SELECT, SqlParserK_SET, SqlParserK_TABLE, SqlParserK_TEMP, SqlParserK_TEMPORARY, SqlParserK_THEN, SqlParserK_TO, SqlParserK_TRANSACTION, SqlParserK_TRIGGER, SqlParserK_UNION, SqlParserK_UNIQUE, SqlParserK_UPDATE, SqlParserK_USING, SqlParserK_VACUUM, SqlParserK_VALUES, SqlParserK_VIEW, SqlParserK_VIRTUAL, SqlParserK_WHEN, SqlParserK_WHERE, SqlParserK_WITH, SqlParserK_WITHOUT, SqlParserIDENTIFIER, SqlParserNUMERIC_LITERAL, SqlParserBIND_PARAMETER, SqlParserSTRING_LITERAL, SqlParserBLOB_LITERAL:
			p.SetState(1240)
			p.GetErrorHandler().Sync(p)


			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 168, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1239)
					p.Match(SqlParserK_DISTINCT)
				}


			}
			{
				p.SetState(1242)
				p.expr(0)
			}
			p.SetState(1247)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			for _la == SqlParserCOMMA {
				{
					p.SetState(1243)
					p.Match(SqlParserCOMMA)
				}
				{
					p.SetState(1244)
					p.expr(0)
				}


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


		case SqlParserSTAR:
			{
				p.SetState(1250)
				p.Match(SqlParserSTAR)
			}


		case SqlParserCLOSE_PAR:



		default:
		}
		{
			p.SetState(1253)
			p.Match(SqlParserCLOSE_PAR)
		}


	case 6:
		{
			p.SetState(1255)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1256)
			p.expr(0)
		}
		{
			p.SetState(1257)
			p.Match(SqlParserCLOSE_PAR)
		}


	case 7:
		{
			p.SetState(1259)
			p.Match(SqlParserK_CAST)
		}
		{
			p.SetState(1260)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1261)
			p.expr(0)
		}
		{
			p.SetState(1262)
			p.Match(SqlParserK_AS)
		}
		{
			p.SetState(1263)
			p.Type_name()
		}
		{
			p.SetState(1264)
			p.Match(SqlParserCLOSE_PAR)
		}


	case 8:
		p.SetState(1270)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserK_EXISTS || _la == SqlParserK_NOT {
			p.SetState(1267)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			if _la == SqlParserK_NOT {
				{
					p.SetState(1266)
					p.Match(SqlParserK_NOT)
				}

			}
			{
				p.SetState(1269)
				p.Match(SqlParserK_EXISTS)
			}

		}
		{
			p.SetState(1272)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1273)
			p.Select_stmt()
		}
		{
			p.SetState(1274)
			p.Match(SqlParserCLOSE_PAR)
		}


	case 9:
		{
			p.SetState(1276)
			p.Match(SqlParserK_CASE)
		}
		p.SetState(1278)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 173, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1277)
				p.expr(0)
			}


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


		for ok := true; ok; ok = _la == SqlParserK_WHEN {
			{
				p.SetState(1280)
				p.Match(SqlParserK_WHEN)
			}
			{
				p.SetState(1281)
				p.expr(0)
			}
			{
				p.SetState(1282)
				p.Match(SqlParserK_THEN)
			}
			{
				p.SetState(1283)
				p.expr(0)
			}


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


		if _la == SqlParserK_ELSE {
			{
				p.SetState(1289)
				p.Match(SqlParserK_ELSE)
			}
			{
				p.SetState(1290)
				p.expr(0)
			}

		}
		{
			p.SetState(1293)
			p.Match(SqlParserK_END)
		}


	case 10:
		{
			p.SetState(1295)
			p.Raise_function()
		}

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

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(1396)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 188, p.GetParserRuleContext()) {
			case 1:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SqlParserRULE_expr)
				p.SetState(1298)

				if !(p.Precpred(p.GetParserRuleContext(), 20)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 20)", ""))
				}
				{
					p.SetState(1299)
					p.Match(SqlParserPIPE2)
				}
				{
					p.SetState(1300)
					p.expr(21)
				}


			case 2:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SqlParserRULE_expr)
				p.SetState(1301)

				if !(p.Precpred(p.GetParserRuleContext(), 19)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 19)", ""))
				}
				{
					p.SetState(1302)
					_la = p.GetTokenStream().LA(1)

					if !((((_la) & -(0x1f+1)) == 0 && ((1 << uint(_la)) & ((1 << SqlParserSTAR) | (1 << SqlParserDIV) | (1 << SqlParserMOD))) != 0)) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1303)
					p.expr(20)
				}


			case 3:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SqlParserRULE_expr)
				p.SetState(1304)

				if !(p.Precpred(p.GetParserRuleContext(), 18)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 18)", ""))
				}
				{
					p.SetState(1305)
					_la = p.GetTokenStream().LA(1)

					if !(_la == SqlParserPLUS || _la == SqlParserMINUS) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1306)
					p.expr(19)
				}


			case 4:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SqlParserRULE_expr)
				p.SetState(1307)

				if !(p.Precpred(p.GetParserRuleContext(), 17)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 17)", ""))
				}
				{
					p.SetState(1308)
					_la = p.GetTokenStream().LA(1)

					if !((((_la) & -(0x1f+1)) == 0 && ((1 << uint(_la)) & ((1 << SqlParserLT2) | (1 << SqlParserGT2) | (1 << SqlParserAMP) | (1 << SqlParserPIPE))) != 0)) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1309)
					p.expr(18)
				}


			case 5:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SqlParserRULE_expr)
				p.SetState(1310)

				if !(p.Precpred(p.GetParserRuleContext(), 16)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 16)", ""))
				}
				{
					p.SetState(1311)
					_la = p.GetTokenStream().LA(1)

					if !((((_la) & -(0x1f+1)) == 0 && ((1 << uint(_la)) & ((1 << SqlParserLT) | (1 << SqlParserLT_EQ) | (1 << SqlParserGT) | (1 << SqlParserGT_EQ))) != 0)) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1312)
					p.expr(17)
				}


			case 6:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SqlParserRULE_expr)
				p.SetState(1313)

				if !(p.Precpred(p.GetParserRuleContext(), 15)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 15)", ""))
				}
				p.SetState(1326)
				p.GetErrorHandler().Sync(p)
				switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 177, p.GetParserRuleContext()) {
				case 1:
					{
						p.SetState(1314)
						p.Match(SqlParserASSIGN)
					}


				case 2:
					{
						p.SetState(1315)
						p.Match(SqlParserEQ)
					}


				case 3:
					{
						p.SetState(1316)
						p.Match(SqlParserNOT_EQ1)
					}


				case 4:
					{
						p.SetState(1317)
						p.Match(SqlParserNOT_EQ2)
					}


				case 5:
					{
						p.SetState(1318)
						p.Match(SqlParserK_IS)
					}


				case 6:
					{
						p.SetState(1319)
						p.Match(SqlParserK_IS)
					}
					{
						p.SetState(1320)
						p.Match(SqlParserK_NOT)
					}


				case 7:
					{
						p.SetState(1321)
						p.Match(SqlParserK_IN)
					}


				case 8:
					{
						p.SetState(1322)
						p.Match(SqlParserK_LIKE)
					}


				case 9:
					{
						p.SetState(1323)
						p.Match(SqlParserK_GLOB)
					}


				case 10:
					{
						p.SetState(1324)
						p.Match(SqlParserK_MATCH)
					}


				case 11:
					{
						p.SetState(1325)
						p.Match(SqlParserK_REGEXP)
					}

				}
				{
					p.SetState(1328)
					p.expr(16)
				}


			case 7:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SqlParserRULE_expr)
				p.SetState(1329)

				if !(p.Precpred(p.GetParserRuleContext(), 14)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", ""))
				}
				{
					p.SetState(1330)
					p.Match(SqlParserK_AND)
				}
				{
					p.SetState(1331)
					p.expr(15)
				}


			case 8:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SqlParserRULE_expr)
				p.SetState(1332)

				if !(p.Precpred(p.GetParserRuleContext(), 13)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 13)", ""))
				}
				{
					p.SetState(1333)
					p.Match(SqlParserK_OR)
				}
				{
					p.SetState(1334)
					p.expr(14)
				}


			case 9:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SqlParserRULE_expr)
				p.SetState(1335)

				if !(p.Precpred(p.GetParserRuleContext(), 6)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", ""))
				}
				{
					p.SetState(1336)
					p.Match(SqlParserK_IS)
				}
				p.SetState(1338)
				p.GetErrorHandler().Sync(p)


				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 178, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(1337)
						p.Match(SqlParserK_NOT)
					}


				}
				{
					p.SetState(1340)
					p.expr(7)
				}


			case 10:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SqlParserRULE_expr)
				p.SetState(1341)

				if !(p.Precpred(p.GetParserRuleContext(), 5)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
				}
				p.SetState(1343)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)


				if _la == SqlParserK_NOT {
					{
						p.SetState(1342)
						p.Match(SqlParserK_NOT)
					}

				}
				{
					p.SetState(1345)
					p.Match(SqlParserK_BETWEEN)
				}
				{
					p.SetState(1346)
					p.expr(0)
				}
				{
					p.SetState(1347)
					p.Match(SqlParserK_AND)
				}
				{
					p.SetState(1348)
					p.expr(6)
				}


			case 11:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SqlParserRULE_expr)
				p.SetState(1350)

				if !(p.Precpred(p.GetParserRuleContext(), 9)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", ""))
				}
				{
					p.SetState(1351)
					p.Match(SqlParserK_COLLATE)
				}
				{
					p.SetState(1352)
					p.Collation_name()
				}


			case 12:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SqlParserRULE_expr)
				p.SetState(1353)

				if !(p.Precpred(p.GetParserRuleContext(), 8)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", ""))
				}
				p.SetState(1355)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)


				if _la == SqlParserK_NOT {
					{
						p.SetState(1354)
						p.Match(SqlParserK_NOT)
					}

				}
				{
					p.SetState(1357)
					_la = p.GetTokenStream().LA(1)

					if !(((((_la - 81)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 81))) & ((1 << (SqlParserK_GLOB - 81)) | (1 << (SqlParserK_LIKE - 81)) | (1 << (SqlParserK_MATCH - 81)))) != 0) || _la == SqlParserK_REGEXP) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1358)
					p.expr(0)
				}
				p.SetState(1361)
				p.GetErrorHandler().Sync(p)


				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 181, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(1359)
						p.Match(SqlParserK_ESCAPE)
					}
					{
						p.SetState(1360)
						p.expr(0)
					}


				}


			case 13:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SqlParserRULE_expr)
				p.SetState(1363)

				if !(p.Precpred(p.GetParserRuleContext(), 7)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", ""))
				}
				p.SetState(1368)
				p.GetErrorHandler().Sync(p)

				switch p.GetTokenStream().LA(1) {
				case SqlParserK_ISNULL:
					{
						p.SetState(1364)
						p.Match(SqlParserK_ISNULL)
					}


				case SqlParserK_NOTNULL:
					{
						p.SetState(1365)
						p.Match(SqlParserK_NOTNULL)
					}


				case SqlParserK_NOT:
					{
						p.SetState(1366)
						p.Match(SqlParserK_NOT)
					}
					{
						p.SetState(1367)
						p.Match(SqlParserK_NULL)
					}



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


			case 14:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SqlParserRULE_expr)
				p.SetState(1370)

				if !(p.Precpred(p.GetParserRuleContext(), 4)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
				}
				p.SetState(1372)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)


				if _la == SqlParserK_NOT {
					{
						p.SetState(1371)
						p.Match(SqlParserK_NOT)
					}

				}
				{
					p.SetState(1374)
					p.Match(SqlParserK_IN)
				}
				p.SetState(1394)
				p.GetErrorHandler().Sync(p)
				switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 187, p.GetParserRuleContext()) {
				case 1:
					{
						p.SetState(1375)
						p.Match(SqlParserOPEN_PAR)
					}
					p.SetState(1385)
					p.GetErrorHandler().Sync(p)


					if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 185, p.GetParserRuleContext()) == 1 {
						{
							p.SetState(1376)
							p.Select_stmt()
						}

					} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 185, p.GetParserRuleContext()) == 2 {
						{
							p.SetState(1377)
							p.expr(0)
						}
						p.SetState(1382)
						p.GetErrorHandler().Sync(p)
						_la = p.GetTokenStream().LA(1)


						for _la == SqlParserCOMMA {
							{
								p.SetState(1378)
								p.Match(SqlParserCOMMA)
							}
							{
								p.SetState(1379)
								p.expr(0)
							}


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


					}
					{
						p.SetState(1387)
						p.Match(SqlParserCLOSE_PAR)
					}


				case 2:
					p.SetState(1391)
					p.GetErrorHandler().Sync(p)


					if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 186, p.GetParserRuleContext()) == 1 {
						{
							p.SetState(1388)
							p.Database_name()
						}
						{
							p.SetState(1389)
							p.Match(SqlParserDOT)
						}


					}
					{
						p.SetState(1393)
						p.Table_name()
					}

				}

			}

		}
		p.SetState(1400)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 189, p.GetParserRuleContext())
	}



	return localctx
}


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

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

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

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

func NewEmptyForeign_key_clauseContext() *Foreign_key_clauseContext {
	var p = new(Foreign_key_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_foreign_key_clause
	return p
}

func (*Foreign_key_clauseContext) IsForeign_key_clauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_foreign_key_clause

	return p
}

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

func (s *Foreign_key_clauseContext) K_REFERENCES() antlr.TerminalNode {
	return s.GetToken(SqlParserK_REFERENCES, 0)
}

func (s *Foreign_key_clauseContext) Foreign_table() IForeign_tableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForeign_tableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForeign_tableContext)
}

func (s *Foreign_key_clauseContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Foreign_key_clauseContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

func (s *Foreign_key_clauseContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Foreign_key_clauseContext) AllFk_target_column_name() []IFk_target_column_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFk_target_column_nameContext)(nil)).Elem())
	var tst = make([]IFk_target_column_nameContext, len(ts))

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

	return tst
}

func (s *Foreign_key_clauseContext) Fk_target_column_name(i int) IFk_target_column_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFk_target_column_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IFk_target_column_nameContext)
}

func (s *Foreign_key_clauseContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Foreign_key_clauseContext) AllK_ON() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_ON)
}

func (s *Foreign_key_clauseContext) K_ON(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_ON, i)
}

func (s *Foreign_key_clauseContext) AllK_MATCH() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_MATCH)
}

func (s *Foreign_key_clauseContext) K_MATCH(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_MATCH, i)
}

func (s *Foreign_key_clauseContext) AllName() []INameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*INameContext)(nil)).Elem())
	var tst = make([]INameContext, len(ts))

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

	return tst
}

func (s *Foreign_key_clauseContext) Name(i int) INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Foreign_key_clauseContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

func (s *Foreign_key_clauseContext) AllK_DELETE() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_DELETE)
}

func (s *Foreign_key_clauseContext) K_DELETE(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_DELETE, i)
}

func (s *Foreign_key_clauseContext) AllK_UPDATE() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_UPDATE)
}

func (s *Foreign_key_clauseContext) K_UPDATE(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_UPDATE, i)
}

func (s *Foreign_key_clauseContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOT, 0)
}

func (s *Foreign_key_clauseContext) K_DEFERRABLE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DEFERRABLE, 0)
}

func (s *Foreign_key_clauseContext) K_INITIALLY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INITIALLY, 0)
}

func (s *Foreign_key_clauseContext) K_DEFERRED() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DEFERRED, 0)
}

func (s *Foreign_key_clauseContext) K_IMMEDIATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IMMEDIATE, 0)
}

func (s *Foreign_key_clauseContext) AllK_ENABLE() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_ENABLE)
}

func (s *Foreign_key_clauseContext) K_ENABLE(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_ENABLE, i)
}

func (s *Foreign_key_clauseContext) K_NOVALIDATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOVALIDATE, 0)
}

func (s *Foreign_key_clauseContext) K_DISABLE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DISABLE, 0)
}

func (s *Foreign_key_clauseContext) AllK_SET() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_SET)
}

func (s *Foreign_key_clauseContext) K_SET(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_SET, i)
}

func (s *Foreign_key_clauseContext) AllK_NULL() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_NULL)
}

func (s *Foreign_key_clauseContext) K_NULL(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_NULL, i)
}

func (s *Foreign_key_clauseContext) AllK_DEFAULT() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_DEFAULT)
}

func (s *Foreign_key_clauseContext) K_DEFAULT(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_DEFAULT, i)
}

func (s *Foreign_key_clauseContext) AllK_CASCADE() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_CASCADE)
}

func (s *Foreign_key_clauseContext) K_CASCADE(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_CASCADE, i)
}

func (s *Foreign_key_clauseContext) AllK_RESTRICT() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_RESTRICT)
}

func (s *Foreign_key_clauseContext) K_RESTRICT(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_RESTRICT, i)
}

func (s *Foreign_key_clauseContext) AllK_NO() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_NO)
}

func (s *Foreign_key_clauseContext) K_NO(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_NO, i)
}

func (s *Foreign_key_clauseContext) AllK_ACTION() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_ACTION)
}

func (s *Foreign_key_clauseContext) K_ACTION(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_ACTION, i)
}

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

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


func (s *Foreign_key_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterForeign_key_clause(s)
	}
}

func (s *Foreign_key_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitForeign_key_clause(s)
	}
}




func (p *SqlParser) Foreign_key_clause() (localctx IForeign_key_clauseContext) {
	localctx = NewForeign_key_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 98, SqlParserRULE_foreign_key_clause)
	var _la int


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

	defer func() {
		if err := recover(); err != 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(1401)
		p.Match(SqlParserK_REFERENCES)
	}
	p.SetState(1405)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 190, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1402)
			p.Database_name()
		}
		{
			p.SetState(1403)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(1407)
		p.Foreign_table()
	}
	p.SetState(1419)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 192, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1408)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1409)
			p.Fk_target_column_name()
		}
		p.SetState(1414)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(1410)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(1411)
				p.Fk_target_column_name()
			}


			p.SetState(1416)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1417)
			p.Match(SqlParserCLOSE_PAR)
		}


	}
	p.SetState(1439)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 195, p.GetParserRuleContext())

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

			switch p.GetTokenStream().LA(1) {
			case SqlParserK_ON:
				{
					p.SetState(1421)
					p.Match(SqlParserK_ON)
				}
				{
					p.SetState(1422)
					_la = p.GetTokenStream().LA(1)

					if !(_la == SqlParserK_DELETE || _la == SqlParserK_UPDATE) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				p.SetState(1431)
				p.GetErrorHandler().Sync(p)
				switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 193, p.GetParserRuleContext()) {
				case 1:
					{
						p.SetState(1423)
						p.Match(SqlParserK_SET)
					}
					{
						p.SetState(1424)
						p.Match(SqlParserK_NULL)
					}


				case 2:
					{
						p.SetState(1425)
						p.Match(SqlParserK_SET)
					}
					{
						p.SetState(1426)
						p.Match(SqlParserK_DEFAULT)
					}


				case 3:
					{
						p.SetState(1427)
						p.Match(SqlParserK_CASCADE)
					}


				case 4:
					{
						p.SetState(1428)
						p.Match(SqlParserK_RESTRICT)
					}


				case 5:
					{
						p.SetState(1429)
						p.Match(SqlParserK_NO)
					}
					{
						p.SetState(1430)
						p.Match(SqlParserK_ACTION)
					}

				}


			case SqlParserK_MATCH:
				{
					p.SetState(1433)
					p.Match(SqlParserK_MATCH)
				}
				{
					p.SetState(1434)
					p.Name()
				}



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


		}
		p.SetState(1441)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 195, p.GetParserRuleContext())
	}
	p.SetState(1462)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 201, p.GetParserRuleContext()) == 1 {
		p.SetState(1443)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 196, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1442)
				p.Match(SqlParserK_NOT)
			}


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


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 197, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1445)
				p.Match(SqlParserK_DEFERRABLE)
			}


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


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 198, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1448)
				p.Match(SqlParserK_INITIALLY)
			}
			{
				p.SetState(1449)
				p.Match(SqlParserK_DEFERRED)
			}

		} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 198, p.GetParserRuleContext()) == 2 {
			{
				p.SetState(1450)
				p.Match(SqlParserK_INITIALLY)
			}
			{
				p.SetState(1451)
				p.Match(SqlParserK_IMMEDIATE)
			}

		} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 198, p.GetParserRuleContext()) == 3 {
			{
				p.SetState(1452)
				p.Match(SqlParserK_ENABLE)
			}
			{
				p.SetState(1453)
				p.Match(SqlParserK_NOVALIDATE)
			}


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


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 199, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1456)
				p.Match(SqlParserK_ENABLE)
			}


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


		if _la == SqlParserK_DISABLE {
			{
				p.SetState(1459)
				p.Match(SqlParserK_DISABLE)
			}

		}


	}



	return localctx
}


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

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

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

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

func NewEmptyFk_target_column_nameContext() *Fk_target_column_nameContext {
	var p = new(Fk_target_column_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_fk_target_column_name
	return p
}

func (*Fk_target_column_nameContext) IsFk_target_column_nameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_fk_target_column_name

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

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

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


func (s *Fk_target_column_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterFk_target_column_name(s)
	}
}

func (s *Fk_target_column_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitFk_target_column_name(s)
	}
}




func (p *SqlParser) Fk_target_column_name() (localctx IFk_target_column_nameContext) {
	localctx = NewFk_target_column_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, SqlParserRULE_fk_target_column_name)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1464)
		p.Name()
	}



	return localctx
}


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

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

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

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

func NewEmptyRaise_functionContext() *Raise_functionContext {
	var p = new(Raise_functionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_raise_function
	return p
}

func (*Raise_functionContext) IsRaise_functionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_raise_function

	return p
}

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

func (s *Raise_functionContext) K_RAISE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_RAISE, 0)
}

func (s *Raise_functionContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Raise_functionContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Raise_functionContext) K_IGNORE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IGNORE, 0)
}

func (s *Raise_functionContext) COMMA() antlr.TerminalNode {
	return s.GetToken(SqlParserCOMMA, 0)
}

func (s *Raise_functionContext) Error_message() IError_messageContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IError_messageContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IError_messageContext)
}

func (s *Raise_functionContext) K_ROLLBACK() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ROLLBACK, 0)
}

func (s *Raise_functionContext) K_ABORT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ABORT, 0)
}

func (s *Raise_functionContext) K_FAIL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FAIL, 0)
}

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

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


func (s *Raise_functionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterRaise_function(s)
	}
}

func (s *Raise_functionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitRaise_function(s)
	}
}




func (p *SqlParser) Raise_function() (localctx IRaise_functionContext) {
	localctx = NewRaise_functionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, SqlParserRULE_raise_function)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1466)
		p.Match(SqlParserK_RAISE)
	}
	{
		p.SetState(1467)
		p.Match(SqlParserOPEN_PAR)
	}
	p.SetState(1472)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SqlParserK_IGNORE:
		{
			p.SetState(1468)
			p.Match(SqlParserK_IGNORE)
		}


	case SqlParserK_ABORT, SqlParserK_FAIL, SqlParserK_ROLLBACK:
		{
			p.SetState(1469)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SqlParserK_ABORT || _la == SqlParserK_FAIL || _la == SqlParserK_ROLLBACK) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1470)
			p.Match(SqlParserCOMMA)
		}
		{
			p.SetState(1471)
			p.Error_message()
		}



	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(1474)
		p.Match(SqlParserCLOSE_PAR)
	}



	return localctx
}


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

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

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

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

func NewEmptyIndexed_columnContext() *Indexed_columnContext {
	var p = new(Indexed_columnContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_indexed_column
	return p
}

func (*Indexed_columnContext) IsIndexed_columnContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_indexed_column

	return p
}

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

func (s *Indexed_columnContext) Column_name() IColumn_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

func (s *Indexed_columnContext) K_COLLATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_COLLATE, 0)
}

func (s *Indexed_columnContext) Collation_name() ICollation_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollation_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICollation_nameContext)
}

func (s *Indexed_columnContext) K_ASC() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ASC, 0)
}

func (s *Indexed_columnContext) K_DESC() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DESC, 0)
}

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

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


func (s *Indexed_columnContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterIndexed_column(s)
	}
}

func (s *Indexed_columnContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitIndexed_column(s)
	}
}




func (p *SqlParser) Indexed_column() (localctx IIndexed_columnContext) {
	localctx = NewIndexed_columnContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 104, SqlParserRULE_indexed_column)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1476)
		p.Column_name()
	}
	p.SetState(1479)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_COLLATE {
		{
			p.SetState(1477)
			p.Match(SqlParserK_COLLATE)
		}
		{
			p.SetState(1478)
			p.Collation_name()
		}

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


	if _la == SqlParserK_ASC || _la == SqlParserK_DESC {
		{
			p.SetState(1481)
			_la = p.GetTokenStream().LA(1)

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

	}



	return localctx
}


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

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

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

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

func NewEmptyTable_constraintContext() *Table_constraintContext {
	var p = new(Table_constraintContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_table_constraint
	return p
}

func (*Table_constraintContext) IsTable_constraintContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_table_constraint

	return p
}

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

func (s *Table_constraintContext) Table_constraint_primary_key() ITable_constraint_primary_keyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_constraint_primary_keyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_constraint_primary_keyContext)
}

func (s *Table_constraintContext) Table_constraint_key() ITable_constraint_keyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_constraint_keyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_constraint_keyContext)
}

func (s *Table_constraintContext) Table_constraint_unique() ITable_constraint_uniqueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_constraint_uniqueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_constraint_uniqueContext)
}

func (s *Table_constraintContext) K_CHECK() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CHECK, 0)
}

func (s *Table_constraintContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Table_constraintContext) Expr() IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Table_constraintContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Table_constraintContext) Table_constraint_foreign_key() ITable_constraint_foreign_keyContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_constraint_foreign_keyContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_constraint_foreign_keyContext)
}

func (s *Table_constraintContext) K_CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CONSTRAINT, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

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

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


func (s *Table_constraintContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterTable_constraint(s)
	}
}

func (s *Table_constraintContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitTable_constraint(s)
	}
}




func (p *SqlParser) Table_constraint() (localctx ITable_constraintContext) {
	localctx = NewTable_constraintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, SqlParserRULE_table_constraint)
	var _la int


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

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

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


	if _la == SqlParserK_CONSTRAINT {
		{
			p.SetState(1484)
			p.Match(SqlParserK_CONSTRAINT)
		}
		{
			p.SetState(1485)
			p.Name()
		}

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

	switch p.GetTokenStream().LA(1) {
	case SqlParserK_PRIMARY:
		{
			p.SetState(1488)
			p.Table_constraint_primary_key()
		}


	case SqlParserK_KEY:
		{
			p.SetState(1489)
			p.Table_constraint_key()
		}


	case SqlParserK_UNIQUE:
		{
			p.SetState(1490)
			p.Table_constraint_unique()
		}


	case SqlParserK_CHECK:
		{
			p.SetState(1491)
			p.Match(SqlParserK_CHECK)
		}
		{
			p.SetState(1492)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1493)
			p.expr(0)
		}
		{
			p.SetState(1494)
			p.Match(SqlParserCLOSE_PAR)
		}


	case SqlParserK_FOREIGN:
		{
			p.SetState(1496)
			p.Table_constraint_foreign_key()
		}



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



	return localctx
}


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

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

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

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

func NewEmptyTable_constraint_primary_keyContext() *Table_constraint_primary_keyContext {
	var p = new(Table_constraint_primary_keyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_table_constraint_primary_key
	return p
}

func (*Table_constraint_primary_keyContext) IsTable_constraint_primary_keyContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_table_constraint_primary_key

	return p
}

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

func (s *Table_constraint_primary_keyContext) K_PRIMARY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_PRIMARY, 0)
}

func (s *Table_constraint_primary_keyContext) K_KEY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_KEY, 0)
}

func (s *Table_constraint_primary_keyContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Table_constraint_primary_keyContext) AllIndexed_column() []IIndexed_columnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIndexed_columnContext)(nil)).Elem())
	var tst = make([]IIndexed_columnContext, len(ts))

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

	return tst
}

func (s *Table_constraint_primary_keyContext) Indexed_column(i int) IIndexed_columnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexed_columnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIndexed_columnContext)
}

func (s *Table_constraint_primary_keyContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Table_constraint_primary_keyContext) Conflict_clause() IConflict_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConflict_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConflict_clauseContext)
}

func (s *Table_constraint_primary_keyContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

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

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


func (s *Table_constraint_primary_keyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterTable_constraint_primary_key(s)
	}
}

func (s *Table_constraint_primary_keyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitTable_constraint_primary_key(s)
	}
}




func (p *SqlParser) Table_constraint_primary_key() (localctx ITable_constraint_primary_keyContext) {
	localctx = NewTable_constraint_primary_keyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, SqlParserRULE_table_constraint_primary_key)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1499)
		p.Match(SqlParserK_PRIMARY)
	}
	{
		p.SetState(1500)
		p.Match(SqlParserK_KEY)
	}
	{
		p.SetState(1501)
		p.Match(SqlParserOPEN_PAR)
	}
	{
		p.SetState(1502)
		p.Indexed_column()
	}
	p.SetState(1507)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	for _la == SqlParserCOMMA {
		{
			p.SetState(1503)
			p.Match(SqlParserCOMMA)
		}
		{
			p.SetState(1504)
			p.Indexed_column()
		}


		p.SetState(1509)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1510)
		p.Match(SqlParserCLOSE_PAR)
	}
	{
		p.SetState(1511)
		p.Conflict_clause()
	}



	return localctx
}


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

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

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

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

func NewEmptyTable_constraint_foreign_keyContext() *Table_constraint_foreign_keyContext {
	var p = new(Table_constraint_foreign_keyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_table_constraint_foreign_key
	return p
}

func (*Table_constraint_foreign_keyContext) IsTable_constraint_foreign_keyContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_table_constraint_foreign_key

	return p
}

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

func (s *Table_constraint_foreign_keyContext) K_FOREIGN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FOREIGN, 0)
}

func (s *Table_constraint_foreign_keyContext) K_KEY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_KEY, 0)
}

func (s *Table_constraint_foreign_keyContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Table_constraint_foreign_keyContext) AllFk_origin_column_name() []IFk_origin_column_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFk_origin_column_nameContext)(nil)).Elem())
	var tst = make([]IFk_origin_column_nameContext, len(ts))

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

	return tst
}

func (s *Table_constraint_foreign_keyContext) Fk_origin_column_name(i int) IFk_origin_column_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFk_origin_column_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IFk_origin_column_nameContext)
}

func (s *Table_constraint_foreign_keyContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Table_constraint_foreign_keyContext) Foreign_key_clause() IForeign_key_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForeign_key_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForeign_key_clauseContext)
}

func (s *Table_constraint_foreign_keyContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

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

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


func (s *Table_constraint_foreign_keyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterTable_constraint_foreign_key(s)
	}
}

func (s *Table_constraint_foreign_keyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitTable_constraint_foreign_key(s)
	}
}




func (p *SqlParser) Table_constraint_foreign_key() (localctx ITable_constraint_foreign_keyContext) {
	localctx = NewTable_constraint_foreign_keyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, SqlParserRULE_table_constraint_foreign_key)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1513)
		p.Match(SqlParserK_FOREIGN)
	}
	{
		p.SetState(1514)
		p.Match(SqlParserK_KEY)
	}
	{
		p.SetState(1515)
		p.Match(SqlParserOPEN_PAR)
	}
	{
		p.SetState(1516)
		p.Fk_origin_column_name()
	}
	p.SetState(1521)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	for _la == SqlParserCOMMA {
		{
			p.SetState(1517)
			p.Match(SqlParserCOMMA)
		}
		{
			p.SetState(1518)
			p.Fk_origin_column_name()
		}


		p.SetState(1523)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1524)
		p.Match(SqlParserCLOSE_PAR)
	}
	{
		p.SetState(1525)
		p.Foreign_key_clause()
	}



	return localctx
}


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

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

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

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

func NewEmptyTable_constraint_uniqueContext() *Table_constraint_uniqueContext {
	var p = new(Table_constraint_uniqueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_table_constraint_unique
	return p
}

func (*Table_constraint_uniqueContext) IsTable_constraint_uniqueContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SqlParserRULE_table_constraint_unique

	return p
}

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

func (s *Table_constraint_uniqueContext) K_UNIQUE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_UNIQUE, 0)
}

func (s *Table_constraint_uniqueContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Table_constraint_uniqueContext) AllIndexed_column() []IIndexed_columnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIndexed_columnContext)(nil)).Elem())
	var tst = make([]IIndexed_columnContext, len(ts))

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

	return tst
}

func (s *Table_constraint_uniqueContext) Indexed_column(i int) IIndexed_columnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexed_columnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIndexed_columnContext)
}

func (s *Table_constraint_uniqueContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Table_constraint_uniqueContext) Conflict_clause() IConflict_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConflict_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConflict_clauseContext)
}

func (s *Table_constraint_uniqueContext) K_KEY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_KEY, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Table_constraint_uniqueContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

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

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

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


func (s *Table_constraint_uniqueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterTable_constraint_unique(s)
	}
}

func (s *Table_constraint_uniqueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitTable_constraint_unique(s)
	}
}




func (p *SqlParser) Table_constraint_unique() (localctx ITable_constraint_uniqueContext) {
	localctx = NewTable_constraint_uniqueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 112, SqlParserRULE_table_constraint_unique)
	var _la int


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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1527)
		p.Match(SqlParserK_UNIQUE)
	}
	p.SetState(1529)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 209, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1528)
			p.Match(SqlParserK_KEY)
		}


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


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 210, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1531)
			p.Name()
		}


	}
	{
		p.SetState(1534)
		p.Match(SqlParserOPEN_PAR)
	}
	{
		p.SetState(1535)
		p.Indexed_column()
	}
	p.SetState(1540)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	for _la == SqlParserCOMMA {
		{
			p.SetState(1536)
			p.Match(SqlParserCOMMA)
		}
		{
			p.SetState(1537)
			p.Indexed_column()
		}


		p.SetState(1542)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1543)
		p.Match(SqlParserCLOSE_PAR)
	}
	{
		p.SetState(1544)
		p.Conflict_clause()
	}



	return localctx
}


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

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

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

type Table_constraint_keyContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTable_constraint_keyContext() *Table_constraint_keyContext {
	var p = new(Table_constraint_keyContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_table_constraint_key
	return p
}

func (*Table_constraint_keyContext) IsTable_constraint_keyContext() {}

func NewTable_constraint_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_constraint_keyContext {
	var p = new(Table_constraint_keyContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_table_constraint_key

	return p
}

func (s *Table_constraint_keyContext) GetParser() antlr.Parser { return s.parser }

func (s *Table_constraint_keyContext) K_KEY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_KEY, 0)
}

func (s *Table_constraint_keyContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Table_constraint_keyContext) AllIndexed_column() []IIndexed_columnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IIndexed_columnContext)(nil)).Elem())
	var tst = make([]IIndexed_columnContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IIndexed_columnContext)
		}
	}

	return tst
}

func (s *Table_constraint_keyContext) Indexed_column(i int) IIndexed_columnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndexed_columnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IIndexed_columnContext)
}

func (s *Table_constraint_keyContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Table_constraint_keyContext) Conflict_clause() IConflict_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IConflict_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IConflict_clauseContext)
}

func (s *Table_constraint_keyContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Table_constraint_keyContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

func (s *Table_constraint_keyContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserCOMMA, i)
}

func (s *Table_constraint_keyContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Table_constraint_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Table_constraint_keyContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterTable_constraint_key(s)
	}
}

func (s *Table_constraint_keyContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitTable_constraint_key(s)
	}
}




func (p *SqlParser) Table_constraint_key() (localctx ITable_constraint_keyContext) {
	localctx = NewTable_constraint_keyContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 114, SqlParserRULE_table_constraint_key)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1546)
		p.Match(SqlParserK_KEY)
	}
	p.SetState(1548)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 212, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1547)
			p.Name()
		}


	}
	{
		p.SetState(1550)
		p.Match(SqlParserOPEN_PAR)
	}
	{
		p.SetState(1551)
		p.Indexed_column()
	}
	p.SetState(1556)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	for _la == SqlParserCOMMA {
		{
			p.SetState(1552)
			p.Match(SqlParserCOMMA)
		}
		{
			p.SetState(1553)
			p.Indexed_column()
		}


		p.SetState(1558)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1559)
		p.Match(SqlParserCLOSE_PAR)
	}
	{
		p.SetState(1560)
		p.Conflict_clause()
	}



	return localctx
}


// IFk_origin_column_nameContext is an interface to support dynamic dispatch.
type IFk_origin_column_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFk_origin_column_nameContext differentiates from other interfaces.
	IsFk_origin_column_nameContext()
}

type Fk_origin_column_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFk_origin_column_nameContext() *Fk_origin_column_nameContext {
	var p = new(Fk_origin_column_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_fk_origin_column_name
	return p
}

func (*Fk_origin_column_nameContext) IsFk_origin_column_nameContext() {}

func NewFk_origin_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fk_origin_column_nameContext {
	var p = new(Fk_origin_column_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_fk_origin_column_name

	return p
}

func (s *Fk_origin_column_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Fk_origin_column_nameContext) Column_name() IColumn_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

func (s *Fk_origin_column_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Fk_origin_column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Fk_origin_column_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterFk_origin_column_name(s)
	}
}

func (s *Fk_origin_column_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitFk_origin_column_name(s)
	}
}




func (p *SqlParser) Fk_origin_column_name() (localctx IFk_origin_column_nameContext) {
	localctx = NewFk_origin_column_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, SqlParserRULE_fk_origin_column_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1562)
		p.Column_name()
	}



	return localctx
}


// IWith_clauseContext is an interface to support dynamic dispatch.
type IWith_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWith_clauseContext differentiates from other interfaces.
	IsWith_clauseContext()
}

type With_clauseContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyWith_clauseContext() *With_clauseContext {
	var p = new(With_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_with_clause
	return p
}

func (*With_clauseContext) IsWith_clauseContext() {}

func NewWith_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_clauseContext {
	var p = new(With_clauseContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_with_clause

	return p
}

func (s *With_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *With_clauseContext) K_WITH() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WITH, 0)
}

func (s *With_clauseContext) AllCte_table_name() []ICte_table_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICte_table_nameContext)(nil)).Elem())
	var tst = make([]ICte_table_nameContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ICte_table_nameContext)
		}
	}

	return tst
}

func (s *With_clauseContext) Cte_table_name(i int) ICte_table_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICte_table_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICte_table_nameContext)
}

func (s *With_clauseContext) AllK_AS() []antlr.TerminalNode {
	return s.GetTokens(SqlParserK_AS)
}

func (s *With_clauseContext) K_AS(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserK_AS, i)
}

func (s *With_clauseContext) AllOPEN_PAR() []antlr.TerminalNode {
	return s.GetTokens(SqlParserOPEN_PAR)
}

func (s *With_clauseContext) OPEN_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, i)
}

func (s *With_clauseContext) AllSelect_stmt() []ISelect_stmtContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISelect_stmtContext)(nil)).Elem())
	var tst = make([]ISelect_stmtContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ISelect_stmtContext)
		}
	}

	return tst
}

func (s *With_clauseContext) Select_stmt(i int) ISelect_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_stmtContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

func (s *With_clauseContext) AllCLOSE_PAR() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCLOSE_PAR)
}

func (s *With_clauseContext) CLOSE_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, i)
}

func (s *With_clauseContext) K_RECURSIVE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_RECURSIVE, 0)
}

func (s *With_clauseContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

func (s *With_clauseContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserCOMMA, i)
}

func (s *With_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *With_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *With_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterWith_clause(s)
	}
}

func (s *With_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitWith_clause(s)
	}
}




func (p *SqlParser) With_clause() (localctx IWith_clauseContext) {
	localctx = NewWith_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, SqlParserRULE_with_clause)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1564)
		p.Match(SqlParserK_WITH)
	}
	p.SetState(1566)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 214, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1565)
			p.Match(SqlParserK_RECURSIVE)
		}


	}
	{
		p.SetState(1568)
		p.Cte_table_name()
	}
	{
		p.SetState(1569)
		p.Match(SqlParserK_AS)
	}
	{
		p.SetState(1570)
		p.Match(SqlParserOPEN_PAR)
	}
	{
		p.SetState(1571)
		p.Select_stmt()
	}
	{
		p.SetState(1572)
		p.Match(SqlParserCLOSE_PAR)
	}
	p.SetState(1582)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	for _la == SqlParserCOMMA {
		{
			p.SetState(1573)
			p.Match(SqlParserCOMMA)
		}
		{
			p.SetState(1574)
			p.Cte_table_name()
		}
		{
			p.SetState(1575)
			p.Match(SqlParserK_AS)
		}
		{
			p.SetState(1576)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1577)
			p.Select_stmt()
		}
		{
			p.SetState(1578)
			p.Match(SqlParserCLOSE_PAR)
		}


		p.SetState(1584)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}



	return localctx
}


// IQualified_table_nameContext is an interface to support dynamic dispatch.
type IQualified_table_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsQualified_table_nameContext differentiates from other interfaces.
	IsQualified_table_nameContext()
}

type Qualified_table_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyQualified_table_nameContext() *Qualified_table_nameContext {
	var p = new(Qualified_table_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_qualified_table_name
	return p
}

func (*Qualified_table_nameContext) IsQualified_table_nameContext() {}

func NewQualified_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_table_nameContext {
	var p = new(Qualified_table_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_qualified_table_name

	return p
}

func (s *Qualified_table_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Qualified_table_nameContext) Table_name() ITable_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Qualified_table_nameContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Qualified_table_nameContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

func (s *Qualified_table_nameContext) K_INDEXED() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INDEXED, 0)
}

func (s *Qualified_table_nameContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BY, 0)
}

func (s *Qualified_table_nameContext) Index_name() IIndex_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndex_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndex_nameContext)
}

func (s *Qualified_table_nameContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOT, 0)
}

func (s *Qualified_table_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Qualified_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Qualified_table_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterQualified_table_name(s)
	}
}

func (s *Qualified_table_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitQualified_table_name(s)
	}
}




func (p *SqlParser) Qualified_table_name() (localctx IQualified_table_nameContext) {
	localctx = NewQualified_table_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, SqlParserRULE_qualified_table_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1588)
	p.GetErrorHandler().Sync(p)


	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 216, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1585)
			p.Database_name()
		}
		{
			p.SetState(1586)
			p.Match(SqlParserDOT)
		}


	}
	{
		p.SetState(1590)
		p.Table_name()
	}
	p.SetState(1596)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SqlParserK_INDEXED:
		{
			p.SetState(1591)
			p.Match(SqlParserK_INDEXED)
		}
		{
			p.SetState(1592)
			p.Match(SqlParserK_BY)
		}
		{
			p.SetState(1593)
			p.Index_name()
		}


	case SqlParserK_NOT:
		{
			p.SetState(1594)
			p.Match(SqlParserK_NOT)
		}
		{
			p.SetState(1595)
			p.Match(SqlParserK_INDEXED)
		}


	case SqlParserEOF, SqlParserSCOL, SqlParserK_ALTER, SqlParserK_ANALYZE, SqlParserK_ATTACH, SqlParserK_BEGIN, SqlParserK_COMMIT, SqlParserK_CREATE, SqlParserK_DELETE, SqlParserK_DETACH, SqlParserK_DROP, SqlParserK_END, SqlParserK_EXPLAIN, SqlParserK_INSERT, SqlParserK_LIMIT, SqlParserK_ORDER, SqlParserK_PRAGMA, SqlParserK_REINDEX, SqlParserK_RELEASE, SqlParserK_REPLACE, SqlParserK_ROLLBACK, SqlParserK_SAVEPOINT, SqlParserK_SELECT, SqlParserK_SET, SqlParserK_UPDATE, SqlParserK_VACUUM, SqlParserK_VALUES, SqlParserK_WHERE, SqlParserK_WITH, SqlParserUNEXPECTED_CHAR:



	default:
	}



	return localctx
}


// IOrdering_termContext is an interface to support dynamic dispatch.
type IOrdering_termContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOrdering_termContext differentiates from other interfaces.
	IsOrdering_termContext()
}

type Ordering_termContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyOrdering_termContext() *Ordering_termContext {
	var p = new(Ordering_termContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_ordering_term
	return p
}

func (*Ordering_termContext) IsOrdering_termContext() {}

func NewOrdering_termContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ordering_termContext {
	var p = new(Ordering_termContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_ordering_term

	return p
}

func (s *Ordering_termContext) GetParser() antlr.Parser { return s.parser }

func (s *Ordering_termContext) Expr() IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Ordering_termContext) K_COLLATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_COLLATE, 0)
}

func (s *Ordering_termContext) Collation_name() ICollation_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollation_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICollation_nameContext)
}

func (s *Ordering_termContext) K_ASC() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ASC, 0)
}

func (s *Ordering_termContext) K_DESC() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DESC, 0)
}

func (s *Ordering_termContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Ordering_termContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Ordering_termContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterOrdering_term(s)
	}
}

func (s *Ordering_termContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitOrdering_term(s)
	}
}




func (p *SqlParser) Ordering_term() (localctx IOrdering_termContext) {
	localctx = NewOrdering_termContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 122, SqlParserRULE_ordering_term)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1598)
		p.expr(0)
	}
	p.SetState(1601)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_COLLATE {
		{
			p.SetState(1599)
			p.Match(SqlParserK_COLLATE)
		}
		{
			p.SetState(1600)
			p.Collation_name()
		}

	}
	p.SetState(1604)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserK_ASC || _la == SqlParserK_DESC {
		{
			p.SetState(1603)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SqlParserK_ASC || _la == SqlParserK_DESC) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	}



	return localctx
}


// IPragma_valueContext is an interface to support dynamic dispatch.
type IPragma_valueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPragma_valueContext differentiates from other interfaces.
	IsPragma_valueContext()
}

type Pragma_valueContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPragma_valueContext() *Pragma_valueContext {
	var p = new(Pragma_valueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_pragma_value
	return p
}

func (*Pragma_valueContext) IsPragma_valueContext() {}

func NewPragma_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_valueContext {
	var p = new(Pragma_valueContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_pragma_value

	return p
}

func (s *Pragma_valueContext) GetParser() antlr.Parser { return s.parser }

func (s *Pragma_valueContext) Signed_number() ISigned_numberContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISigned_numberContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISigned_numberContext)
}

func (s *Pragma_valueContext) Name() INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Pragma_valueContext) STRING_LITERAL() antlr.TerminalNode {
	return s.GetToken(SqlParserSTRING_LITERAL, 0)
}

func (s *Pragma_valueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Pragma_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Pragma_valueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterPragma_value(s)
	}
}

func (s *Pragma_valueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitPragma_value(s)
	}
}




func (p *SqlParser) Pragma_value() (localctx IPragma_valueContext) {
	localctx = NewPragma_valueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 124, SqlParserRULE_pragma_value)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1609)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 220, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1606)
			p.Signed_number()
		}


	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1607)
			p.Name()
		}


	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1608)
			p.Match(SqlParserSTRING_LITERAL)
		}

	}


	return localctx
}


// ICommon_table_expressionContext is an interface to support dynamic dispatch.
type ICommon_table_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCommon_table_expressionContext differentiates from other interfaces.
	IsCommon_table_expressionContext()
}

type Common_table_expressionContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCommon_table_expressionContext() *Common_table_expressionContext {
	var p = new(Common_table_expressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_common_table_expression
	return p
}

func (*Common_table_expressionContext) IsCommon_table_expressionContext() {}

func NewCommon_table_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_table_expressionContext {
	var p = new(Common_table_expressionContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_common_table_expression

	return p
}

func (s *Common_table_expressionContext) GetParser() antlr.Parser { return s.parser }

func (s *Common_table_expressionContext) Table_name() ITable_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Common_table_expressionContext) K_AS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AS, 0)
}

func (s *Common_table_expressionContext) AllOPEN_PAR() []antlr.TerminalNode {
	return s.GetTokens(SqlParserOPEN_PAR)
}

func (s *Common_table_expressionContext) OPEN_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, i)
}

func (s *Common_table_expressionContext) Select_stmt() ISelect_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

func (s *Common_table_expressionContext) AllCLOSE_PAR() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCLOSE_PAR)
}

func (s *Common_table_expressionContext) CLOSE_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, i)
}

func (s *Common_table_expressionContext) AllColumn_name() []IColumn_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem())
	var tst = make([]IColumn_nameContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IColumn_nameContext)
		}
	}

	return tst
}

func (s *Common_table_expressionContext) Column_name(i int) IColumn_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

func (s *Common_table_expressionContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

func (s *Common_table_expressionContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserCOMMA, i)
}

func (s *Common_table_expressionContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Common_table_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Common_table_expressionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterCommon_table_expression(s)
	}
}

func (s *Common_table_expressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitCommon_table_expression(s)
	}
}




func (p *SqlParser) Common_table_expression() (localctx ICommon_table_expressionContext) {
	localctx = NewCommon_table_expressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 126, SqlParserRULE_common_table_expression)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1611)
		p.Table_name()
	}
	p.SetState(1623)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserOPEN_PAR {
		{
			p.SetState(1612)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1613)
			p.Column_name()
		}
		p.SetState(1618)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(1614)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(1615)
				p.Column_name()
			}


			p.SetState(1620)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1621)
			p.Match(SqlParserCLOSE_PAR)
		}

	}
	{
		p.SetState(1625)
		p.Match(SqlParserK_AS)
	}
	{
		p.SetState(1626)
		p.Match(SqlParserOPEN_PAR)
	}
	{
		p.SetState(1627)
		p.Select_stmt()
	}
	{
		p.SetState(1628)
		p.Match(SqlParserCLOSE_PAR)
	}



	return localctx
}


// IResult_columnContext is an interface to support dynamic dispatch.
type IResult_columnContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsResult_columnContext differentiates from other interfaces.
	IsResult_columnContext()
}

type Result_columnContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyResult_columnContext() *Result_columnContext {
	var p = new(Result_columnContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_result_column
	return p
}

func (*Result_columnContext) IsResult_columnContext() {}

func NewResult_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Result_columnContext {
	var p = new(Result_columnContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_result_column

	return p
}

func (s *Result_columnContext) GetParser() antlr.Parser { return s.parser }

func (s *Result_columnContext) STAR() antlr.TerminalNode {
	return s.GetToken(SqlParserSTAR, 0)
}

func (s *Result_columnContext) Table_name() ITable_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Result_columnContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

func (s *Result_columnContext) Expr() IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Result_columnContext) Column_alias() IColumn_aliasContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_aliasContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumn_aliasContext)
}

func (s *Result_columnContext) K_AS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AS, 0)
}

func (s *Result_columnContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Result_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Result_columnContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterResult_column(s)
	}
}

func (s *Result_columnContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitResult_column(s)
	}
}




func (p *SqlParser) Result_column() (localctx IResult_columnContext) {
	localctx = NewResult_columnContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 128, SqlParserRULE_result_column)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1642)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 225, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1630)
			p.Match(SqlParserSTAR)
		}


	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1631)
			p.Table_name()
		}
		{
			p.SetState(1632)
			p.Match(SqlParserDOT)
		}
		{
			p.SetState(1633)
			p.Match(SqlParserSTAR)
		}


	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1635)
			p.expr(0)
		}
		p.SetState(1640)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserK_AS || _la == SqlParserIDENTIFIER || _la == SqlParserSTRING_LITERAL {
			p.SetState(1637)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			if _la == SqlParserK_AS {
				{
					p.SetState(1636)
					p.Match(SqlParserK_AS)
				}

			}
			{
				p.SetState(1639)
				p.Column_alias()
			}

		}

	}


	return localctx
}


// ITable_or_subqueryContext is an interface to support dynamic dispatch.
type ITable_or_subqueryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTable_or_subqueryContext differentiates from other interfaces.
	IsTable_or_subqueryContext()
}

type Table_or_subqueryContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTable_or_subqueryContext() *Table_or_subqueryContext {
	var p = new(Table_or_subqueryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_table_or_subquery
	return p
}

func (*Table_or_subqueryContext) IsTable_or_subqueryContext() {}

func NewTable_or_subqueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_or_subqueryContext {
	var p = new(Table_or_subqueryContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_table_or_subquery

	return p
}

func (s *Table_or_subqueryContext) GetParser() antlr.Parser { return s.parser }

func (s *Table_or_subqueryContext) Table_name() ITable_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Table_or_subqueryContext) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Table_or_subqueryContext) DOT() antlr.TerminalNode {
	return s.GetToken(SqlParserDOT, 0)
}

func (s *Table_or_subqueryContext) Table_alias() ITable_aliasContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_aliasContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_aliasContext)
}

func (s *Table_or_subqueryContext) K_INDEXED() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INDEXED, 0)
}

func (s *Table_or_subqueryContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BY, 0)
}

func (s *Table_or_subqueryContext) Index_name() IIndex_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IIndex_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IIndex_nameContext)
}

func (s *Table_or_subqueryContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOT, 0)
}

func (s *Table_or_subqueryContext) K_AS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AS, 0)
}

func (s *Table_or_subqueryContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Table_or_subqueryContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Table_or_subqueryContext) AllTable_or_subquery() []ITable_or_subqueryContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITable_or_subqueryContext)(nil)).Elem())
	var tst = make([]ITable_or_subqueryContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ITable_or_subqueryContext)
		}
	}

	return tst
}

func (s *Table_or_subqueryContext) Table_or_subquery(i int) ITable_or_subqueryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_or_subqueryContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITable_or_subqueryContext)
}

func (s *Table_or_subqueryContext) Join_clause() IJoin_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IJoin_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IJoin_clauseContext)
}

func (s *Table_or_subqueryContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

func (s *Table_or_subqueryContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserCOMMA, i)
}

func (s *Table_or_subqueryContext) Select_stmt() ISelect_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

func (s *Table_or_subqueryContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Table_or_subqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Table_or_subqueryContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterTable_or_subquery(s)
	}
}

func (s *Table_or_subqueryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitTable_or_subquery(s)
	}
}




func (p *SqlParser) Table_or_subquery() (localctx ITable_or_subqueryContext) {
	localctx = NewTable_or_subqueryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 130, SqlParserRULE_table_or_subquery)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1691)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 236, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(1647)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 226, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1644)
				p.Database_name()
			}
			{
				p.SetState(1645)
				p.Match(SqlParserDOT)
			}


		}
		{
			p.SetState(1649)
			p.Table_name()
		}
		p.SetState(1654)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 228, p.GetParserRuleContext()) == 1 {
			p.SetState(1651)
			p.GetErrorHandler().Sync(p)


			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 227, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1650)
					p.Match(SqlParserK_AS)
				}


			}
			{
				p.SetState(1653)
				p.Table_alias()
			}


		}
		p.SetState(1661)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SqlParserK_INDEXED:
			{
				p.SetState(1656)
				p.Match(SqlParserK_INDEXED)
			}
			{
				p.SetState(1657)
				p.Match(SqlParserK_BY)
			}
			{
				p.SetState(1658)
				p.Index_name()
			}


		case SqlParserK_NOT:
			{
				p.SetState(1659)
				p.Match(SqlParserK_NOT)
			}
			{
				p.SetState(1660)
				p.Match(SqlParserK_INDEXED)
			}


		case SqlParserEOF, SqlParserSCOL, SqlParserCLOSE_PAR, SqlParserCOMMA, SqlParserK_ALTER, SqlParserK_ANALYZE, SqlParserK_ATTACH, SqlParserK_BEGIN, SqlParserK_COMMIT, SqlParserK_CREATE, SqlParserK_CROSS, SqlParserK_DELETE, SqlParserK_DETACH, SqlParserK_DROP, SqlParserK_END, SqlParserK_EXCEPT, SqlParserK_EXPLAIN, SqlParserK_GROUP, SqlParserK_INNER, SqlParserK_INSERT, SqlParserK_INTERSECT, SqlParserK_JOIN, SqlParserK_LEFT, SqlParserK_LIMIT, SqlParserK_NATURAL, SqlParserK_ON, SqlParserK_ORDER, SqlParserK_PRAGMA, SqlParserK_REINDEX, SqlParserK_RELEASE, SqlParserK_REPLACE, SqlParserK_ROLLBACK, SqlParserK_SAVEPOINT, SqlParserK_SELECT, SqlParserK_UNION, SqlParserK_UPDATE, SqlParserK_USING, SqlParserK_VACUUM, SqlParserK_VALUES, SqlParserK_WHERE, SqlParserK_WITH, SqlParserUNEXPECTED_CHAR:



		default:
		}


	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1663)
			p.Match(SqlParserOPEN_PAR)
		}
		p.SetState(1673)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 231, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1664)
				p.Table_or_subquery()
			}
			p.SetState(1669)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			for _la == SqlParserCOMMA {
				{
					p.SetState(1665)
					p.Match(SqlParserCOMMA)
				}
				{
					p.SetState(1666)
					p.Table_or_subquery()
				}


				p.SetState(1671)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}


		case 2:
			{
				p.SetState(1672)
				p.Join_clause()
			}

		}
		{
			p.SetState(1675)
			p.Match(SqlParserCLOSE_PAR)
		}
		p.SetState(1680)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 233, p.GetParserRuleContext()) == 1 {
			p.SetState(1677)
			p.GetErrorHandler().Sync(p)


			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 232, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1676)
					p.Match(SqlParserK_AS)
				}


			}
			{
				p.SetState(1679)
				p.Table_alias()
			}


		}


	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1682)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1683)
			p.Select_stmt()
		}
		{
			p.SetState(1684)
			p.Match(SqlParserCLOSE_PAR)
		}
		p.SetState(1689)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 235, p.GetParserRuleContext()) == 1 {
			p.SetState(1686)
			p.GetErrorHandler().Sync(p)


			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 234, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1685)
					p.Match(SqlParserK_AS)
				}


			}
			{
				p.SetState(1688)
				p.Table_alias()
			}


		}

	}


	return localctx
}


// IJoin_clauseContext is an interface to support dynamic dispatch.
type IJoin_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsJoin_clauseContext differentiates from other interfaces.
	IsJoin_clauseContext()
}

type Join_clauseContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyJoin_clauseContext() *Join_clauseContext {
	var p = new(Join_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_join_clause
	return p
}

func (*Join_clauseContext) IsJoin_clauseContext() {}

func NewJoin_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_clauseContext {
	var p = new(Join_clauseContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_join_clause

	return p
}

func (s *Join_clauseContext) GetParser() antlr.Parser { return s.parser }

func (s *Join_clauseContext) AllTable_or_subquery() []ITable_or_subqueryContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITable_or_subqueryContext)(nil)).Elem())
	var tst = make([]ITable_or_subqueryContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ITable_or_subqueryContext)
		}
	}

	return tst
}

func (s *Join_clauseContext) Table_or_subquery(i int) ITable_or_subqueryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_or_subqueryContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITable_or_subqueryContext)
}

func (s *Join_clauseContext) AllJoin_operator() []IJoin_operatorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IJoin_operatorContext)(nil)).Elem())
	var tst = make([]IJoin_operatorContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IJoin_operatorContext)
		}
	}

	return tst
}

func (s *Join_clauseContext) Join_operator(i int) IJoin_operatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IJoin_operatorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IJoin_operatorContext)
}

func (s *Join_clauseContext) AllJoin_constraint() []IJoin_constraintContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IJoin_constraintContext)(nil)).Elem())
	var tst = make([]IJoin_constraintContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IJoin_constraintContext)
		}
	}

	return tst
}

func (s *Join_clauseContext) Join_constraint(i int) IJoin_constraintContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IJoin_constraintContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IJoin_constraintContext)
}

func (s *Join_clauseContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Join_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Join_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterJoin_clause(s)
	}
}

func (s *Join_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitJoin_clause(s)
	}
}




func (p *SqlParser) Join_clause() (localctx IJoin_clauseContext) {
	localctx = NewJoin_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 132, SqlParserRULE_join_clause)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1693)
		p.Table_or_subquery()
	}
	p.SetState(1700)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	for _la == SqlParserCOMMA || _la == SqlParserK_CROSS || ((((_la - 91)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 91))) & ((1 << (SqlParserK_INNER - 91)) | (1 << (SqlParserK_JOIN - 91)) | (1 << (SqlParserK_LEFT - 91)) | (1 << (SqlParserK_NATURAL - 91)))) != 0) {
		{
			p.SetState(1694)
			p.Join_operator()
		}
		{
			p.SetState(1695)
			p.Table_or_subquery()
		}
		{
			p.SetState(1696)
			p.Join_constraint()
		}


		p.SetState(1702)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}



	return localctx
}


// IJoin_operatorContext is an interface to support dynamic dispatch.
type IJoin_operatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsJoin_operatorContext differentiates from other interfaces.
	IsJoin_operatorContext()
}

type Join_operatorContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyJoin_operatorContext() *Join_operatorContext {
	var p = new(Join_operatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_join_operator
	return p
}

func (*Join_operatorContext) IsJoin_operatorContext() {}

func NewJoin_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_operatorContext {
	var p = new(Join_operatorContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_join_operator

	return p
}

func (s *Join_operatorContext) GetParser() antlr.Parser { return s.parser }

func (s *Join_operatorContext) COMMA() antlr.TerminalNode {
	return s.GetToken(SqlParserCOMMA, 0)
}

func (s *Join_operatorContext) K_JOIN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_JOIN, 0)
}

func (s *Join_operatorContext) K_NATURAL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NATURAL, 0)
}

func (s *Join_operatorContext) K_LEFT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_LEFT, 0)
}

func (s *Join_operatorContext) K_INNER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INNER, 0)
}

func (s *Join_operatorContext) K_CROSS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CROSS, 0)
}

func (s *Join_operatorContext) K_OUTER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OUTER, 0)
}

func (s *Join_operatorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Join_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Join_operatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterJoin_operator(s)
	}
}

func (s *Join_operatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitJoin_operator(s)
	}
}




func (p *SqlParser) Join_operator() (localctx IJoin_operatorContext) {
	localctx = NewJoin_operatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 134, SqlParserRULE_join_operator)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1716)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SqlParserCOMMA:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1703)
			p.Match(SqlParserCOMMA)
		}


	case SqlParserK_CROSS, SqlParserK_INNER, SqlParserK_JOIN, SqlParserK_LEFT, SqlParserK_NATURAL:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(1705)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserK_NATURAL {
			{
				p.SetState(1704)
				p.Match(SqlParserK_NATURAL)
			}

		}
		p.SetState(1713)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SqlParserK_LEFT:
			{
				p.SetState(1707)
				p.Match(SqlParserK_LEFT)
			}
			p.SetState(1709)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			if _la == SqlParserK_OUTER {
				{
					p.SetState(1708)
					p.Match(SqlParserK_OUTER)
				}

			}


		case SqlParserK_INNER:
			{
				p.SetState(1711)
				p.Match(SqlParserK_INNER)
			}


		case SqlParserK_CROSS:
			{
				p.SetState(1712)
				p.Match(SqlParserK_CROSS)
			}


		case SqlParserK_JOIN:



		default:
		}
		{
			p.SetState(1715)
			p.Match(SqlParserK_JOIN)
		}



	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}


	return localctx
}


// IJoin_constraintContext is an interface to support dynamic dispatch.
type IJoin_constraintContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsJoin_constraintContext differentiates from other interfaces.
	IsJoin_constraintContext()
}

type Join_constraintContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyJoin_constraintContext() *Join_constraintContext {
	var p = new(Join_constraintContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_join_constraint
	return p
}

func (*Join_constraintContext) IsJoin_constraintContext() {}

func NewJoin_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_constraintContext {
	var p = new(Join_constraintContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_join_constraint

	return p
}

func (s *Join_constraintContext) GetParser() antlr.Parser { return s.parser }

func (s *Join_constraintContext) K_ON() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ON, 0)
}

func (s *Join_constraintContext) Expr() IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Join_constraintContext) K_USING() antlr.TerminalNode {
	return s.GetToken(SqlParserK_USING, 0)
}

func (s *Join_constraintContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Join_constraintContext) AllColumn_name() []IColumn_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem())
	var tst = make([]IColumn_nameContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IColumn_nameContext)
		}
	}

	return tst
}

func (s *Join_constraintContext) Column_name(i int) IColumn_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

func (s *Join_constraintContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Join_constraintContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

func (s *Join_constraintContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserCOMMA, i)
}

func (s *Join_constraintContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Join_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Join_constraintContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterJoin_constraint(s)
	}
}

func (s *Join_constraintContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitJoin_constraint(s)
	}
}




func (p *SqlParser) Join_constraint() (localctx IJoin_constraintContext) {
	localctx = NewJoin_constraintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 136, SqlParserRULE_join_constraint)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1732)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SqlParserK_ON:
		{
			p.SetState(1718)
			p.Match(SqlParserK_ON)
		}
		{
			p.SetState(1719)
			p.expr(0)
		}


	case SqlParserK_USING:
		{
			p.SetState(1720)
			p.Match(SqlParserK_USING)
		}
		{
			p.SetState(1721)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1722)
			p.Column_name()
		}
		p.SetState(1727)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(1723)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(1724)
				p.Column_name()
			}


			p.SetState(1729)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1730)
			p.Match(SqlParserCLOSE_PAR)
		}


	case SqlParserEOF, SqlParserSCOL, SqlParserCLOSE_PAR, SqlParserCOMMA, SqlParserK_ALTER, SqlParserK_ANALYZE, SqlParserK_ATTACH, SqlParserK_BEGIN, SqlParserK_COMMIT, SqlParserK_CREATE, SqlParserK_CROSS, SqlParserK_DELETE, SqlParserK_DETACH, SqlParserK_DROP, SqlParserK_END, SqlParserK_EXCEPT, SqlParserK_EXPLAIN, SqlParserK_GROUP, SqlParserK_INNER, SqlParserK_INSERT, SqlParserK_INTERSECT, SqlParserK_JOIN, SqlParserK_LEFT, SqlParserK_LIMIT, SqlParserK_NATURAL, SqlParserK_ORDER, SqlParserK_PRAGMA, SqlParserK_REINDEX, SqlParserK_RELEASE, SqlParserK_REPLACE, SqlParserK_ROLLBACK, SqlParserK_SAVEPOINT, SqlParserK_SELECT, SqlParserK_UNION, SqlParserK_UPDATE, SqlParserK_VACUUM, SqlParserK_VALUES, SqlParserK_WHERE, SqlParserK_WITH, SqlParserUNEXPECTED_CHAR:



	default:
	}



	return localctx
}


// ISelect_coreContext is an interface to support dynamic dispatch.
type ISelect_coreContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSelect_coreContext differentiates from other interfaces.
	IsSelect_coreContext()
}

type Select_coreContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySelect_coreContext() *Select_coreContext {
	var p = new(Select_coreContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_select_core
	return p
}

func (*Select_coreContext) IsSelect_coreContext() {}

func NewSelect_coreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_coreContext {
	var p = new(Select_coreContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_select_core

	return p
}

func (s *Select_coreContext) GetParser() antlr.Parser { return s.parser }

func (s *Select_coreContext) K_SELECT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_SELECT, 0)
}

func (s *Select_coreContext) AllResult_column() []IResult_columnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IResult_columnContext)(nil)).Elem())
	var tst = make([]IResult_columnContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IResult_columnContext)
		}
	}

	return tst
}

func (s *Select_coreContext) Result_column(i int) IResult_columnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResult_columnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IResult_columnContext)
}

func (s *Select_coreContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

func (s *Select_coreContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserCOMMA, i)
}

func (s *Select_coreContext) K_FROM() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FROM, 0)
}

func (s *Select_coreContext) K_WHERE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WHERE, 0)
}

func (s *Select_coreContext) AllExpr() []IExprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExprContext)(nil)).Elem())
	var tst = make([]IExprContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IExprContext)
		}
	}

	return tst
}

func (s *Select_coreContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Select_coreContext) K_GROUP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_GROUP, 0)
}

func (s *Select_coreContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BY, 0)
}

func (s *Select_coreContext) K_DISTINCT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DISTINCT, 0)
}

func (s *Select_coreContext) K_ALL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ALL, 0)
}

func (s *Select_coreContext) AllTable_or_subquery() []ITable_or_subqueryContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITable_or_subqueryContext)(nil)).Elem())
	var tst = make([]ITable_or_subqueryContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(ITable_or_subqueryContext)
		}
	}

	return tst
}

func (s *Select_coreContext) Table_or_subquery(i int) ITable_or_subqueryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_or_subqueryContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITable_or_subqueryContext)
}

func (s *Select_coreContext) Join_clause() IJoin_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IJoin_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IJoin_clauseContext)
}

func (s *Select_coreContext) K_HAVING() antlr.TerminalNode {
	return s.GetToken(SqlParserK_HAVING, 0)
}

func (s *Select_coreContext) K_VALUES() antlr.TerminalNode {
	return s.GetToken(SqlParserK_VALUES, 0)
}

func (s *Select_coreContext) AllOPEN_PAR() []antlr.TerminalNode {
	return s.GetTokens(SqlParserOPEN_PAR)
}

func (s *Select_coreContext) OPEN_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, i)
}

func (s *Select_coreContext) AllCLOSE_PAR() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCLOSE_PAR)
}

func (s *Select_coreContext) CLOSE_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, i)
}

func (s *Select_coreContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Select_coreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Select_coreContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterSelect_core(s)
	}
}

func (s *Select_coreContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitSelect_core(s)
	}
}




func (p *SqlParser) Select_core() (localctx ISelect_coreContext) {
	localctx = NewSelect_coreContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 138, SqlParserRULE_select_core)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1808)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SqlParserK_SELECT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1734)
			p.Match(SqlParserK_SELECT)
		}
		p.SetState(1736)
		p.GetErrorHandler().Sync(p)


		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 244, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1735)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SqlParserK_ALL || _la == SqlParserK_DISTINCT) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}


		}
		{
			p.SetState(1738)
			p.Result_column()
		}
		p.SetState(1743)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(1739)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(1740)
				p.Result_column()
			}


			p.SetState(1745)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		p.SetState(1758)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserK_FROM {
			{
				p.SetState(1746)
				p.Match(SqlParserK_FROM)
			}
			p.SetState(1756)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 247, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(1747)
					p.Table_or_subquery()
				}
				p.SetState(1752)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)


				for _la == SqlParserCOMMA {
					{
						p.SetState(1748)
						p.Match(SqlParserCOMMA)
					}
					{
						p.SetState(1749)
						p.Table_or_subquery()
					}


					p.SetState(1754)
					p.GetErrorHandler().Sync(p)
					_la = p.GetTokenStream().LA(1)
				}


			case 2:
				{
					p.SetState(1755)
					p.Join_clause()
				}

			}

		}
		p.SetState(1762)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserK_WHERE {
			{
				p.SetState(1760)
				p.Match(SqlParserK_WHERE)
			}
			{
				p.SetState(1761)
				p.expr(0)
			}

		}
		p.SetState(1778)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserK_GROUP {
			{
				p.SetState(1764)
				p.Match(SqlParserK_GROUP)
			}
			{
				p.SetState(1765)
				p.Match(SqlParserK_BY)
			}
			{
				p.SetState(1766)
				p.expr(0)
			}
			p.SetState(1771)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			for _la == SqlParserCOMMA {
				{
					p.SetState(1767)
					p.Match(SqlParserCOMMA)
				}
				{
					p.SetState(1768)
					p.expr(0)
				}


				p.SetState(1773)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			p.SetState(1776)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			if _la == SqlParserK_HAVING {
				{
					p.SetState(1774)
					p.Match(SqlParserK_HAVING)
				}
				{
					p.SetState(1775)
					p.expr(0)
				}

			}

		}


	case SqlParserK_VALUES:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1780)
			p.Match(SqlParserK_VALUES)
		}
		{
			p.SetState(1781)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1782)
			p.expr(0)
		}
		p.SetState(1787)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(1783)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(1784)
				p.expr(0)
			}


			p.SetState(1789)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1790)
			p.Match(SqlParserCLOSE_PAR)
		}
		p.SetState(1805)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(1791)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(1792)
				p.Match(SqlParserOPEN_PAR)
			}
			{
				p.SetState(1793)
				p.expr(0)
			}
			p.SetState(1798)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)


			for _la == SqlParserCOMMA {
				{
					p.SetState(1794)
					p.Match(SqlParserCOMMA)
				}
				{
					p.SetState(1795)
					p.expr(0)
				}


				p.SetState(1800)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(1801)
				p.Match(SqlParserCLOSE_PAR)
			}


			p.SetState(1807)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}



	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}


	return localctx
}


// ICompound_operatorContext is an interface to support dynamic dispatch.
type ICompound_operatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCompound_operatorContext differentiates from other interfaces.
	IsCompound_operatorContext()
}

type Compound_operatorContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCompound_operatorContext() *Compound_operatorContext {
	var p = new(Compound_operatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_compound_operator
	return p
}

func (*Compound_operatorContext) IsCompound_operatorContext() {}

func NewCompound_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compound_operatorContext {
	var p = new(Compound_operatorContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_compound_operator

	return p
}

func (s *Compound_operatorContext) GetParser() antlr.Parser { return s.parser }

func (s *Compound_operatorContext) K_UNION() antlr.TerminalNode {
	return s.GetToken(SqlParserK_UNION, 0)
}

func (s *Compound_operatorContext) K_ALL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ALL, 0)
}

func (s *Compound_operatorContext) K_INTERSECT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INTERSECT, 0)
}

func (s *Compound_operatorContext) K_EXCEPT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXCEPT, 0)
}

func (s *Compound_operatorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Compound_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Compound_operatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterCompound_operator(s)
	}
}

func (s *Compound_operatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitCompound_operator(s)
	}
}




func (p *SqlParser) Compound_operator() (localctx ICompound_operatorContext) {
	localctx = NewCompound_operatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 140, SqlParserRULE_compound_operator)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1815)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 257, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1810)
			p.Match(SqlParserK_UNION)
		}


	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1811)
			p.Match(SqlParserK_UNION)
		}
		{
			p.SetState(1812)
			p.Match(SqlParserK_ALL)
		}


	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1813)
			p.Match(SqlParserK_INTERSECT)
		}


	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1814)
			p.Match(SqlParserK_EXCEPT)
		}

	}


	return localctx
}


// ICte_table_nameContext is an interface to support dynamic dispatch.
type ICte_table_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCte_table_nameContext differentiates from other interfaces.
	IsCte_table_nameContext()
}

type Cte_table_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCte_table_nameContext() *Cte_table_nameContext {
	var p = new(Cte_table_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_cte_table_name
	return p
}

func (*Cte_table_nameContext) IsCte_table_nameContext() {}

func NewCte_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cte_table_nameContext {
	var p = new(Cte_table_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_cte_table_name

	return p
}

func (s *Cte_table_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Cte_table_nameContext) Table_name() ITable_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Cte_table_nameContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Cte_table_nameContext) AllColumn_name() []IColumn_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem())
	var tst = make([]IColumn_nameContext, len(ts))

	for i, t := range ts {
		if t != nil {
			tst[i] = t.(IColumn_nameContext)
		}
	}

	return tst
}

func (s *Cte_table_nameContext) Column_name(i int) IColumn_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

func (s *Cte_table_nameContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Cte_table_nameContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SqlParserCOMMA)
}

func (s *Cte_table_nameContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(SqlParserCOMMA, i)
}

func (s *Cte_table_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Cte_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Cte_table_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterCte_table_name(s)
	}
}

func (s *Cte_table_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitCte_table_name(s)
	}
}




func (p *SqlParser) Cte_table_name() (localctx ICte_table_nameContext) {
	localctx = NewCte_table_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 142, SqlParserRULE_cte_table_name)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1817)
		p.Table_name()
	}
	p.SetState(1829)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	if _la == SqlParserOPEN_PAR {
		{
			p.SetState(1818)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1819)
			p.Column_name()
		}
		p.SetState(1824)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		for _la == SqlParserCOMMA {
			{
				p.SetState(1820)
				p.Match(SqlParserCOMMA)
			}
			{
				p.SetState(1821)
				p.Column_name()
			}


			p.SetState(1826)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1827)
			p.Match(SqlParserCLOSE_PAR)
		}

	}



	return localctx
}


// ISigned_numberContext is an interface to support dynamic dispatch.
type ISigned_numberContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSigned_numberContext differentiates from other interfaces.
	IsSigned_numberContext()
}

type Signed_numberContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySigned_numberContext() *Signed_numberContext {
	var p = new(Signed_numberContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_signed_number
	return p
}

func (*Signed_numberContext) IsSigned_numberContext() {}

func NewSigned_numberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Signed_numberContext {
	var p = new(Signed_numberContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_signed_number

	return p
}

func (s *Signed_numberContext) GetParser() antlr.Parser { return s.parser }

func (s *Signed_numberContext) NUMERIC_LITERAL() antlr.TerminalNode {
	return s.GetToken(SqlParserNUMERIC_LITERAL, 0)
}

func (s *Signed_numberContext) STAR() antlr.TerminalNode {
	return s.GetToken(SqlParserSTAR, 0)
}

func (s *Signed_numberContext) PLUS() antlr.TerminalNode {
	return s.GetToken(SqlParserPLUS, 0)
}

func (s *Signed_numberContext) MINUS() antlr.TerminalNode {
	return s.GetToken(SqlParserMINUS, 0)
}

func (s *Signed_numberContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Signed_numberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Signed_numberContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterSigned_number(s)
	}
}

func (s *Signed_numberContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitSigned_number(s)
	}
}




func (p *SqlParser) Signed_number() (localctx ISigned_numberContext) {
	localctx = NewSigned_numberContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 144, SqlParserRULE_signed_number)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1836)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SqlParserPLUS, SqlParserMINUS, SqlParserNUMERIC_LITERAL:
		p.SetState(1832)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)


		if _la == SqlParserPLUS || _la == SqlParserMINUS {
			{
				p.SetState(1831)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SqlParserPLUS || _la == SqlParserMINUS) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}

		}
		{
			p.SetState(1834)
			p.Match(SqlParserNUMERIC_LITERAL)
		}


	case SqlParserSTAR:
		{
			p.SetState(1835)
			p.Match(SqlParserSTAR)
		}



	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}



	return localctx
}


// ILiteral_valueContext is an interface to support dynamic dispatch.
type ILiteral_valueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLiteral_valueContext differentiates from other interfaces.
	IsLiteral_valueContext()
}

type Literal_valueContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyLiteral_valueContext() *Literal_valueContext {
	var p = new(Literal_valueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_literal_value
	return p
}

func (*Literal_valueContext) IsLiteral_valueContext() {}

func NewLiteral_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Literal_valueContext {
	var p = new(Literal_valueContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_literal_value

	return p
}

func (s *Literal_valueContext) GetParser() antlr.Parser { return s.parser }

func (s *Literal_valueContext) NUMERIC_LITERAL() antlr.TerminalNode {
	return s.GetToken(SqlParserNUMERIC_LITERAL, 0)
}

func (s *Literal_valueContext) STRING_LITERAL() antlr.TerminalNode {
	return s.GetToken(SqlParserSTRING_LITERAL, 0)
}

func (s *Literal_valueContext) BLOB_LITERAL() antlr.TerminalNode {
	return s.GetToken(SqlParserBLOB_LITERAL, 0)
}

func (s *Literal_valueContext) K_NULL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NULL, 0)
}

func (s *Literal_valueContext) K_CURRENT_TIME() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CURRENT_TIME, 0)
}

func (s *Literal_valueContext) K_CURRENT_DATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CURRENT_DATE, 0)
}

func (s *Literal_valueContext) K_CURRENT_TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CURRENT_TIMESTAMP, 0)
}

func (s *Literal_valueContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Literal_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Literal_valueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterLiteral_value(s)
	}
}

func (s *Literal_valueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitLiteral_value(s)
	}
}




func (p *SqlParser) Literal_value() (localctx ILiteral_valueContext) {
	localctx = NewLiteral_valueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 146, SqlParserRULE_literal_value)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1838)
		_la = p.GetTokenStream().LA(1)

		if !(((((_la - 53)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 53))) & ((1 << (SqlParserK_CURRENT_DATE - 53)) | (1 << (SqlParserK_CURRENT_TIME - 53)) | (1 << (SqlParserK_CURRENT_TIMESTAMP - 53)))) != 0) || _la == SqlParserK_NULL || ((((_la - 157)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 157))) & ((1 << (SqlParserNUMERIC_LITERAL - 157)) | (1 << (SqlParserSTRING_LITERAL - 157)) | (1 << (SqlParserBLOB_LITERAL - 157)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}



	return localctx
}


// IUnary_operatorContext is an interface to support dynamic dispatch.
type IUnary_operatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnary_operatorContext differentiates from other interfaces.
	IsUnary_operatorContext()
}

type Unary_operatorContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnary_operatorContext() *Unary_operatorContext {
	var p = new(Unary_operatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_unary_operator
	return p
}

func (*Unary_operatorContext) IsUnary_operatorContext() {}

func NewUnary_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_operatorContext {
	var p = new(Unary_operatorContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_unary_operator

	return p
}

func (s *Unary_operatorContext) GetParser() antlr.Parser { return s.parser }

func (s *Unary_operatorContext) MINUS() antlr.TerminalNode {
	return s.GetToken(SqlParserMINUS, 0)
}

func (s *Unary_operatorContext) PLUS() antlr.TerminalNode {
	return s.GetToken(SqlParserPLUS, 0)
}

func (s *Unary_operatorContext) TILDE() antlr.TerminalNode {
	return s.GetToken(SqlParserTILDE, 0)
}

func (s *Unary_operatorContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOT, 0)
}

func (s *Unary_operatorContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Unary_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Unary_operatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterUnary_operator(s)
	}
}

func (s *Unary_operatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitUnary_operator(s)
	}
}




func (p *SqlParser) Unary_operator() (localctx IUnary_operatorContext) {
	localctx = NewUnary_operatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 148, SqlParserRULE_unary_operator)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1840)
		_la = p.GetTokenStream().LA(1)

		if !((((_la) & -(0x1f+1)) == 0 && ((1 << uint(_la)) & ((1 << SqlParserPLUS) | (1 << SqlParserMINUS) | (1 << SqlParserTILDE))) != 0) || _la == SqlParserK_NOT) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}



	return localctx
}


// IError_messageContext is an interface to support dynamic dispatch.
type IError_messageContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsError_messageContext differentiates from other interfaces.
	IsError_messageContext()
}

type Error_messageContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyError_messageContext() *Error_messageContext {
	var p = new(Error_messageContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_error_message
	return p
}

func (*Error_messageContext) IsError_messageContext() {}

func NewError_messageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Error_messageContext {
	var p = new(Error_messageContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_error_message

	return p
}

func (s *Error_messageContext) GetParser() antlr.Parser { return s.parser }

func (s *Error_messageContext) STRING_LITERAL() antlr.TerminalNode {
	return s.GetToken(SqlParserSTRING_LITERAL, 0)
}

func (s *Error_messageContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Error_messageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Error_messageContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterError_message(s)
	}
}

func (s *Error_messageContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitError_message(s)
	}
}




func (p *SqlParser) Error_message() (localctx IError_messageContext) {
	localctx = NewError_messageContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 150, SqlParserRULE_error_message)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1842)
		p.Match(SqlParserSTRING_LITERAL)
	}



	return localctx
}


// IModule_argumentContext is an interface to support dynamic dispatch.
type IModule_argumentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModule_argumentContext differentiates from other interfaces.
	IsModule_argumentContext()
}

type Module_argumentContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModule_argumentContext() *Module_argumentContext {
	var p = new(Module_argumentContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_module_argument
	return p
}

func (*Module_argumentContext) IsModule_argumentContext() {}

func NewModule_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Module_argumentContext {
	var p = new(Module_argumentContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_module_argument

	return p
}

func (s *Module_argumentContext) GetParser() antlr.Parser { return s.parser }

func (s *Module_argumentContext) Expr() IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Module_argumentContext) Column_def() IColumn_defContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_defContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IColumn_defContext)
}

func (s *Module_argumentContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Module_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Module_argumentContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterModule_argument(s)
	}
}

func (s *Module_argumentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitModule_argument(s)
	}
}




func (p *SqlParser) Module_argument() (localctx IModule_argumentContext) {
	localctx = NewModule_argumentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 152, SqlParserRULE_module_argument)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			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(1846)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 262, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1844)
			p.expr(0)
		}


	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1845)
			p.Column_def()
		}

	}


	return localctx
}


// IColumn_aliasContext is an interface to support dynamic dispatch.
type IColumn_aliasContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsColumn_aliasContext differentiates from other interfaces.
	IsColumn_aliasContext()
}

type Column_aliasContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColumn_aliasContext() *Column_aliasContext {
	var p = new(Column_aliasContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_column_alias
	return p
}

func (*Column_aliasContext) IsColumn_aliasContext() {}

func NewColumn_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_aliasContext {
	var p = new(Column_aliasContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_column_alias

	return p
}

func (s *Column_aliasContext) GetParser() antlr.Parser { return s.parser }

func (s *Column_aliasContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(SqlParserIDENTIFIER, 0)
}

func (s *Column_aliasContext) STRING_LITERAL() antlr.TerminalNode {
	return s.GetToken(SqlParserSTRING_LITERAL, 0)
}

func (s *Column_aliasContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Column_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Column_aliasContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterColumn_alias(s)
	}
}

func (s *Column_aliasContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitColumn_alias(s)
	}
}




func (p *SqlParser) Column_alias() (localctx IColumn_aliasContext) {
	localctx = NewColumn_aliasContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 154, SqlParserRULE_column_alias)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1848)
		_la = p.GetTokenStream().LA(1)

		if !(_la == SqlParserIDENTIFIER || _la == SqlParserSTRING_LITERAL) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}



	return localctx
}


// IKeywordContext is an interface to support dynamic dispatch.
type IKeywordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKeywordContext differentiates from other interfaces.
	IsKeywordContext()
}

type KeywordContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyKeywordContext() *KeywordContext {
	var p = new(KeywordContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_keyword
	return p
}

func (*KeywordContext) IsKeywordContext() {}

func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordContext {
	var p = new(KeywordContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_keyword

	return p
}

func (s *KeywordContext) GetParser() antlr.Parser { return s.parser }

func (s *KeywordContext) K_ABORT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ABORT, 0)
}

func (s *KeywordContext) K_ACTION() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ACTION, 0)
}

func (s *KeywordContext) K_ADD() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ADD, 0)
}

func (s *KeywordContext) K_AFTER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AFTER, 0)
}

func (s *KeywordContext) K_ALL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ALL, 0)
}

func (s *KeywordContext) K_ALTER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ALTER, 0)
}

func (s *KeywordContext) K_ANALYZE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ANALYZE, 0)
}

func (s *KeywordContext) K_AND() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AND, 0)
}

func (s *KeywordContext) K_AS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AS, 0)
}

func (s *KeywordContext) K_ASC() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ASC, 0)
}

func (s *KeywordContext) K_ATTACH() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ATTACH, 0)
}

func (s *KeywordContext) K_AUTOINCREMENT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_AUTOINCREMENT, 0)
}

func (s *KeywordContext) K_BEFORE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BEFORE, 0)
}

func (s *KeywordContext) K_BEGIN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BEGIN, 0)
}

func (s *KeywordContext) K_BETWEEN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BETWEEN, 0)
}

func (s *KeywordContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_BY, 0)
}

func (s *KeywordContext) K_CASCADE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CASCADE, 0)
}

func (s *KeywordContext) K_CASE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CASE, 0)
}

func (s *KeywordContext) K_CAST() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CAST, 0)
}

func (s *KeywordContext) K_CHECK() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CHECK, 0)
}

func (s *KeywordContext) K_COLLATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_COLLATE, 0)
}

func (s *KeywordContext) K_COLUMN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_COLUMN, 0)
}

func (s *KeywordContext) K_COMMIT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_COMMIT, 0)
}

func (s *KeywordContext) K_CONFLICT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CONFLICT, 0)
}

func (s *KeywordContext) K_CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CONSTRAINT, 0)
}

func (s *KeywordContext) K_CREATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CREATE, 0)
}

func (s *KeywordContext) K_CROSS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CROSS, 0)
}

func (s *KeywordContext) K_CURRENT_DATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CURRENT_DATE, 0)
}

func (s *KeywordContext) K_CURRENT_TIME() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CURRENT_TIME, 0)
}

func (s *KeywordContext) K_CURRENT_TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_CURRENT_TIMESTAMP, 0)
}

func (s *KeywordContext) K_DATABASE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DATABASE, 0)
}

func (s *KeywordContext) K_DEFAULT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DEFAULT, 0)
}

func (s *KeywordContext) K_DEFERRABLE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DEFERRABLE, 0)
}

func (s *KeywordContext) K_DEFERRED() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DEFERRED, 0)
}

func (s *KeywordContext) K_DELETE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DELETE, 0)
}

func (s *KeywordContext) K_DESC() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DESC, 0)
}

func (s *KeywordContext) K_DETACH() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DETACH, 0)
}

func (s *KeywordContext) K_DISTINCT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DISTINCT, 0)
}

func (s *KeywordContext) K_DROP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_DROP, 0)
}

func (s *KeywordContext) K_EACH() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EACH, 0)
}

func (s *KeywordContext) K_ELSE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ELSE, 0)
}

func (s *KeywordContext) K_END() antlr.TerminalNode {
	return s.GetToken(SqlParserK_END, 0)
}

func (s *KeywordContext) K_ENABLE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ENABLE, 0)
}

func (s *KeywordContext) K_ESCAPE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ESCAPE, 0)
}

func (s *KeywordContext) K_EXCEPT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXCEPT, 0)
}

func (s *KeywordContext) K_EXCLUSIVE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXCLUSIVE, 0)
}

func (s *KeywordContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXISTS, 0)
}

func (s *KeywordContext) K_EXPLAIN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_EXPLAIN, 0)
}

func (s *KeywordContext) K_FAIL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FAIL, 0)
}

func (s *KeywordContext) K_FOR() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FOR, 0)
}

func (s *KeywordContext) K_FOREIGN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FOREIGN, 0)
}

func (s *KeywordContext) K_FROM() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FROM, 0)
}

func (s *KeywordContext) K_FULL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_FULL, 0)
}

func (s *KeywordContext) K_GLOB() antlr.TerminalNode {
	return s.GetToken(SqlParserK_GLOB, 0)
}

func (s *KeywordContext) K_GROUP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_GROUP, 0)
}

func (s *KeywordContext) K_HAVING() antlr.TerminalNode {
	return s.GetToken(SqlParserK_HAVING, 0)
}

func (s *KeywordContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IF, 0)
}

func (s *KeywordContext) K_IGNORE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IGNORE, 0)
}

func (s *KeywordContext) K_IMMEDIATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IMMEDIATE, 0)
}

func (s *KeywordContext) K_IN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IN, 0)
}

func (s *KeywordContext) K_INDEX() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INDEX, 0)
}

func (s *KeywordContext) K_INDEXED() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INDEXED, 0)
}

func (s *KeywordContext) K_INITIALLY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INITIALLY, 0)
}

func (s *KeywordContext) K_INNER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INNER, 0)
}

func (s *KeywordContext) K_INSERT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INSERT, 0)
}

func (s *KeywordContext) K_INSTEAD() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INSTEAD, 0)
}

func (s *KeywordContext) K_INTERSECT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INTERSECT, 0)
}

func (s *KeywordContext) K_INTO() antlr.TerminalNode {
	return s.GetToken(SqlParserK_INTO, 0)
}

func (s *KeywordContext) K_IS() antlr.TerminalNode {
	return s.GetToken(SqlParserK_IS, 0)
}

func (s *KeywordContext) K_ISNULL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ISNULL, 0)
}

func (s *KeywordContext) K_JOIN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_JOIN, 0)
}

func (s *KeywordContext) K_KEY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_KEY, 0)
}

func (s *KeywordContext) K_LEFT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_LEFT, 0)
}

func (s *KeywordContext) K_LIKE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_LIKE, 0)
}

func (s *KeywordContext) K_LIMIT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_LIMIT, 0)
}

func (s *KeywordContext) K_MATCH() antlr.TerminalNode {
	return s.GetToken(SqlParserK_MATCH, 0)
}

func (s *KeywordContext) K_NATURAL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NATURAL, 0)
}

func (s *KeywordContext) K_NO() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NO, 0)
}

func (s *KeywordContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOT, 0)
}

func (s *KeywordContext) K_NOTNULL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NOTNULL, 0)
}

func (s *KeywordContext) K_NULL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NULL, 0)
}

func (s *KeywordContext) K_OF() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OF, 0)
}

func (s *KeywordContext) K_OFFSET() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OFFSET, 0)
}

func (s *KeywordContext) K_ON() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ON, 0)
}

func (s *KeywordContext) K_OR() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OR, 0)
}

func (s *KeywordContext) K_ORDER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ORDER, 0)
}

func (s *KeywordContext) K_OUTER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_OUTER, 0)
}

func (s *KeywordContext) K_PLAN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_PLAN, 0)
}

func (s *KeywordContext) K_PRAGMA() antlr.TerminalNode {
	return s.GetToken(SqlParserK_PRAGMA, 0)
}

func (s *KeywordContext) K_PRIMARY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_PRIMARY, 0)
}

func (s *KeywordContext) K_QUERY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_QUERY, 0)
}

func (s *KeywordContext) K_RAISE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_RAISE, 0)
}

func (s *KeywordContext) K_RECURSIVE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_RECURSIVE, 0)
}

func (s *KeywordContext) K_REFERENCES() antlr.TerminalNode {
	return s.GetToken(SqlParserK_REFERENCES, 0)
}

func (s *KeywordContext) K_REGEXP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_REGEXP, 0)
}

func (s *KeywordContext) K_REINDEX() antlr.TerminalNode {
	return s.GetToken(SqlParserK_REINDEX, 0)
}

func (s *KeywordContext) K_RELEASE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_RELEASE, 0)
}

func (s *KeywordContext) K_RENAME() antlr.TerminalNode {
	return s.GetToken(SqlParserK_RENAME, 0)
}

func (s *KeywordContext) K_REPLACE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_REPLACE, 0)
}

func (s *KeywordContext) K_RESTRICT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_RESTRICT, 0)
}

func (s *KeywordContext) K_RIGHT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_RIGHT, 0)
}

func (s *KeywordContext) K_ROLLBACK() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ROLLBACK, 0)
}

func (s *KeywordContext) K_ROW() antlr.TerminalNode {
	return s.GetToken(SqlParserK_ROW, 0)
}

func (s *KeywordContext) K_SAVEPOINT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_SAVEPOINT, 0)
}

func (s *KeywordContext) K_SELECT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_SELECT, 0)
}

func (s *KeywordContext) K_SET() antlr.TerminalNode {
	return s.GetToken(SqlParserK_SET, 0)
}

func (s *KeywordContext) K_TABLE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TABLE, 0)
}

func (s *KeywordContext) K_TEMP() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TEMP, 0)
}

func (s *KeywordContext) K_TEMPORARY() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TEMPORARY, 0)
}

func (s *KeywordContext) K_THEN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_THEN, 0)
}

func (s *KeywordContext) K_TO() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TO, 0)
}

func (s *KeywordContext) K_TRANSACTION() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TRANSACTION, 0)
}

func (s *KeywordContext) K_TRIGGER() antlr.TerminalNode {
	return s.GetToken(SqlParserK_TRIGGER, 0)
}

func (s *KeywordContext) K_UNION() antlr.TerminalNode {
	return s.GetToken(SqlParserK_UNION, 0)
}

func (s *KeywordContext) K_UNIQUE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_UNIQUE, 0)
}

func (s *KeywordContext) K_UPDATE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_UPDATE, 0)
}

func (s *KeywordContext) K_USING() antlr.TerminalNode {
	return s.GetToken(SqlParserK_USING, 0)
}

func (s *KeywordContext) K_VACUUM() antlr.TerminalNode {
	return s.GetToken(SqlParserK_VACUUM, 0)
}

func (s *KeywordContext) K_VALUES() antlr.TerminalNode {
	return s.GetToken(SqlParserK_VALUES, 0)
}

func (s *KeywordContext) K_VIEW() antlr.TerminalNode {
	return s.GetToken(SqlParserK_VIEW, 0)
}

func (s *KeywordContext) K_VIRTUAL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_VIRTUAL, 0)
}

func (s *KeywordContext) K_WHEN() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WHEN, 0)
}

func (s *KeywordContext) K_WHERE() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WHERE, 0)
}

func (s *KeywordContext) K_WITH() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WITH, 0)
}

func (s *KeywordContext) K_WITHOUT() antlr.TerminalNode {
	return s.GetToken(SqlParserK_WITHOUT, 0)
}

func (s *KeywordContext) K_NEXTVAL() antlr.TerminalNode {
	return s.GetToken(SqlParserK_NEXTVAL, 0)
}

func (s *KeywordContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *KeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *KeywordContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterKeyword(s)
	}
}

func (s *KeywordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitKeyword(s)
	}
}




func (p *SqlParser) Keyword() (localctx IKeywordContext) {
	localctx = NewKeywordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 156, SqlParserRULE_keyword)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1850)
		_la = p.GetTokenStream().LA(1)

		if !((((_la) & -(0x1f+1)) == 0 && ((1 << uint(_la)) & ((1 << SqlParserK_ABORT) | (1 << SqlParserK_ACTION) | (1 << SqlParserK_ADD) | (1 << SqlParserK_AFTER) | (1 << SqlParserK_ALL) | (1 << SqlParserK_ALTER))) != 0) || ((((_la - 32)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 32))) & ((1 << (SqlParserK_ANALYZE - 32)) | (1 << (SqlParserK_AND - 32)) | (1 << (SqlParserK_AS - 32)) | (1 << (SqlParserK_ASC - 32)) | (1 << (SqlParserK_ATTACH - 32)) | (1 << (SqlParserK_AUTOINCREMENT - 32)) | (1 << (SqlParserK_BEFORE - 32)) | (1 << (SqlParserK_BEGIN - 32)) | (1 << (SqlParserK_BETWEEN - 32)) | (1 << (SqlParserK_BY - 32)) | (1 << (SqlParserK_CASCADE - 32)) | (1 << (SqlParserK_CASE - 32)) | (1 << (SqlParserK_CAST - 32)) | (1 << (SqlParserK_CHECK - 32)) | (1 << (SqlParserK_COLLATE - 32)) | (1 << (SqlParserK_COLUMN - 32)) | (1 << (SqlParserK_COMMIT - 32)) | (1 << (SqlParserK_CONFLICT - 32)) | (1 << (SqlParserK_CONSTRAINT - 32)) | (1 << (SqlParserK_CREATE - 32)) | (1 << (SqlParserK_CROSS - 32)) | (1 << (SqlParserK_CURRENT_DATE - 32)) | (1 << (SqlParserK_CURRENT_TIME - 32)) | (1 << (SqlParserK_CURRENT_TIMESTAMP - 32)) | (1 << (SqlParserK_DATABASE - 32)) | (1 << (SqlParserK_DEFAULT - 32)) | (1 << (SqlParserK_DEFERRABLE - 32)) | (1 << (SqlParserK_DEFERRED - 32)) | (1 << (SqlParserK_DELETE - 32)) | (1 << (SqlParserK_DESC - 32)) | (1 << (SqlParserK_DETACH - 32)) | (1 << (SqlParserK_DISTINCT - 32)))) != 0) || ((((_la - 64)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 64))) & ((1 << (SqlParserK_DROP - 64)) | (1 << (SqlParserK_EACH - 64)) | (1 << (SqlParserK_ELSE - 64)) | (1 << (SqlParserK_END - 64)) | (1 << (SqlParserK_ENABLE - 64)) | (1 << (SqlParserK_ESCAPE - 64)) | (1 << (SqlParserK_EXCEPT - 64)) | (1 << (SqlParserK_EXCLUSIVE - 64)) | (1 << (SqlParserK_EXISTS - 64)) | (1 << (SqlParserK_EXPLAIN - 64)) | (1 << (SqlParserK_FAIL - 64)) | (1 << (SqlParserK_FOR - 64)) | (1 << (SqlParserK_FOREIGN - 64)) | (1 << (SqlParserK_FROM - 64)) | (1 << (SqlParserK_FULL - 64)) | (1 << (SqlParserK_GLOB - 64)) | (1 << (SqlParserK_GROUP - 64)) | (1 << (SqlParserK_HAVING - 64)) | (1 << (SqlParserK_IF - 64)) | (1 << (SqlParserK_IGNORE - 64)) | (1 << (SqlParserK_IMMEDIATE - 64)) | (1 << (SqlParserK_IN - 64)) | (1 << (SqlParserK_INDEX - 64)) | (1 << (SqlParserK_INDEXED - 64)) | (1 << (SqlParserK_INITIALLY - 64)) | (1 << (SqlParserK_INNER - 64)) | (1 << (SqlParserK_INSERT - 64)) | (1 << (SqlParserK_INSTEAD - 64)) | (1 << (SqlParserK_INTERSECT - 64)) | (1 << (SqlParserK_INTO - 64)))) != 0) || ((((_la - 96)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 96))) & ((1 << (SqlParserK_IS - 96)) | (1 << (SqlParserK_ISNULL - 96)) | (1 << (SqlParserK_JOIN - 96)) | (1 << (SqlParserK_KEY - 96)) | (1 << (SqlParserK_LEFT - 96)) | (1 << (SqlParserK_LIKE - 96)) | (1 << (SqlParserK_LIMIT - 96)) | (1 << (SqlParserK_MATCH - 96)) | (1 << (SqlParserK_NATURAL - 96)) | (1 << (SqlParserK_NEXTVAL - 96)) | (1 << (SqlParserK_NO - 96)) | (1 << (SqlParserK_NOT - 96)) | (1 << (SqlParserK_NOTNULL - 96)) | (1 << (SqlParserK_NULL - 96)) | (1 << (SqlParserK_OF - 96)) | (1 << (SqlParserK_OFFSET - 96)) | (1 << (SqlParserK_ON - 96)) | (1 << (SqlParserK_OR - 96)) | (1 << (SqlParserK_ORDER - 96)) | (1 << (SqlParserK_OUTER - 96)) | (1 << (SqlParserK_PLAN - 96)) | (1 << (SqlParserK_PRAGMA - 96)) | (1 << (SqlParserK_PRIMARY - 96)) | (1 << (SqlParserK_QUERY - 96)) | (1 << (SqlParserK_RAISE - 96)) | (1 << (SqlParserK_RECURSIVE - 96)) | (1 << (SqlParserK_REFERENCES - 96)) | (1 << (SqlParserK_REGEXP - 96)) | (1 << (SqlParserK_REINDEX - 96)) | (1 << (SqlParserK_RELEASE - 96)) | (1 << (SqlParserK_RENAME - 96)))) != 0) || ((((_la - 128)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 128))) & ((1 << (SqlParserK_REPLACE - 128)) | (1 << (SqlParserK_RESTRICT - 128)) | (1 << (SqlParserK_RIGHT - 128)) | (1 << (SqlParserK_ROLLBACK - 128)) | (1 << (SqlParserK_ROW - 128)) | (1 << (SqlParserK_SAVEPOINT - 128)) | (1 << (SqlParserK_SELECT - 128)) | (1 << (SqlParserK_SET - 128)) | (1 << (SqlParserK_TABLE - 128)) | (1 << (SqlParserK_TEMP - 128)) | (1 << (SqlParserK_TEMPORARY - 128)) | (1 << (SqlParserK_THEN - 128)) | (1 << (SqlParserK_TO - 128)) | (1 << (SqlParserK_TRANSACTION - 128)) | (1 << (SqlParserK_TRIGGER - 128)) | (1 << (SqlParserK_UNION - 128)) | (1 << (SqlParserK_UNIQUE - 128)) | (1 << (SqlParserK_UPDATE - 128)) | (1 << (SqlParserK_USING - 128)) | (1 << (SqlParserK_VACUUM - 128)) | (1 << (SqlParserK_VALUES - 128)) | (1 << (SqlParserK_VIEW - 128)) | (1 << (SqlParserK_VIRTUAL - 128)) | (1 << (SqlParserK_WHEN - 128)) | (1 << (SqlParserK_WHERE - 128)) | (1 << (SqlParserK_WITH - 128)) | (1 << (SqlParserK_WITHOUT - 128)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}



	return localctx
}


// IUnknownContext is an interface to support dynamic dispatch.
type IUnknownContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnknownContext differentiates from other interfaces.
	IsUnknownContext()
}

type UnknownContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyUnknownContext() *UnknownContext {
	var p = new(UnknownContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_unknown
	return p
}

func (*UnknownContext) IsUnknownContext() {}

func NewUnknownContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnknownContext {
	var p = new(UnknownContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_unknown

	return p
}

func (s *UnknownContext) GetParser() antlr.Parser { return s.parser }
func (s *UnknownContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *UnknownContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *UnknownContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterUnknown(s)
	}
}

func (s *UnknownContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitUnknown(s)
	}
}




func (p *SqlParser) Unknown() (localctx IUnknownContext) {
	localctx = NewUnknownContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 158, SqlParserRULE_unknown)
	var _la int


	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	p.SetState(1853)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)


	for ok := true; ok; ok = (((_la) & -(0x1f+1)) == 0 && ((1 << uint(_la)) & ((1 << SqlParserT__0) | (1 << SqlParserSCOL) | (1 << SqlParserDOT) | (1 << SqlParserOPEN_PAR) | (1 << SqlParserCLOSE_PAR) | (1 << SqlParserCOMMA) | (1 << SqlParserASSIGN) | (1 << SqlParserSTAR) | (1 << SqlParserPLUS) | (1 << SqlParserMINUS) | (1 << SqlParserTILDE) | (1 << SqlParserPIPE2) | (1 << SqlParserDIV) | (1 << SqlParserMOD) | (1 << SqlParserLT2) | (1 << SqlParserGT2) | (1 << SqlParserAMP) | (1 << SqlParserPIPE) | (1 << SqlParserLT) | (1 << SqlParserLT_EQ) | (1 << SqlParserGT) | (1 << SqlParserGT_EQ) | (1 << SqlParserEQ) | (1 << SqlParserNOT_EQ1) | (1 << SqlParserNOT_EQ2) | (1 << SqlParserK_ABORT) | (1 << SqlParserK_ACTION) | (1 << SqlParserK_ADD) | (1 << SqlParserK_AFTER) | (1 << SqlParserK_ALL) | (1 << SqlParserK_ALTER))) != 0) || ((((_la - 32)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 32))) & ((1 << (SqlParserK_ANALYZE - 32)) | (1 << (SqlParserK_AND - 32)) | (1 << (SqlParserK_AS - 32)) | (1 << (SqlParserK_ASC - 32)) | (1 << (SqlParserK_ATTACH - 32)) | (1 << (SqlParserK_AUTOINCREMENT - 32)) | (1 << (SqlParserK_BEFORE - 32)) | (1 << (SqlParserK_BEGIN - 32)) | (1 << (SqlParserK_BETWEEN - 32)) | (1 << (SqlParserK_BY - 32)) | (1 << (SqlParserK_CASCADE - 32)) | (1 << (SqlParserK_CASE - 32)) | (1 << (SqlParserK_CAST - 32)) | (1 << (SqlParserK_CHECK - 32)) | (1 << (SqlParserK_COLLATE - 32)) | (1 << (SqlParserK_COLUMN - 32)) | (1 << (SqlParserK_COMMIT - 32)) | (1 << (SqlParserK_CONFLICT - 32)) | (1 << (SqlParserK_CONSTRAINT - 32)) | (1 << (SqlParserK_CREATE - 32)) | (1 << (SqlParserK_CROSS - 32)) | (1 << (SqlParserK_CURRENT_DATE - 32)) | (1 << (SqlParserK_CURRENT_TIME - 32)) | (1 << (SqlParserK_CURRENT_TIMESTAMP - 32)) | (1 << (SqlParserK_DATABASE - 32)) | (1 << (SqlParserK_DEFAULT - 32)) | (1 << (SqlParserK_DEFERRABLE - 32)) | (1 << (SqlParserK_DEFERRED - 32)) | (1 << (SqlParserK_DELETE - 32)) | (1 << (SqlParserK_DESC - 32)) | (1 << (SqlParserK_DETACH - 32)) | (1 << (SqlParserK_DISTINCT - 32)))) != 0) || ((((_la - 64)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 64))) & ((1 << (SqlParserK_DROP - 64)) | (1 << (SqlParserK_EACH - 64)) | (1 << (SqlParserK_ELSE - 64)) | (1 << (SqlParserK_END - 64)) | (1 << (SqlParserK_ENABLE - 64)) | (1 << (SqlParserK_DISABLE - 64)) | (1 << (SqlParserK_NOVALIDATE - 64)) | (1 << (SqlParserK_ESCAPE - 64)) | (1 << (SqlParserK_EXCEPT - 64)) | (1 << (SqlParserK_EXCLUSIVE - 64)) | (1 << (SqlParserK_EXISTS - 64)) | (1 << (SqlParserK_EXPLAIN - 64)) | (1 << (SqlParserK_FAIL - 64)) | (1 << (SqlParserK_FOR - 64)) | (1 << (SqlParserK_FOREIGN - 64)) | (1 << (SqlParserK_FROM - 64)) | (1 << (SqlParserK_FULL - 64)) | (1 << (SqlParserK_GLOB - 64)) | (1 << (SqlParserK_GROUP - 64)) | (1 << (SqlParserK_HAVING - 64)) | (1 << (SqlParserK_IF - 64)) | (1 << (SqlParserK_IGNORE - 64)) | (1 << (SqlParserK_IMMEDIATE - 64)) | (1 << (SqlParserK_IN - 64)) | (1 << (SqlParserK_INDEX - 64)) | (1 << (SqlParserK_INDEXED - 64)) | (1 << (SqlParserK_INITIALLY - 64)) | (1 << (SqlParserK_INNER - 64)) | (1 << (SqlParserK_INSERT - 64)) | (1 << (SqlParserK_INSTEAD - 64)) | (1 << (SqlParserK_INTERSECT - 64)) | (1 << (SqlParserK_INTO - 64)))) != 0) || ((((_la - 96)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 96))) & ((1 << (SqlParserK_IS - 96)) | (1 << (SqlParserK_ISNULL - 96)) | (1 << (SqlParserK_JOIN - 96)) | (1 << (SqlParserK_KEY - 96)) | (1 << (SqlParserK_LEFT - 96)) | (1 << (SqlParserK_LIKE - 96)) | (1 << (SqlParserK_LIMIT - 96)) | (1 << (SqlParserK_MATCH - 96)) | (1 << (SqlParserK_NATURAL - 96)) | (1 << (SqlParserK_NEXTVAL - 96)) | (1 << (SqlParserK_NO - 96)) | (1 << (SqlParserK_NOT - 96)) | (1 << (SqlParserK_NOTNULL - 96)) | (1 << (SqlParserK_NULL - 96)) | (1 << (SqlParserK_OF - 96)) | (1 << (SqlParserK_OFFSET - 96)) | (1 << (SqlParserK_ON - 96)) | (1 << (SqlParserK_ONLY - 96)) | (1 << (SqlParserK_OR - 96)) | (1 << (SqlParserK_ORDER - 96)) | (1 << (SqlParserK_OUTER - 96)) | (1 << (SqlParserK_PLAN - 96)) | (1 << (SqlParserK_PRAGMA - 96)) | (1 << (SqlParserK_PRIMARY - 96)) | (1 << (SqlParserK_QUERY - 96)) | (1 << (SqlParserK_RAISE - 96)) | (1 << (SqlParserK_RECURSIVE - 96)) | (1 << (SqlParserK_REFERENCES - 96)) | (1 << (SqlParserK_REGEXP - 96)) | (1 << (SqlParserK_REINDEX - 96)) | (1 << (SqlParserK_RELEASE - 96)) | (1 << (SqlParserK_RENAME - 96)))) != 0) || ((((_la - 128)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 128))) & ((1 << (SqlParserK_REPLACE - 128)) | (1 << (SqlParserK_RESTRICT - 128)) | (1 << (SqlParserK_RIGHT - 128)) | (1 << (SqlParserK_ROLLBACK - 128)) | (1 << (SqlParserK_ROW - 128)) | (1 << (SqlParserK_SAVEPOINT - 128)) | (1 << (SqlParserK_SELECT - 128)) | (1 << (SqlParserK_SET - 128)) | (1 << (SqlParserK_TABLE - 128)) | (1 << (SqlParserK_TEMP - 128)) | (1 << (SqlParserK_TEMPORARY - 128)) | (1 << (SqlParserK_THEN - 128)) | (1 << (SqlParserK_TO - 128)) | (1 << (SqlParserK_TRANSACTION - 128)) | (1 << (SqlParserK_TRIGGER - 128)) | (1 << (SqlParserK_UNION - 128)) | (1 << (SqlParserK_UNIQUE - 128)) | (1 << (SqlParserK_UPDATE - 128)) | (1 << (SqlParserK_USING - 128)) | (1 << (SqlParserK_VACUUM - 128)) | (1 << (SqlParserK_VALUES - 128)) | (1 << (SqlParserK_VIEW - 128)) | (1 << (SqlParserK_FORCE - 128)) | (1 << (SqlParserK_VIRTUAL - 128)) | (1 << (SqlParserK_WHEN - 128)) | (1 << (SqlParserK_WHERE - 128)) | (1 << (SqlParserK_WITH - 128)) | (1 << (SqlParserK_WITHOUT - 128)) | (1 << (SqlParserIDENTIFIER - 128)) | (1 << (SqlParserNUMERIC_LITERAL - 128)) | (1 << (SqlParserBIND_PARAMETER - 128)) | (1 << (SqlParserSTRING_LITERAL - 128)))) != 0) || ((((_la - 160)) & -(0x1f+1)) == 0 && ((1 << uint((_la - 160))) & ((1 << (SqlParserBLOB_LITERAL - 160)) | (1 << (SqlParserSINGLE_LINE_COMMENT - 160)) | (1 << (SqlParserMULTILINE_COMMENT - 160)) | (1 << (SqlParserSPACES - 160)) | (1 << (SqlParserUNEXPECTED_CHAR - 160)))) != 0) {
		p.SetState(1852)
		p.MatchWildcard()



		p.SetState(1855)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}



	return localctx
}


// INameContext is an interface to support dynamic dispatch.
type INameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNameContext differentiates from other interfaces.
	IsNameContext()
}

type NameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNameContext() *NameContext {
	var p = new(NameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_name
	return p
}

func (*NameContext) IsNameContext() {}

func NewNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NameContext {
	var p = new(NameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_name

	return p
}

func (s *NameContext) GetParser() antlr.Parser { return s.parser }

func (s *NameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *NameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *NameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *NameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterName(s)
	}
}

func (s *NameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitName(s)
	}
}




func (p *SqlParser) Name() (localctx INameContext) {
	localctx = NewNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 160, SqlParserRULE_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1857)
		p.Any_name()
	}



	return localctx
}


// IFunction_nameContext is an interface to support dynamic dispatch.
type IFunction_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunction_nameContext differentiates from other interfaces.
	IsFunction_nameContext()
}

type Function_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyFunction_nameContext() *Function_nameContext {
	var p = new(Function_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_function_name
	return p
}

func (*Function_nameContext) IsFunction_nameContext() {}

func NewFunction_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_nameContext {
	var p = new(Function_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_function_name

	return p
}

func (s *Function_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Function_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Function_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Function_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterFunction_name(s)
	}
}

func (s *Function_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitFunction_name(s)
	}
}




func (p *SqlParser) Function_name() (localctx IFunction_nameContext) {
	localctx = NewFunction_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 162, SqlParserRULE_function_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1859)
		p.Any_name()
	}



	return localctx
}


// IDatabase_nameContext is an interface to support dynamic dispatch.
type IDatabase_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDatabase_nameContext differentiates from other interfaces.
	IsDatabase_nameContext()
}

type Database_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyDatabase_nameContext() *Database_nameContext {
	var p = new(Database_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_database_name
	return p
}

func (*Database_nameContext) IsDatabase_nameContext() {}

func NewDatabase_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_nameContext {
	var p = new(Database_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_database_name

	return p
}

func (s *Database_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Database_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Database_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Database_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Database_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterDatabase_name(s)
	}
}

func (s *Database_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitDatabase_name(s)
	}
}




func (p *SqlParser) Database_name() (localctx IDatabase_nameContext) {
	localctx = NewDatabase_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 164, SqlParserRULE_database_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1861)
		p.Any_name()
	}



	return localctx
}


// ISource_table_nameContext is an interface to support dynamic dispatch.
type ISource_table_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSource_table_nameContext differentiates from other interfaces.
	IsSource_table_nameContext()
}

type Source_table_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySource_table_nameContext() *Source_table_nameContext {
	var p = new(Source_table_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_source_table_name
	return p
}

func (*Source_table_nameContext) IsSource_table_nameContext() {}

func NewSource_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Source_table_nameContext {
	var p = new(Source_table_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_source_table_name

	return p
}

func (s *Source_table_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Source_table_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Source_table_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Source_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Source_table_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterSource_table_name(s)
	}
}

func (s *Source_table_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitSource_table_name(s)
	}
}




func (p *SqlParser) Source_table_name() (localctx ISource_table_nameContext) {
	localctx = NewSource_table_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 166, SqlParserRULE_source_table_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1863)
		p.Any_name()
	}



	return localctx
}


// ITable_nameContext is an interface to support dynamic dispatch.
type ITable_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTable_nameContext differentiates from other interfaces.
	IsTable_nameContext()
}

type Table_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTable_nameContext() *Table_nameContext {
	var p = new(Table_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_table_name
	return p
}

func (*Table_nameContext) IsTable_nameContext() {}

func NewTable_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_nameContext {
	var p = new(Table_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_table_name

	return p
}

func (s *Table_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Table_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Table_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Table_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterTable_name(s)
	}
}

func (s *Table_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitTable_name(s)
	}
}




func (p *SqlParser) Table_name() (localctx ITable_nameContext) {
	localctx = NewTable_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 168, SqlParserRULE_table_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1865)
		p.Any_name()
	}



	return localctx
}


// ITable_or_index_nameContext is an interface to support dynamic dispatch.
type ITable_or_index_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTable_or_index_nameContext differentiates from other interfaces.
	IsTable_or_index_nameContext()
}

type Table_or_index_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTable_or_index_nameContext() *Table_or_index_nameContext {
	var p = new(Table_or_index_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_table_or_index_name
	return p
}

func (*Table_or_index_nameContext) IsTable_or_index_nameContext() {}

func NewTable_or_index_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_or_index_nameContext {
	var p = new(Table_or_index_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_table_or_index_name

	return p
}

func (s *Table_or_index_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Table_or_index_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Table_or_index_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Table_or_index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Table_or_index_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterTable_or_index_name(s)
	}
}

func (s *Table_or_index_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitTable_or_index_name(s)
	}
}




func (p *SqlParser) Table_or_index_name() (localctx ITable_or_index_nameContext) {
	localctx = NewTable_or_index_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 170, SqlParserRULE_table_or_index_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1867)
		p.Any_name()
	}



	return localctx
}


// INew_table_nameContext is an interface to support dynamic dispatch.
type INew_table_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNew_table_nameContext differentiates from other interfaces.
	IsNew_table_nameContext()
}

type New_table_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNew_table_nameContext() *New_table_nameContext {
	var p = new(New_table_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_new_table_name
	return p
}

func (*New_table_nameContext) IsNew_table_nameContext() {}

func NewNew_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_table_nameContext {
	var p = new(New_table_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_new_table_name

	return p
}

func (s *New_table_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *New_table_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *New_table_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *New_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *New_table_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterNew_table_name(s)
	}
}

func (s *New_table_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitNew_table_name(s)
	}
}




func (p *SqlParser) New_table_name() (localctx INew_table_nameContext) {
	localctx = NewNew_table_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 172, SqlParserRULE_new_table_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1869)
		p.Any_name()
	}



	return localctx
}


// IColumn_nameContext is an interface to support dynamic dispatch.
type IColumn_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsColumn_nameContext differentiates from other interfaces.
	IsColumn_nameContext()
}

type Column_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyColumn_nameContext() *Column_nameContext {
	var p = new(Column_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_column_name
	return p
}

func (*Column_nameContext) IsColumn_nameContext() {}

func NewColumn_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_nameContext {
	var p = new(Column_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_column_name

	return p
}

func (s *Column_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Column_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Column_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Column_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterColumn_name(s)
	}
}

func (s *Column_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitColumn_name(s)
	}
}




func (p *SqlParser) Column_name() (localctx IColumn_nameContext) {
	localctx = NewColumn_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 174, SqlParserRULE_column_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1871)
		p.Any_name()
	}



	return localctx
}


// ICollation_nameContext is an interface to support dynamic dispatch.
type ICollation_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCollation_nameContext differentiates from other interfaces.
	IsCollation_nameContext()
}

type Collation_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyCollation_nameContext() *Collation_nameContext {
	var p = new(Collation_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_collation_name
	return p
}

func (*Collation_nameContext) IsCollation_nameContext() {}

func NewCollation_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Collation_nameContext {
	var p = new(Collation_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_collation_name

	return p
}

func (s *Collation_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Collation_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Collation_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Collation_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Collation_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterCollation_name(s)
	}
}

func (s *Collation_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitCollation_name(s)
	}
}




func (p *SqlParser) Collation_name() (localctx ICollation_nameContext) {
	localctx = NewCollation_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 176, SqlParserRULE_collation_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1873)
		p.Any_name()
	}



	return localctx
}


// IForeign_tableContext is an interface to support dynamic dispatch.
type IForeign_tableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForeign_tableContext differentiates from other interfaces.
	IsForeign_tableContext()
}

type Foreign_tableContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyForeign_tableContext() *Foreign_tableContext {
	var p = new(Foreign_tableContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_foreign_table
	return p
}

func (*Foreign_tableContext) IsForeign_tableContext() {}

func NewForeign_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_tableContext {
	var p = new(Foreign_tableContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_foreign_table

	return p
}

func (s *Foreign_tableContext) GetParser() antlr.Parser { return s.parser }

func (s *Foreign_tableContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Foreign_tableContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Foreign_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Foreign_tableContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterForeign_table(s)
	}
}

func (s *Foreign_tableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitForeign_table(s)
	}
}




func (p *SqlParser) Foreign_table() (localctx IForeign_tableContext) {
	localctx = NewForeign_tableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 178, SqlParserRULE_foreign_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.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1875)
		p.Any_name()
	}



	return localctx
}


// IIndex_nameContext is an interface to support dynamic dispatch.
type IIndex_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIndex_nameContext differentiates from other interfaces.
	IsIndex_nameContext()
}

type Index_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyIndex_nameContext() *Index_nameContext {
	var p = new(Index_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_index_name
	return p
}

func (*Index_nameContext) IsIndex_nameContext() {}

func NewIndex_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_nameContext {
	var p = new(Index_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_index_name

	return p
}

func (s *Index_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Index_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Index_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Index_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterIndex_name(s)
	}
}

func (s *Index_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitIndex_name(s)
	}
}




func (p *SqlParser) Index_name() (localctx IIndex_nameContext) {
	localctx = NewIndex_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 180, SqlParserRULE_index_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1877)
		p.Any_name()
	}



	return localctx
}


// ITrigger_nameContext is an interface to support dynamic dispatch.
type ITrigger_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTrigger_nameContext differentiates from other interfaces.
	IsTrigger_nameContext()
}

type Trigger_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTrigger_nameContext() *Trigger_nameContext {
	var p = new(Trigger_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_trigger_name
	return p
}

func (*Trigger_nameContext) IsTrigger_nameContext() {}

func NewTrigger_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_nameContext {
	var p = new(Trigger_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_trigger_name

	return p
}

func (s *Trigger_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Trigger_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Trigger_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Trigger_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Trigger_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterTrigger_name(s)
	}
}

func (s *Trigger_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitTrigger_name(s)
	}
}




func (p *SqlParser) Trigger_name() (localctx ITrigger_nameContext) {
	localctx = NewTrigger_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 182, SqlParserRULE_trigger_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1879)
		p.Any_name()
	}



	return localctx
}


// IView_nameContext is an interface to support dynamic dispatch.
type IView_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsView_nameContext differentiates from other interfaces.
	IsView_nameContext()
}

type View_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyView_nameContext() *View_nameContext {
	var p = new(View_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_view_name
	return p
}

func (*View_nameContext) IsView_nameContext() {}

func NewView_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *View_nameContext {
	var p = new(View_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_view_name

	return p
}

func (s *View_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *View_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *View_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *View_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *View_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterView_name(s)
	}
}

func (s *View_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitView_name(s)
	}
}




func (p *SqlParser) View_name() (localctx IView_nameContext) {
	localctx = NewView_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 184, SqlParserRULE_view_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1881)
		p.Any_name()
	}



	return localctx
}


// IModule_nameContext is an interface to support dynamic dispatch.
type IModule_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsModule_nameContext differentiates from other interfaces.
	IsModule_nameContext()
}

type Module_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyModule_nameContext() *Module_nameContext {
	var p = new(Module_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_module_name
	return p
}

func (*Module_nameContext) IsModule_nameContext() {}

func NewModule_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Module_nameContext {
	var p = new(Module_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_module_name

	return p
}

func (s *Module_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Module_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Module_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Module_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Module_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterModule_name(s)
	}
}

func (s *Module_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitModule_name(s)
	}
}




func (p *SqlParser) Module_name() (localctx IModule_nameContext) {
	localctx = NewModule_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 186, SqlParserRULE_module_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1883)
		p.Any_name()
	}



	return localctx
}


// IPragma_nameContext is an interface to support dynamic dispatch.
type IPragma_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPragma_nameContext differentiates from other interfaces.
	IsPragma_nameContext()
}

type Pragma_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyPragma_nameContext() *Pragma_nameContext {
	var p = new(Pragma_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_pragma_name
	return p
}

func (*Pragma_nameContext) IsPragma_nameContext() {}

func NewPragma_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_nameContext {
	var p = new(Pragma_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_pragma_name

	return p
}

func (s *Pragma_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Pragma_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Pragma_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Pragma_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Pragma_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterPragma_name(s)
	}
}

func (s *Pragma_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitPragma_name(s)
	}
}




func (p *SqlParser) Pragma_name() (localctx IPragma_nameContext) {
	localctx = NewPragma_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 188, SqlParserRULE_pragma_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1885)
		p.Any_name()
	}



	return localctx
}


// ISavepoint_nameContext is an interface to support dynamic dispatch.
type ISavepoint_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSavepoint_nameContext differentiates from other interfaces.
	IsSavepoint_nameContext()
}

type Savepoint_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptySavepoint_nameContext() *Savepoint_nameContext {
	var p = new(Savepoint_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_savepoint_name
	return p
}

func (*Savepoint_nameContext) IsSavepoint_nameContext() {}

func NewSavepoint_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Savepoint_nameContext {
	var p = new(Savepoint_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_savepoint_name

	return p
}

func (s *Savepoint_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Savepoint_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Savepoint_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Savepoint_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Savepoint_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterSavepoint_name(s)
	}
}

func (s *Savepoint_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitSavepoint_name(s)
	}
}




func (p *SqlParser) Savepoint_name() (localctx ISavepoint_nameContext) {
	localctx = NewSavepoint_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 190, SqlParserRULE_savepoint_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1887)
		p.Any_name()
	}



	return localctx
}


// ITable_aliasContext is an interface to support dynamic dispatch.
type ITable_aliasContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTable_aliasContext differentiates from other interfaces.
	IsTable_aliasContext()
}

type Table_aliasContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTable_aliasContext() *Table_aliasContext {
	var p = new(Table_aliasContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_table_alias
	return p
}

func (*Table_aliasContext) IsTable_aliasContext() {}

func NewTable_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_aliasContext {
	var p = new(Table_aliasContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_table_alias

	return p
}

func (s *Table_aliasContext) GetParser() antlr.Parser { return s.parser }

func (s *Table_aliasContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Table_aliasContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Table_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Table_aliasContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterTable_alias(s)
	}
}

func (s *Table_aliasContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitTable_alias(s)
	}
}




func (p *SqlParser) Table_alias() (localctx ITable_aliasContext) {
	localctx = NewTable_aliasContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 192, SqlParserRULE_table_alias)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1889)
		p.Any_name()
	}



	return localctx
}


// ITransaction_nameContext is an interface to support dynamic dispatch.
type ITransaction_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTransaction_nameContext differentiates from other interfaces.
	IsTransaction_nameContext()
}

type Transaction_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyTransaction_nameContext() *Transaction_nameContext {
	var p = new(Transaction_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_transaction_name
	return p
}

func (*Transaction_nameContext) IsTransaction_nameContext() {}

func NewTransaction_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_nameContext {
	var p = new(Transaction_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_transaction_name

	return p
}

func (s *Transaction_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Transaction_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Transaction_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Transaction_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Transaction_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterTransaction_name(s)
	}
}

func (s *Transaction_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitTransaction_name(s)
	}
}




func (p *SqlParser) Transaction_name() (localctx ITransaction_nameContext) {
	localctx = NewTransaction_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 194, SqlParserRULE_transaction_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1891)
		p.Any_name()
	}



	return localctx
}


// IAny_nameContext is an interface to support dynamic dispatch.
type IAny_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAny_nameContext differentiates from other interfaces.
	IsAny_nameContext()
}

type Any_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyAny_nameContext() *Any_nameContext {
	var p = new(Any_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SqlParserRULE_any_name
	return p
}

func (*Any_nameContext) IsAny_nameContext() {}

func NewAny_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_nameContext {
	var p = new(Any_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SqlParserRULE_any_name

	return p
}

func (s *Any_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *Any_nameContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(SqlParserIDENTIFIER, 0)
}

func (s *Any_nameContext) Keyword() IKeywordContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKeywordContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IKeywordContext)
}

func (s *Any_nameContext) STRING_LITERAL() antlr.TerminalNode {
	return s.GetToken(SqlParserSTRING_LITERAL, 0)
}

func (s *Any_nameContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserOPEN_PAR, 0)
}

func (s *Any_nameContext) Any_name() IAny_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAny_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

func (s *Any_nameContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SqlParserCLOSE_PAR, 0)
}

func (s *Any_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *Any_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}


func (s *Any_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.EnterAny_name(s)
	}
}

func (s *Any_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SqlListener); ok {
		listenerT.ExitAny_name(s)
	}
}




func (p *SqlParser) Any_name() (localctx IAny_nameContext) {
	localctx = NewAny_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 196, SqlParserRULE_any_name)

	defer func() {
		p.ExitRule()
	}()

	defer func() {
		if err := recover(); err != nil {
			if v, ok := err.(antlr.RecognitionException); ok {
				localctx.SetException(v)
				p.GetErrorHandler().ReportError(p, v)
				p.GetErrorHandler().Recover(p, v)
			} else {
				panic(err)
			}
		}
	}()

	p.SetState(1900)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SqlParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1893)
			p.Match(SqlParserIDENTIFIER)
		}


	case SqlParserK_ABORT, SqlParserK_ACTION, SqlParserK_ADD, SqlParserK_AFTER, SqlParserK_ALL, SqlParserK_ALTER, SqlParserK_ANALYZE, SqlParserK_AND, SqlParserK_AS, SqlParserK_ASC, SqlParserK_ATTACH, SqlParserK_AUTOINCREMENT, SqlParserK_BEFORE, SqlParserK_BEGIN, SqlParserK_BETWEEN, SqlParserK_BY, SqlParserK_CASCADE, SqlParserK_CASE, SqlParserK_CAST, SqlParserK_CHECK, SqlParserK_COLLATE, SqlParserK_COLUMN, SqlParserK_COMMIT, SqlParserK_CONFLICT, SqlParserK_CONSTRAINT, SqlParserK_CREATE, SqlParserK_CROSS, SqlParserK_CURRENT_DATE, SqlParserK_CURRENT_TIME, SqlParserK_CURRENT_TIMESTAMP, SqlParserK_DATABASE, SqlParserK_DEFAULT, SqlParserK_DEFERRABLE, SqlParserK_DEFERRED, SqlParserK_DELETE, SqlParserK_DESC, SqlParserK_DETACH, SqlParserK_DISTINCT, SqlParserK_DROP, SqlParserK_EACH, SqlParserK_ELSE, SqlParserK_END, SqlParserK_ENABLE, SqlParserK_ESCAPE, SqlParserK_EXCEPT, SqlParserK_EXCLUSIVE, SqlParserK_EXISTS, SqlParserK_EXPLAIN, SqlParserK_FAIL, SqlParserK_FOR, SqlParserK_FOREIGN, SqlParserK_FROM, SqlParserK_FULL, SqlParserK_GLOB, SqlParserK_GROUP, SqlParserK_HAVING, SqlParserK_IF, SqlParserK_IGNORE, SqlParserK_IMMEDIATE, SqlParserK_IN, SqlParserK_INDEX, SqlParserK_INDEXED, SqlParserK_INITIALLY, SqlParserK_INNER, SqlParserK_INSERT, SqlParserK_INSTEAD, SqlParserK_INTERSECT, SqlParserK_INTO, SqlParserK_IS, SqlParserK_ISNULL, SqlParserK_JOIN, SqlParserK_KEY, SqlParserK_LEFT, SqlParserK_LIKE, SqlParserK_LIMIT, SqlParserK_MATCH, SqlParserK_NATURAL, SqlParserK_NEXTVAL, SqlParserK_NO, SqlParserK_NOT, SqlParserK_NOTNULL, SqlParserK_NULL, SqlParserK_OF, SqlParserK_OFFSET, SqlParserK_ON, SqlParserK_OR, SqlParserK_ORDER, SqlParserK_OUTER, SqlParserK_PLAN, SqlParserK_PRAGMA, SqlParserK_PRIMARY, SqlParserK_QUERY, SqlParserK_RAISE, SqlParserK_RECURSIVE, SqlParserK_REFERENCES, SqlParserK_REGEXP, SqlParserK_REINDEX, SqlParserK_RELEASE, SqlParserK_RENAME, SqlParserK_REPLACE, SqlParserK_RESTRICT, SqlParserK_RIGHT, SqlParserK_ROLLBACK, SqlParserK_ROW, SqlParserK_SAVEPOINT, SqlParserK_SELECT, SqlParserK_SET, SqlParserK_TABLE, SqlParserK_TEMP, SqlParserK_TEMPORARY, SqlParserK_THEN, SqlParserK_TO, SqlParserK_TRANSACTION, SqlParserK_TRIGGER, SqlParserK_UNION, SqlParserK_UNIQUE, SqlParserK_UPDATE, SqlParserK_USING, SqlParserK_VACUUM, SqlParserK_VALUES, SqlParserK_VIEW, SqlParserK_VIRTUAL, SqlParserK_WHEN, SqlParserK_WHERE, SqlParserK_WITH, SqlParserK_WITHOUT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1894)
			p.Keyword()
		}


	case SqlParserSTRING_LITERAL:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1895)
			p.Match(SqlParserSTRING_LITERAL)
		}


	case SqlParserOPEN_PAR:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1896)
			p.Match(SqlParserOPEN_PAR)
		}
		{
			p.SetState(1897)
			p.Any_name()
		}
		{
			p.SetState(1898)
			p.Match(SqlParserCLOSE_PAR)
		}



	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}


	return localctx
}


func (p *SqlParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
	switch ruleIndex {
	case 48:
			var t *ExprContext = nil
			if localctx != nil { t = localctx.(*ExprContext) }
			return p.Expr_Sempred(t, predIndex)


	default:
		panic("No predicate with index: " + fmt.Sprint(ruleIndex))
	}
}

func (p *SqlParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	switch predIndex {
	case 0:
			return p.Precpred(p.GetParserRuleContext(), 20)

	case 1:
			return p.Precpred(p.GetParserRuleContext(), 19)

	case 2:
			return p.Precpred(p.GetParserRuleContext(), 18)

	case 3:
			return p.Precpred(p.GetParserRuleContext(), 17)

	case 4:
			return p.Precpred(p.GetParserRuleContext(), 16)

	case 5:
			return p.Precpred(p.GetParserRuleContext(), 15)

	case 6:
			return p.Precpred(p.GetParserRuleContext(), 14)

	case 7:
			return p.Precpred(p.GetParserRuleContext(), 13)

	case 8:
			return p.Precpred(p.GetParserRuleContext(), 6)

	case 9:
			return p.Precpred(p.GetParserRuleContext(), 5)

	case 10:
			return p.Precpred(p.GetParserRuleContext(), 9)

	case 11:
			return p.Precpred(p.GetParserRuleContext(), 8)

	case 12:
			return p.Precpred(p.GetParserRuleContext(), 7)

	case 13:
			return p.Precpred(p.GetParserRuleContext(), 4)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}

