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

package parser // SQLiteParser

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

var ruleNames = []string{
	"parse", "sql_stmt_list", "sql_stmt", "alter_table_stmt", "analyze_stmt",
	"attach_stmt", "begin_stmt", "commit_stmt", "rollback_stmt", "savepoint_stmt",
	"release_stmt", "create_index_stmt", "indexed_column", "create_table_stmt",
	"column_def", "type_name", "column_constraint", "signed_number", "table_constraint",
	"foreign_key_clause", "conflict_clause", "create_trigger_stmt", "create_view_stmt",
	"create_virtual_table_stmt", "with_clause", "cte_table_name", "recursive_cte",
	"common_table_expression", "delete_stmt", "delete_stmt_limited", "detach_stmt",
	"drop_stmt", "expr", "raise_function", "literal_value", "insert_stmt",
	"upsert_clause", "pragma_stmt", "pragma_value", "reindex_stmt", "select_stmt",
	"join_clause", "select_core", "factored_select_stmt", "simple_select_stmt",
	"compound_select_stmt", "table_or_subquery", "result_column", "join_operator",
	"join_constraint", "compound_operator", "update_stmt", "column_name_list",
	"update_stmt_limited", "qualified_table_name", "vacuum_stmt", "filter_clause",
	"window_defn", "over_clause", "frame_spec", "frame_clause", "simple_function_invocation",
	"aggregate_function_invocation", "window_function_invocation", "common_table_stmt",
	"order_by_stmt", "limit_stmt", "ordering_term", "asc_desc", "frame_left",
	"frame_right", "frame_single", "window_function", "of_OF_fset", "default_DEFAULT__value",
	"partition_by", "order_by_expr", "order_by_expr_asc_desc", "expr_asc_desc",
	"initial_select", "recursive__select", "unary_operator", "error_message",
	"module_argument", "column_alias", "keyword", "name", "function_name",
	"schema_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",
	"window_name", "alias", "filename", "base_window_name", "simple_func",
	"aggregate_func", "table_function_name", "any_name",
}

type SQLiteParser struct {
	*antlr.BaseParser
}

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

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

	return this
}

// SQLiteParser tokens.
const (
	SQLiteParserEOF                 = antlr.TokenEOF
	SQLiteParserSCOL                = 1
	SQLiteParserDOT                 = 2
	SQLiteParserOPEN_PAR            = 3
	SQLiteParserCLOSE_PAR           = 4
	SQLiteParserCOMMA               = 5
	SQLiteParserASSIGN              = 6
	SQLiteParserSTAR                = 7
	SQLiteParserPLUS                = 8
	SQLiteParserMINUS               = 9
	SQLiteParserTILDE               = 10
	SQLiteParserPIPE2               = 11
	SQLiteParserDIV                 = 12
	SQLiteParserMOD                 = 13
	SQLiteParserLT2                 = 14
	SQLiteParserGT2                 = 15
	SQLiteParserAMP                 = 16
	SQLiteParserPIPE                = 17
	SQLiteParserLT                  = 18
	SQLiteParserLT_EQ               = 19
	SQLiteParserGT                  = 20
	SQLiteParserGT_EQ               = 21
	SQLiteParserEQ                  = 22
	SQLiteParserNOT_EQ1             = 23
	SQLiteParserNOT_EQ2             = 24
	SQLiteParserABORT_              = 25
	SQLiteParserACTION_             = 26
	SQLiteParserADD_                = 27
	SQLiteParserAFTER_              = 28
	SQLiteParserALL_                = 29
	SQLiteParserALTER_              = 30
	SQLiteParserANALYZE_            = 31
	SQLiteParserAND_                = 32
	SQLiteParserAS_                 = 33
	SQLiteParserASC_                = 34
	SQLiteParserATTACH_             = 35
	SQLiteParserAUTOINCREMENT_      = 36
	SQLiteParserBEFORE_             = 37
	SQLiteParserBEGIN_              = 38
	SQLiteParserBETWEEN_            = 39
	SQLiteParserBY_                 = 40
	SQLiteParserCASCADE_            = 41
	SQLiteParserCASE_               = 42
	SQLiteParserCAST_               = 43
	SQLiteParserCHECK_              = 44
	SQLiteParserCOLLATE_            = 45
	SQLiteParserCOLUMN_             = 46
	SQLiteParserCOMMIT_             = 47
	SQLiteParserCONFLICT_           = 48
	SQLiteParserCONSTRAINT_         = 49
	SQLiteParserCREATE_             = 50
	SQLiteParserCROSS_              = 51
	SQLiteParserCURRENT_DATE_       = 52
	SQLiteParserCURRENT_TIME_       = 53
	SQLiteParserCURRENT_TIMESTAMP_  = 54
	SQLiteParserDATABASE_           = 55
	SQLiteParserDEFAULT_            = 56
	SQLiteParserDEFERRABLE_         = 57
	SQLiteParserDEFERRED_           = 58
	SQLiteParserDELETE_             = 59
	SQLiteParserDESC_               = 60
	SQLiteParserDETACH_             = 61
	SQLiteParserDISTINCT_           = 62
	SQLiteParserDROP_               = 63
	SQLiteParserEACH_               = 64
	SQLiteParserELSE_               = 65
	SQLiteParserEND_                = 66
	SQLiteParserESCAPE_             = 67
	SQLiteParserEXCEPT_             = 68
	SQLiteParserEXCLUSIVE_          = 69
	SQLiteParserEXISTS_             = 70
	SQLiteParserEXPLAIN_            = 71
	SQLiteParserFAIL_               = 72
	SQLiteParserFOR_                = 73
	SQLiteParserFOREIGN_            = 74
	SQLiteParserFROM_               = 75
	SQLiteParserFULL_               = 76
	SQLiteParserGLOB_               = 77
	SQLiteParserGROUP_              = 78
	SQLiteParserHAVING_             = 79
	SQLiteParserIF_                 = 80
	SQLiteParserIGNORE_             = 81
	SQLiteParserIMMEDIATE_          = 82
	SQLiteParserIN_                 = 83
	SQLiteParserINDEX_              = 84
	SQLiteParserINDEXED_            = 85
	SQLiteParserINITIALLY_          = 86
	SQLiteParserINNER_              = 87
	SQLiteParserINSERT_             = 88
	SQLiteParserINSTEAD_            = 89
	SQLiteParserINTERSECT_          = 90
	SQLiteParserINTO_               = 91
	SQLiteParserIS_                 = 92
	SQLiteParserISNULL_             = 93
	SQLiteParserJOIN_               = 94
	SQLiteParserKEY_                = 95
	SQLiteParserLEFT_               = 96
	SQLiteParserLIKE_               = 97
	SQLiteParserLIMIT_              = 98
	SQLiteParserMATCH_              = 99
	SQLiteParserNATURAL_            = 100
	SQLiteParserNO_                 = 101
	SQLiteParserNOT_                = 102
	SQLiteParserNOTNULL_            = 103
	SQLiteParserNULL_               = 104
	SQLiteParserOF_                 = 105
	SQLiteParserOFFSET_             = 106
	SQLiteParserON_                 = 107
	SQLiteParserOR_                 = 108
	SQLiteParserORDER_              = 109
	SQLiteParserOUTER_              = 110
	SQLiteParserPLAN_               = 111
	SQLiteParserPRAGMA_             = 112
	SQLiteParserPRIMARY_            = 113
	SQLiteParserQUERY_              = 114
	SQLiteParserRAISE_              = 115
	SQLiteParserRECURSIVE_          = 116
	SQLiteParserREFERENCES_         = 117
	SQLiteParserREGEXP_             = 118
	SQLiteParserREINDEX_            = 119
	SQLiteParserRELEASE_            = 120
	SQLiteParserRENAME_             = 121
	SQLiteParserREPLACE_            = 122
	SQLiteParserRESTRICT_           = 123
	SQLiteParserRIGHT_              = 124
	SQLiteParserROLLBACK_           = 125
	SQLiteParserROW_                = 126
	SQLiteParserROWS_               = 127
	SQLiteParserSAVEPOINT_          = 128
	SQLiteParserSELECT_             = 129
	SQLiteParserSET_                = 130
	SQLiteParserTABLE_              = 131
	SQLiteParserTEMP_               = 132
	SQLiteParserTEMPORARY_          = 133
	SQLiteParserTHEN_               = 134
	SQLiteParserTO_                 = 135
	SQLiteParserTRANSACTION_        = 136
	SQLiteParserTRIGGER_            = 137
	SQLiteParserUNION_              = 138
	SQLiteParserUNIQUE_             = 139
	SQLiteParserUPDATE_             = 140
	SQLiteParserUSING_              = 141
	SQLiteParserVACUUM_             = 142
	SQLiteParserVALUES_             = 143
	SQLiteParserVIEW_               = 144
	SQLiteParserVIRTUAL_            = 145
	SQLiteParserWHEN_               = 146
	SQLiteParserWHERE_              = 147
	SQLiteParserWITH_               = 148
	SQLiteParserWITHOUT_            = 149
	SQLiteParserFIRST_VALUE_        = 150
	SQLiteParserOVER_               = 151
	SQLiteParserPARTITION_          = 152
	SQLiteParserRANGE_              = 153
	SQLiteParserPRECEDING_          = 154
	SQLiteParserUNBOUNDED_          = 155
	SQLiteParserCURRENT_            = 156
	SQLiteParserFOLLOWING_          = 157
	SQLiteParserCUME_DIST_          = 158
	SQLiteParserDENSE_RANK_         = 159
	SQLiteParserLAG_                = 160
	SQLiteParserLAST_VALUE_         = 161
	SQLiteParserLEAD_               = 162
	SQLiteParserNTH_VALUE_          = 163
	SQLiteParserNTILE_              = 164
	SQLiteParserPERCENT_RANK_       = 165
	SQLiteParserRANK_               = 166
	SQLiteParserROW_NUMBER_         = 167
	SQLiteParserGENERATED_          = 168
	SQLiteParserALWAYS_             = 169
	SQLiteParserSTORED_             = 170
	SQLiteParserTRUE_               = 171
	SQLiteParserFALSE_              = 172
	SQLiteParserWINDOW_             = 173
	SQLiteParserNULLS_              = 174
	SQLiteParserFIRST_              = 175
	SQLiteParserLAST_               = 176
	SQLiteParserFILTER_             = 177
	SQLiteParserGROUPS_             = 178
	SQLiteParserEXCLUDE_            = 179
	SQLiteParserTIES_               = 180
	SQLiteParserOTHERS_             = 181
	SQLiteParserDO_                 = 182
	SQLiteParserNOTHING_            = 183
	SQLiteParserIDENTIFIER          = 184
	SQLiteParserNUMERIC_LITERAL     = 185
	SQLiteParserBIND_PARAMETER      = 186
	SQLiteParserSTRING_LITERAL      = 187
	SQLiteParserBLOB_LITERAL        = 188
	SQLiteParserSINGLE_LINE_COMMENT = 189
	SQLiteParserMULTILINE_COMMENT   = 190
	SQLiteParserSPACES              = 191
	SQLiteParserUNEXPECTED_CHAR     = 192
)

// SQLiteParser rules.
const (
	SQLiteParserRULE_parse                         = 0
	SQLiteParserRULE_sql_stmt_list                 = 1
	SQLiteParserRULE_sql_stmt                      = 2
	SQLiteParserRULE_alter_table_stmt              = 3
	SQLiteParserRULE_analyze_stmt                  = 4
	SQLiteParserRULE_attach_stmt                   = 5
	SQLiteParserRULE_begin_stmt                    = 6
	SQLiteParserRULE_commit_stmt                   = 7
	SQLiteParserRULE_rollback_stmt                 = 8
	SQLiteParserRULE_savepoint_stmt                = 9
	SQLiteParserRULE_release_stmt                  = 10
	SQLiteParserRULE_create_index_stmt             = 11
	SQLiteParserRULE_indexed_column                = 12
	SQLiteParserRULE_create_table_stmt             = 13
	SQLiteParserRULE_column_def                    = 14
	SQLiteParserRULE_type_name                     = 15
	SQLiteParserRULE_column_constraint             = 16
	SQLiteParserRULE_signed_number                 = 17
	SQLiteParserRULE_table_constraint              = 18
	SQLiteParserRULE_foreign_key_clause            = 19
	SQLiteParserRULE_conflict_clause               = 20
	SQLiteParserRULE_create_trigger_stmt           = 21
	SQLiteParserRULE_create_view_stmt              = 22
	SQLiteParserRULE_create_virtual_table_stmt     = 23
	SQLiteParserRULE_with_clause                   = 24
	SQLiteParserRULE_cte_table_name                = 25
	SQLiteParserRULE_recursive_cte                 = 26
	SQLiteParserRULE_common_table_expression       = 27
	SQLiteParserRULE_delete_stmt                   = 28
	SQLiteParserRULE_delete_stmt_limited           = 29
	SQLiteParserRULE_detach_stmt                   = 30
	SQLiteParserRULE_drop_stmt                     = 31
	SQLiteParserRULE_expr                          = 32
	SQLiteParserRULE_raise_function                = 33
	SQLiteParserRULE_literal_value                 = 34
	SQLiteParserRULE_insert_stmt                   = 35
	SQLiteParserRULE_upsert_clause                 = 36
	SQLiteParserRULE_pragma_stmt                   = 37
	SQLiteParserRULE_pragma_value                  = 38
	SQLiteParserRULE_reindex_stmt                  = 39
	SQLiteParserRULE_select_stmt                   = 40
	SQLiteParserRULE_join_clause                   = 41
	SQLiteParserRULE_select_core                   = 42
	SQLiteParserRULE_factored_select_stmt          = 43
	SQLiteParserRULE_simple_select_stmt            = 44
	SQLiteParserRULE_compound_select_stmt          = 45
	SQLiteParserRULE_table_or_subquery             = 46
	SQLiteParserRULE_result_column                 = 47
	SQLiteParserRULE_join_operator                 = 48
	SQLiteParserRULE_join_constraint               = 49
	SQLiteParserRULE_compound_operator             = 50
	SQLiteParserRULE_update_stmt                   = 51
	SQLiteParserRULE_column_name_list              = 52
	SQLiteParserRULE_update_stmt_limited           = 53
	SQLiteParserRULE_qualified_table_name          = 54
	SQLiteParserRULE_vacuum_stmt                   = 55
	SQLiteParserRULE_filter_clause                 = 56
	SQLiteParserRULE_window_defn                   = 57
	SQLiteParserRULE_over_clause                   = 58
	SQLiteParserRULE_frame_spec                    = 59
	SQLiteParserRULE_frame_clause                  = 60
	SQLiteParserRULE_simple_function_invocation    = 61
	SQLiteParserRULE_aggregate_function_invocation = 62
	SQLiteParserRULE_window_function_invocation    = 63
	SQLiteParserRULE_common_table_stmt             = 64
	SQLiteParserRULE_order_by_stmt                 = 65
	SQLiteParserRULE_limit_stmt                    = 66
	SQLiteParserRULE_ordering_term                 = 67
	SQLiteParserRULE_asc_desc                      = 68
	SQLiteParserRULE_frame_left                    = 69
	SQLiteParserRULE_frame_right                   = 70
	SQLiteParserRULE_frame_single                  = 71
	SQLiteParserRULE_window_function               = 72
	SQLiteParserRULE_of_OF_fset                    = 73
	SQLiteParserRULE_default_DEFAULT__value        = 74
	SQLiteParserRULE_partition_by                  = 75
	SQLiteParserRULE_order_by_expr                 = 76
	SQLiteParserRULE_order_by_expr_asc_desc        = 77
	SQLiteParserRULE_expr_asc_desc                 = 78
	SQLiteParserRULE_initial_select                = 79
	SQLiteParserRULE_recursive__select             = 80
	SQLiteParserRULE_unary_operator                = 81
	SQLiteParserRULE_error_message                 = 82
	SQLiteParserRULE_module_argument               = 83
	SQLiteParserRULE_column_alias                  = 84
	SQLiteParserRULE_keyword                       = 85
	SQLiteParserRULE_name                          = 86
	SQLiteParserRULE_function_name                 = 87
	SQLiteParserRULE_schema_name                   = 88
	SQLiteParserRULE_table_name                    = 89
	SQLiteParserRULE_table_or_index_name           = 90
	SQLiteParserRULE_new_table_name                = 91
	SQLiteParserRULE_column_name                   = 92
	SQLiteParserRULE_collation_name                = 93
	SQLiteParserRULE_foreign_table                 = 94
	SQLiteParserRULE_index_name                    = 95
	SQLiteParserRULE_trigger_name                  = 96
	SQLiteParserRULE_view_name                     = 97
	SQLiteParserRULE_module_name                   = 98
	SQLiteParserRULE_pragma_name                   = 99
	SQLiteParserRULE_savepoint_name                = 100
	SQLiteParserRULE_table_alias                   = 101
	SQLiteParserRULE_transaction_name              = 102
	SQLiteParserRULE_window_name                   = 103
	SQLiteParserRULE_alias                         = 104
	SQLiteParserRULE_filename                      = 105
	SQLiteParserRULE_base_window_name              = 106
	SQLiteParserRULE_simple_func                   = 107
	SQLiteParserRULE_aggregate_func                = 108
	SQLiteParserRULE_table_function_name           = 109
	SQLiteParserRULE_any_name                      = 110
)

// 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 = SQLiteParserRULE_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 = SQLiteParserRULE_parse

	return p
}

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

func (s *ParseContext) EOF() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEOF, 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) 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.(SQLiteParserListener); ok {
		listenerT.EnterParse(s)
	}
}

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

func (p *SQLiteParser) Parse() (localctx IParseContext) {
	this := p
	_ = this

	localctx = NewParseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 0, SQLiteParserRULE_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(225)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SQLiteParserSCOL)|(1<<SQLiteParserALTER_)|(1<<SQLiteParserANALYZE_))) != 0) || (((_la-35)&-(0x1f+1)) == 0 && ((1<<uint((_la-35)))&((1<<(SQLiteParserATTACH_-35))|(1<<(SQLiteParserBEGIN_-35))|(1<<(SQLiteParserCOMMIT_-35))|(1<<(SQLiteParserCREATE_-35))|(1<<(SQLiteParserDEFAULT_-35))|(1<<(SQLiteParserDELETE_-35))|(1<<(SQLiteParserDETACH_-35))|(1<<(SQLiteParserDROP_-35))|(1<<(SQLiteParserEND_-35)))) != 0) || _la == SQLiteParserEXPLAIN_ || _la == SQLiteParserINSERT_ || (((_la-112)&-(0x1f+1)) == 0 && ((1<<uint((_la-112)))&((1<<(SQLiteParserPRAGMA_-112))|(1<<(SQLiteParserREINDEX_-112))|(1<<(SQLiteParserRELEASE_-112))|(1<<(SQLiteParserREPLACE_-112))|(1<<(SQLiteParserROLLBACK_-112))|(1<<(SQLiteParserSAVEPOINT_-112))|(1<<(SQLiteParserSELECT_-112))|(1<<(SQLiteParserUPDATE_-112))|(1<<(SQLiteParserVACUUM_-112))|(1<<(SQLiteParserVALUES_-112)))) != 0) || _la == SQLiteParserWITH_ {
		{
			p.SetState(222)
			p.Sql_stmt_list()
		}

		p.SetState(227)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(228)
		p.Match(SQLiteParserEOF)
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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(SQLiteParserSCOL)
}

func (s *Sql_stmt_listContext) SCOL(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserSCOL, 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.(SQLiteParserListener); ok {
		listenerT.EnterSql_stmt_list(s)
	}
}

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

func (p *SQLiteParser) Sql_stmt_list() (localctx ISql_stmt_listContext) {
	this := p
	_ = this

	localctx = NewSql_stmt_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 2, SQLiteParserRULE_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(233)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserSCOL {
		{
			p.SetState(230)
			p.Match(SQLiteParserSCOL)
		}

		p.SetState(235)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(236)
		p.Sql_stmt()
	}
	p.SetState(245)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 3, p.GetParserRuleContext())

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

			for ok := true; ok; ok = _la == SQLiteParserSCOL {
				{
					p.SetState(237)
					p.Match(SQLiteParserSCOL)
				}

				p.SetState(240)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(242)
				p.Sql_stmt()
			}

		}
		p.SetState(247)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 3, p.GetParserRuleContext())
	}
	p.SetState(251)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 4, p.GetParserRuleContext())

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

		}
		p.SetState(253)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 4, 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 = SQLiteParserRULE_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 = SQLiteParserRULE_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) 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_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_stmt() IDrop_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDrop_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDrop_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) 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) EXPLAIN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXPLAIN_, 0)
}

func (s *Sql_stmtContext) QUERY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserQUERY_, 0)
}

func (s *Sql_stmtContext) PLAN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPLAN_, 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.(SQLiteParserListener); ok {
		listenerT.EnterSql_stmt(s)
	}
}

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

func (p *SQLiteParser) Sql_stmt() (localctx ISql_stmtContext) {
	this := p
	_ = this

	localctx = NewSql_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 4, SQLiteParserRULE_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(259)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserEXPLAIN_ {
		{
			p.SetState(254)
			p.Match(SQLiteParserEXPLAIN_)
		}
		p.SetState(257)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserQUERY_ {
			{
				p.SetState(255)
				p.Match(SQLiteParserQUERY_)
			}
			{
				p.SetState(256)
				p.Match(SQLiteParserPLAN_)
			}

		}

	}
	p.SetState(285)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(261)
			p.Alter_table_stmt()
		}

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

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

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

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

	case 6:
		{
			p.SetState(266)
			p.Create_index_stmt()
		}

	case 7:
		{
			p.SetState(267)
			p.Create_table_stmt()
		}

	case 8:
		{
			p.SetState(268)
			p.Create_trigger_stmt()
		}

	case 9:
		{
			p.SetState(269)
			p.Create_view_stmt()
		}

	case 10:
		{
			p.SetState(270)
			p.Create_virtual_table_stmt()
		}

	case 11:
		{
			p.SetState(271)
			p.Delete_stmt()
		}

	case 12:
		{
			p.SetState(272)
			p.Delete_stmt_limited()
		}

	case 13:
		{
			p.SetState(273)
			p.Detach_stmt()
		}

	case 14:
		{
			p.SetState(274)
			p.Drop_stmt()
		}

	case 15:
		{
			p.SetState(275)
			p.Insert_stmt()
		}

	case 16:
		{
			p.SetState(276)
			p.Pragma_stmt()
		}

	case 17:
		{
			p.SetState(277)
			p.Reindex_stmt()
		}

	case 18:
		{
			p.SetState(278)
			p.Release_stmt()
		}

	case 19:
		{
			p.SetState(279)
			p.Rollback_stmt()
		}

	case 20:
		{
			p.SetState(280)
			p.Savepoint_stmt()
		}

	case 21:
		{
			p.SetState(281)
			p.Select_stmt()
		}

	case 22:
		{
			p.SetState(282)
			p.Update_stmt()
		}

	case 23:
		{
			p.SetState(283)
			p.Update_stmt_limited()
		}

	case 24:
		{
			p.SetState(284)
			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

	// GetOld_column_name returns the old_column_name rule contexts.
	GetOld_column_name() IColumn_nameContext

	// GetNew_column_name returns the new_column_name rule contexts.
	GetNew_column_name() IColumn_nameContext

	// SetOld_column_name sets the old_column_name rule contexts.
	SetOld_column_name(IColumn_nameContext)

	// SetNew_column_name sets the new_column_name rule contexts.
	SetNew_column_name(IColumn_nameContext)

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

type Alter_table_stmtContext struct {
	*antlr.BaseParserRuleContext
	parser          antlr.Parser
	old_column_name IColumn_nameContext
	new_column_name IColumn_nameContext
}

func NewEmptyAlter_table_stmtContext() *Alter_table_stmtContext {
	var p = new(Alter_table_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_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 = SQLiteParserRULE_alter_table_stmt

	return p
}

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

func (s *Alter_table_stmtContext) GetOld_column_name() IColumn_nameContext { return s.old_column_name }

func (s *Alter_table_stmtContext) GetNew_column_name() IColumn_nameContext { return s.new_column_name }

func (s *Alter_table_stmtContext) SetOld_column_name(v IColumn_nameContext) { s.old_column_name = v }

func (s *Alter_table_stmtContext) SetNew_column_name(v IColumn_nameContext) { s.new_column_name = v }

func (s *Alter_table_stmtContext) ALTER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserALTER_, 0)
}

func (s *Alter_table_stmtContext) TABLE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTABLE_, 0)
}

func (s *Alter_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 *Alter_table_stmtContext) RENAME_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRENAME_, 0)
}

func (s *Alter_table_stmtContext) ADD_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserADD_, 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) DROP_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDROP_, 0)
}

func (s *Alter_table_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 *Alter_table_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 *Alter_table_stmtContext) Schema_name() ISchema_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISchema_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

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

func (s *Alter_table_stmtContext) TO_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTO_, 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) COLUMN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOLUMN_, 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.(SQLiteParserListener); ok {
		listenerT.EnterAlter_table_stmt(s)
	}
}

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

func (p *SQLiteParser) Alter_table_stmt() (localctx IAlter_table_stmtContext) {
	this := p
	_ = this

	localctx = NewAlter_table_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 6, SQLiteParserRULE_alter_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(287)
		p.Match(SQLiteParserALTER_)
	}
	{
		p.SetState(288)
		p.Match(SQLiteParserTABLE_)
	}
	p.SetState(292)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 8, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(289)
			p.Schema_name()
		}
		{
			p.SetState(290)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(294)
		p.Table_name()
	}
	p.SetState(317)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserRENAME_:
		{
			p.SetState(295)
			p.Match(SQLiteParserRENAME_)
		}
		p.SetState(305)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 10, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(296)
				p.Match(SQLiteParserTO_)
			}
			{
				p.SetState(297)
				p.New_table_name()
			}

		case 2:
			p.SetState(299)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 9, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(298)
					p.Match(SQLiteParserCOLUMN_)
				}

			}
			{
				p.SetState(301)

				var _x = p.Column_name()

				localctx.(*Alter_table_stmtContext).old_column_name = _x
			}
			{
				p.SetState(302)
				p.Match(SQLiteParserTO_)
			}
			{
				p.SetState(303)

				var _x = p.Column_name()

				localctx.(*Alter_table_stmtContext).new_column_name = _x
			}

		}

	case SQLiteParserADD_:
		{
			p.SetState(307)
			p.Match(SQLiteParserADD_)
		}
		p.SetState(309)
		p.GetErrorHandler().Sync(p)

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

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

	case SQLiteParserDROP_:
		{
			p.SetState(312)
			p.Match(SQLiteParserDROP_)
		}
		p.SetState(314)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 12, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(313)
				p.Match(SQLiteParserCOLUMN_)
			}

		}
		{
			p.SetState(316)
			p.Column_name()
		}

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

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_analyze_stmt

	return p
}

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

func (s *Analyze_stmtContext) ANALYZE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserANALYZE_, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ISchema_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(SQLiteParserDOT, 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.(SQLiteParserListener); ok {
		listenerT.EnterAnalyze_stmt(s)
	}
}

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

func (p *SQLiteParser) Analyze_stmt() (localctx IAnalyze_stmtContext) {
	this := p
	_ = this

	localctx = NewAnalyze_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 8, SQLiteParserRULE_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(319)
		p.Match(SQLiteParserANALYZE_)
	}
	p.SetState(327)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 15, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(320)
			p.Schema_name()
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 15, p.GetParserRuleContext()) == 2 {
		p.SetState(324)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 14, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(321)
				p.Schema_name()
			}
			{
				p.SetState(322)
				p.Match(SQLiteParserDOT)
			}

		}
		{
			p.SetState(326)
			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 = SQLiteParserRULE_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 = SQLiteParserRULE_attach_stmt

	return p
}

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

func (s *Attach_stmtContext) ATTACH_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserATTACH_, 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) AS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAS_, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

func (s *Attach_stmtContext) DATABASE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDATABASE_, 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.(SQLiteParserListener); ok {
		listenerT.EnterAttach_stmt(s)
	}
}

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

func (p *SQLiteParser) Attach_stmt() (localctx IAttach_stmtContext) {
	this := p
	_ = this

	localctx = NewAttach_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 10, SQLiteParserRULE_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(329)
		p.Match(SQLiteParserATTACH_)
	}
	p.SetState(331)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 16, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(330)
			p.Match(SQLiteParserDATABASE_)
		}

	}
	{
		p.SetState(333)
		p.expr(0)
	}
	{
		p.SetState(334)
		p.Match(SQLiteParserAS_)
	}
	{
		p.SetState(335)
		p.Schema_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 = SQLiteParserRULE_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 = SQLiteParserRULE_begin_stmt

	return p
}

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

func (s *Begin_stmtContext) BEGIN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBEGIN_, 0)
}

func (s *Begin_stmtContext) TRANSACTION_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTRANSACTION_, 0)
}

func (s *Begin_stmtContext) DEFERRED_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDEFERRED_, 0)
}

func (s *Begin_stmtContext) IMMEDIATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIMMEDIATE_, 0)
}

func (s *Begin_stmtContext) EXCLUSIVE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXCLUSIVE_, 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.(SQLiteParserListener); ok {
		listenerT.EnterBegin_stmt(s)
	}
}

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

func (p *SQLiteParser) Begin_stmt() (localctx IBegin_stmtContext) {
	this := p
	_ = this

	localctx = NewBegin_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 12, SQLiteParserRULE_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(337)
		p.Match(SQLiteParserBEGIN_)
	}
	p.SetState(339)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-58)&-(0x1f+1)) == 0 && ((1<<uint((_la-58)))&((1<<(SQLiteParserDEFERRED_-58))|(1<<(SQLiteParserEXCLUSIVE_-58))|(1<<(SQLiteParserIMMEDIATE_-58)))) != 0 {
		{
			p.SetState(338)
			_la = p.GetTokenStream().LA(1)

			if !(((_la-58)&-(0x1f+1)) == 0 && ((1<<uint((_la-58)))&((1<<(SQLiteParserDEFERRED_-58))|(1<<(SQLiteParserEXCLUSIVE_-58))|(1<<(SQLiteParserIMMEDIATE_-58)))) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

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

	if _la == SQLiteParserTRANSACTION_ {
		{
			p.SetState(341)
			p.Match(SQLiteParserTRANSACTION_)
		}
		p.SetState(343)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 18, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(342)
				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 = SQLiteParserRULE_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 = SQLiteParserRULE_commit_stmt

	return p
}

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

func (s *Commit_stmtContext) COMMIT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMIT_, 0)
}

func (s *Commit_stmtContext) END_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEND_, 0)
}

func (s *Commit_stmtContext) TRANSACTION_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTRANSACTION_, 0)
}

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

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

func (p *SQLiteParser) Commit_stmt() (localctx ICommit_stmtContext) {
	this := p
	_ = this

	localctx = NewCommit_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 14, SQLiteParserRULE_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(347)
		_la = p.GetTokenStream().LA(1)

		if !(_la == SQLiteParserCOMMIT_ || _la == SQLiteParserEND_) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(349)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserTRANSACTION_ {
		{
			p.SetState(348)
			p.Match(SQLiteParserTRANSACTION_)
		}

	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_rollback_stmt

	return p
}

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

func (s *Rollback_stmtContext) ROLLBACK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROLLBACK_, 0)
}

func (s *Rollback_stmtContext) TRANSACTION_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTRANSACTION_, 0)
}

func (s *Rollback_stmtContext) TO_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTO_, 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) SAVEPOINT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSAVEPOINT_, 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.(SQLiteParserListener); ok {
		listenerT.EnterRollback_stmt(s)
	}
}

func (s *Rollback_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitRollback_stmt(s)
	}
}

func (p *SQLiteParser) Rollback_stmt() (localctx IRollback_stmtContext) {
	this := p
	_ = this

	localctx = NewRollback_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, SQLiteParserRULE_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(351)
		p.Match(SQLiteParserROLLBACK_)
	}
	p.SetState(353)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserTRANSACTION_ {
		{
			p.SetState(352)
			p.Match(SQLiteParserTRANSACTION_)
		}

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

	if _la == SQLiteParserTO_ {
		{
			p.SetState(355)
			p.Match(SQLiteParserTO_)
		}
		p.SetState(357)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 22, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(356)
				p.Match(SQLiteParserSAVEPOINT_)
			}

		}
		{
			p.SetState(359)
			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 = SQLiteParserRULE_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 = SQLiteParserRULE_savepoint_stmt

	return p
}

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

func (s *Savepoint_stmtContext) SAVEPOINT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSAVEPOINT_, 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.(SQLiteParserListener); ok {
		listenerT.EnterSavepoint_stmt(s)
	}
}

func (s *Savepoint_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitSavepoint_stmt(s)
	}
}

func (p *SQLiteParser) Savepoint_stmt() (localctx ISavepoint_stmtContext) {
	this := p
	_ = this

	localctx = NewSavepoint_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, SQLiteParserRULE_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(362)
		p.Match(SQLiteParserSAVEPOINT_)
	}
	{
		p.SetState(363)
		p.Savepoint_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 = SQLiteParserRULE_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 = SQLiteParserRULE_release_stmt

	return p
}

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

func (s *Release_stmtContext) RELEASE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRELEASE_, 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) SAVEPOINT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSAVEPOINT_, 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.(SQLiteParserListener); ok {
		listenerT.EnterRelease_stmt(s)
	}
}

func (s *Release_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitRelease_stmt(s)
	}
}

func (p *SQLiteParser) Release_stmt() (localctx IRelease_stmtContext) {
	this := p
	_ = this

	localctx = NewRelease_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 20, SQLiteParserRULE_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(365)
		p.Match(SQLiteParserRELEASE_)
	}
	p.SetState(367)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 24, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(366)
			p.Match(SQLiteParserSAVEPOINT_)
		}

	}
	{
		p.SetState(369)
		p.Savepoint_name()
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_create_index_stmt

	return p
}

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

func (s *Create_index_stmtContext) CREATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCREATE_, 0)
}

func (s *Create_index_stmtContext) INDEX_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINDEX_, 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) ON_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserON_, 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(SQLiteParserOPEN_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(SQLiteParserCLOSE_PAR, 0)
}

func (s *Create_index_stmtContext) UNIQUE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUNIQUE_, 0)
}

func (s *Create_index_stmtContext) IF_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIF_, 0)
}

func (s *Create_index_stmtContext) NOT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOT_, 0)
}

func (s *Create_index_stmtContext) EXISTS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXISTS_, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

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

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

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

func (s *Create_index_stmtContext) WHERE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWHERE_, 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.(SQLiteParserListener); ok {
		listenerT.EnterCreate_index_stmt(s)
	}
}

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

func (p *SQLiteParser) Create_index_stmt() (localctx ICreate_index_stmtContext) {
	this := p
	_ = this

	localctx = NewCreate_index_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 22, SQLiteParserRULE_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(371)
		p.Match(SQLiteParserCREATE_)
	}
	p.SetState(373)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserUNIQUE_ {
		{
			p.SetState(372)
			p.Match(SQLiteParserUNIQUE_)
		}

	}
	{
		p.SetState(375)
		p.Match(SQLiteParserINDEX_)
	}
	p.SetState(379)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 26, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(376)
			p.Match(SQLiteParserIF_)
		}
		{
			p.SetState(377)
			p.Match(SQLiteParserNOT_)
		}
		{
			p.SetState(378)
			p.Match(SQLiteParserEXISTS_)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 27, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(381)
			p.Schema_name()
		}
		{
			p.SetState(382)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(386)
		p.Index_name()
	}
	{
		p.SetState(387)
		p.Match(SQLiteParserON_)
	}
	{
		p.SetState(388)
		p.Table_name()
	}
	{
		p.SetState(389)
		p.Match(SQLiteParserOPEN_PAR)
	}
	{
		p.SetState(390)
		p.Indexed_column()
	}
	p.SetState(395)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserCOMMA {
		{
			p.SetState(391)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(392)
			p.Indexed_column()
		}

		p.SetState(397)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(398)
		p.Match(SQLiteParserCLOSE_PAR)
	}
	p.SetState(401)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserWHERE_ {
		{
			p.SetState(399)
			p.Match(SQLiteParserWHERE_)
		}
		{
			p.SetState(400)
			p.expr(0)
		}

	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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) Expr() IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Indexed_columnContext) COLLATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOLLATE_, 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) Asc_desc() IAsc_descContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAsc_descContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAsc_descContext)
}

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

func (s *Indexed_columnContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitIndexed_column(s)
	}
}

func (p *SQLiteParser) Indexed_column() (localctx IIndexed_columnContext) {
	this := p
	_ = this

	localctx = NewIndexed_columnContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, SQLiteParserRULE_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(405)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 30, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(403)
			p.Column_name()
		}

	case 2:
		{
			p.SetState(404)
			p.expr(0)
		}

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

	if _la == SQLiteParserCOLLATE_ {
		{
			p.SetState(407)
			p.Match(SQLiteParserCOLLATE_)
		}
		{
			p.SetState(408)
			p.Collation_name()
		}

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

	if _la == SQLiteParserASC_ || _la == SQLiteParserDESC_ {
		{
			p.SetState(411)
			p.Asc_desc()
		}

	}

	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

	// GetRow_ROW_ID returns the row_ROW_ID token.
	GetRow_ROW_ID() antlr.Token

	// SetRow_ROW_ID sets the row_ROW_ID token.
	SetRow_ROW_ID(antlr.Token)

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

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

func NewEmptyCreate_table_stmtContext() *Create_table_stmtContext {
	var p = new(Create_table_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_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 = SQLiteParserRULE_create_table_stmt

	return p
}

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

func (s *Create_table_stmtContext) GetRow_ROW_ID() antlr.Token { return s.row_ROW_ID }

func (s *Create_table_stmtContext) SetRow_ROW_ID(v antlr.Token) { s.row_ROW_ID = v }

func (s *Create_table_stmtContext) CREATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCREATE_, 0)
}

func (s *Create_table_stmtContext) TABLE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTABLE_, 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(SQLiteParserOPEN_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(SQLiteParserCLOSE_PAR, 0)
}

func (s *Create_table_stmtContext) AS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAS_, 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) IF_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIF_, 0)
}

func (s *Create_table_stmtContext) NOT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOT_, 0)
}

func (s *Create_table_stmtContext) EXISTS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXISTS_, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

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

func (s *Create_table_stmtContext) TEMP_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTEMP_, 0)
}

func (s *Create_table_stmtContext) TEMPORARY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTEMPORARY_, 0)
}

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

func (s *Create_table_stmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMA, 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) WITHOUT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWITHOUT_, 0)
}

func (s *Create_table_stmtContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIDENTIFIER, 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.(SQLiteParserListener); ok {
		listenerT.EnterCreate_table_stmt(s)
	}
}

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

func (p *SQLiteParser) Create_table_stmt() (localctx ICreate_table_stmtContext) {
	this := p
	_ = this

	localctx = NewCreate_table_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 26, SQLiteParserRULE_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)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(414)
		p.Match(SQLiteParserCREATE_)
	}
	p.SetState(416)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserTEMP_ || _la == SQLiteParserTEMPORARY_ {
		{
			p.SetState(415)
			_la = p.GetTokenStream().LA(1)

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

	}
	{
		p.SetState(418)
		p.Match(SQLiteParserTABLE_)
	}
	p.SetState(422)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 34, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(419)
			p.Match(SQLiteParserIF_)
		}
		{
			p.SetState(420)
			p.Match(SQLiteParserNOT_)
		}
		{
			p.SetState(421)
			p.Match(SQLiteParserEXISTS_)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 35, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(424)
			p.Schema_name()
		}
		{
			p.SetState(425)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(429)
		p.Table_name()
	}
	p.SetState(453)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserOPEN_PAR:
		{
			p.SetState(430)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(431)
			p.Column_def()
		}
		p.SetState(436)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 36, p.GetParserRuleContext())

		for _alt != 1 && _alt != antlr.ATNInvalidAltNumber {
			if _alt == 1+1 {
				{
					p.SetState(432)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(433)
					p.Column_def()
				}

			}
			p.SetState(438)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 36, p.GetParserRuleContext())
		}
		p.SetState(443)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(439)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(440)
				p.Table_constraint()
			}

			p.SetState(445)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(446)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		p.SetState(449)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserWITHOUT_ {
			{
				p.SetState(447)
				p.Match(SQLiteParserWITHOUT_)
			}
			{
				p.SetState(448)

				var _m = p.Match(SQLiteParserIDENTIFIER)

				localctx.(*Create_table_stmtContext).row_ROW_ID = _m
			}

		}

	case SQLiteParserAS_:
		{
			p.SetState(451)
			p.Match(SQLiteParserAS_)
		}
		{
			p.SetState(452)
			p.Select_stmt()
		}

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

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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) 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 *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) 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.(SQLiteParserListener); ok {
		listenerT.EnterColumn_def(s)
	}
}

func (s *Column_defContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitColumn_def(s)
	}
}

func (p *SQLiteParser) Column_def() (localctx IColumn_defContext) {
	this := p
	_ = this

	localctx = NewColumn_defContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, SQLiteParserRULE_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(455)
		p.Column_name()
	}
	p.SetState(457)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 40, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(456)
			p.Type_name()
		}

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

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(459)
				p.Column_constraint()
			}

		}
		p.SetState(464)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 41, 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 = SQLiteParserRULE_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 = SQLiteParserRULE_type_name

	return p
}

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

func (s *Type_nameContext) 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 *Type_nameContext) Name(i int) INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Type_nameContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_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(SQLiteParserCLOSE_PAR, 0)
}

func (s *Type_nameContext) COMMA() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMA, 0)
}

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

func (s *Type_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitType_name(s)
	}
}

func (p *SQLiteParser) Type_name() (localctx IType_nameContext) {
	this := p
	_ = this

	localctx = NewType_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, SQLiteParserRULE_type_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)
			}
		}
	}()

	var _alt int

	p.EnterOuterAlt(localctx, 1)
	p.SetState(466)
	p.GetErrorHandler().Sync(p)
	_alt = 1 + 1
	for ok := true; ok; ok = _alt != 1 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1 + 1:
			{
				p.SetState(465)
				p.Name()
			}

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

		p.SetState(468)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 42, p.GetParserRuleContext())
	}
	p.SetState(480)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 43, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(470)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(471)
			p.Signed_number()
		}
		{
			p.SetState(472)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 43, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(474)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(475)
			p.Signed_number()
		}
		{
			p.SetState(476)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(477)
			p.Signed_number()
		}
		{
			p.SetState(478)
			p.Match(SQLiteParserCLOSE_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 = SQLiteParserRULE_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 = SQLiteParserRULE_column_constraint

	return p
}

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

func (s *Column_constraintContext) CHECK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCHECK_, 0)
}

func (s *Column_constraintContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_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(SQLiteParserCLOSE_PAR, 0)
}

func (s *Column_constraintContext) DEFAULT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDEFAULT_, 0)
}

func (s *Column_constraintContext) COLLATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOLLATE_, 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) 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_constraintContext) AS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAS_, 0)
}

func (s *Column_constraintContext) CONSTRAINT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCONSTRAINT_, 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) PRIMARY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPRIMARY_, 0)
}

func (s *Column_constraintContext) KEY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserKEY_, 0)
}

func (s *Column_constraintContext) NOT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOT_, 0)
}

func (s *Column_constraintContext) NULL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNULL_, 0)
}

func (s *Column_constraintContext) UNIQUE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUNIQUE_, 0)
}

func (s *Column_constraintContext) 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_constraintContext) 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_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) GENERATED_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserGENERATED_, 0)
}

func (s *Column_constraintContext) ALWAYS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserALWAYS_, 0)
}

func (s *Column_constraintContext) STORED_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSTORED_, 0)
}

func (s *Column_constraintContext) VIRTUAL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserVIRTUAL_, 0)
}

func (s *Column_constraintContext) Asc_desc() IAsc_descContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAsc_descContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAsc_descContext)
}

func (s *Column_constraintContext) AUTOINCREMENT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAUTOINCREMENT_, 0)
}

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

func (s *Column_constraintContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitColumn_constraint(s)
	}
}

func (p *SQLiteParser) Column_constraint() (localctx IColumn_constraintContext) {
	this := p
	_ = this

	localctx = NewColumn_constraintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, SQLiteParserRULE_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(484)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserCONSTRAINT_ {
		{
			p.SetState(482)
			p.Match(SQLiteParserCONSTRAINT_)
		}
		{
			p.SetState(483)
			p.Name()
		}

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

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserPRIMARY_:
		{
			p.SetState(486)
			p.Match(SQLiteParserPRIMARY_)
		}
		{
			p.SetState(487)
			p.Match(SQLiteParserKEY_)
		}
		p.SetState(489)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserASC_ || _la == SQLiteParserDESC_ {
			{
				p.SetState(488)
				p.Asc_desc()
			}

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

		if _la == SQLiteParserON_ {
			{
				p.SetState(491)
				p.Conflict_clause()
			}

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

		if _la == SQLiteParserAUTOINCREMENT_ {
			{
				p.SetState(494)
				p.Match(SQLiteParserAUTOINCREMENT_)
			}

		}

	case SQLiteParserNOT_, SQLiteParserUNIQUE_:
		p.SetState(500)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SQLiteParserNOT_:
			{
				p.SetState(497)
				p.Match(SQLiteParserNOT_)
			}
			{
				p.SetState(498)
				p.Match(SQLiteParserNULL_)
			}

		case SQLiteParserUNIQUE_:
			{
				p.SetState(499)
				p.Match(SQLiteParserUNIQUE_)
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}
		p.SetState(503)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserON_ {
			{
				p.SetState(502)
				p.Conflict_clause()
			}

		}

	case SQLiteParserCHECK_:
		{
			p.SetState(505)
			p.Match(SQLiteParserCHECK_)
		}
		{
			p.SetState(506)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(507)
			p.expr(0)
		}
		{
			p.SetState(508)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case SQLiteParserDEFAULT_:
		{
			p.SetState(510)
			p.Match(SQLiteParserDEFAULT_)
		}
		p.SetState(517)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 50, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(511)
				p.Signed_number()
			}

		case 2:
			{
				p.SetState(512)
				p.Literal_value()
			}

		case 3:
			{
				p.SetState(513)
				p.Match(SQLiteParserOPEN_PAR)
			}
			{
				p.SetState(514)
				p.expr(0)
			}
			{
				p.SetState(515)
				p.Match(SQLiteParserCLOSE_PAR)
			}

		}

	case SQLiteParserCOLLATE_:
		{
			p.SetState(519)
			p.Match(SQLiteParserCOLLATE_)
		}
		{
			p.SetState(520)
			p.Collation_name()
		}

	case SQLiteParserREFERENCES_:
		{
			p.SetState(521)
			p.Foreign_key_clause()
		}

	case SQLiteParserAS_, SQLiteParserGENERATED_:
		p.SetState(524)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserGENERATED_ {
			{
				p.SetState(522)
				p.Match(SQLiteParserGENERATED_)
			}
			{
				p.SetState(523)
				p.Match(SQLiteParserALWAYS_)
			}

		}
		{
			p.SetState(526)
			p.Match(SQLiteParserAS_)
		}
		{
			p.SetState(527)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(528)
			p.expr(0)
		}
		{
			p.SetState(529)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		p.SetState(531)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserVIRTUAL_ || _la == SQLiteParserSTORED_ {
			{
				p.SetState(530)
				_la = p.GetTokenStream().LA(1)

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

		}

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

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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(SQLiteParserNUMERIC_LITERAL, 0)
}

func (s *Signed_numberContext) PLUS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPLUS, 0)
}

func (s *Signed_numberContext) MINUS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserMINUS, 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.(SQLiteParserListener); ok {
		listenerT.EnterSigned_number(s)
	}
}

func (s *Signed_numberContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitSigned_number(s)
	}
}

func (p *SQLiteParser) Signed_number() (localctx ISigned_numberContext) {
	this := p
	_ = this

	localctx = NewSigned_numberContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 34, SQLiteParserRULE_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(536)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserPLUS || _la == SQLiteParserMINUS {
		{
			p.SetState(535)
			_la = p.GetTokenStream().LA(1)

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

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

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_table_constraint

	return p
}

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

func (s *Table_constraintContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Table_constraintContext) 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_constraintContext) 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_constraintContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

func (s *Table_constraintContext) CHECK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCHECK_, 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) FOREIGN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFOREIGN_, 0)
}

func (s *Table_constraintContext) KEY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserKEY_, 0)
}

func (s *Table_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 *Table_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 *Table_constraintContext) 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_constraintContext) CONSTRAINT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCONSTRAINT_, 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) PRIMARY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPRIMARY_, 0)
}

func (s *Table_constraintContext) UNIQUE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUNIQUE_, 0)
}

func (s *Table_constraintContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

func (s *Table_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 *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.(SQLiteParserListener); ok {
		listenerT.EnterTable_constraint(s)
	}
}

func (s *Table_constraintContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitTable_constraint(s)
	}
}

func (p *SQLiteParser) Table_constraint() (localctx ITable_constraintContext) {
	this := p
	_ = this

	localctx = NewTable_constraintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, SQLiteParserRULE_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(542)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserCONSTRAINT_ {
		{
			p.SetState(540)
			p.Match(SQLiteParserCONSTRAINT_)
		}
		{
			p.SetState(541)
			p.Name()
		}

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

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserPRIMARY_, SQLiteParserUNIQUE_:
		p.SetState(547)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SQLiteParserPRIMARY_:
			{
				p.SetState(544)
				p.Match(SQLiteParserPRIMARY_)
			}
			{
				p.SetState(545)
				p.Match(SQLiteParserKEY_)
			}

		case SQLiteParserUNIQUE_:
			{
				p.SetState(546)
				p.Match(SQLiteParserUNIQUE_)
			}

		default:
			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
		}
		{
			p.SetState(549)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(550)
			p.Indexed_column()
		}
		p.SetState(555)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(551)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(552)
				p.Indexed_column()
			}

			p.SetState(557)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(558)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		p.SetState(560)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserON_ {
			{
				p.SetState(559)
				p.Conflict_clause()
			}

		}

	case SQLiteParserCHECK_:
		{
			p.SetState(562)
			p.Match(SQLiteParserCHECK_)
		}
		{
			p.SetState(563)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(564)
			p.expr(0)
		}
		{
			p.SetState(565)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case SQLiteParserFOREIGN_:
		{
			p.SetState(567)
			p.Match(SQLiteParserFOREIGN_)
		}
		{
			p.SetState(568)
			p.Match(SQLiteParserKEY_)
		}
		{
			p.SetState(569)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(570)
			p.Column_name()
		}
		p.SetState(575)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(571)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(572)
				p.Column_name()
			}

			p.SetState(577)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(578)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		{
			p.SetState(579)
			p.Foreign_key_clause()
		}

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

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_foreign_key_clause

	return p
}

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

func (s *Foreign_key_clauseContext) REFERENCES_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserREFERENCES_, 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) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Foreign_key_clauseContext) 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 *Foreign_key_clauseContext) 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 *Foreign_key_clauseContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

func (s *Foreign_key_clauseContext) AllON_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserON_)
}

func (s *Foreign_key_clauseContext) ON_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserON_, i)
}

func (s *Foreign_key_clauseContext) AllMATCH_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserMATCH_)
}

func (s *Foreign_key_clauseContext) MATCH_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserMATCH_, 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) DEFERRABLE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDEFERRABLE_, 0)
}

func (s *Foreign_key_clauseContext) AllDELETE_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserDELETE_)
}

func (s *Foreign_key_clauseContext) DELETE_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserDELETE_, i)
}

func (s *Foreign_key_clauseContext) AllUPDATE_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserUPDATE_)
}

func (s *Foreign_key_clauseContext) UPDATE_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserUPDATE_, i)
}

func (s *Foreign_key_clauseContext) AllSET_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserSET_)
}

func (s *Foreign_key_clauseContext) SET_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserSET_, i)
}

func (s *Foreign_key_clauseContext) AllCASCADE_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCASCADE_)
}

func (s *Foreign_key_clauseContext) CASCADE_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserCASCADE_, i)
}

func (s *Foreign_key_clauseContext) AllRESTRICT_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserRESTRICT_)
}

func (s *Foreign_key_clauseContext) RESTRICT_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserRESTRICT_, i)
}

func (s *Foreign_key_clauseContext) AllNO_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserNO_)
}

func (s *Foreign_key_clauseContext) NO_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserNO_, i)
}

func (s *Foreign_key_clauseContext) AllACTION_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserACTION_)
}

func (s *Foreign_key_clauseContext) ACTION_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserACTION_, i)
}

func (s *Foreign_key_clauseContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

func (s *Foreign_key_clauseContext) AllNULL_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserNULL_)
}

func (s *Foreign_key_clauseContext) NULL_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserNULL_, i)
}

func (s *Foreign_key_clauseContext) AllDEFAULT_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserDEFAULT_)
}

func (s *Foreign_key_clauseContext) DEFAULT_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserDEFAULT_, i)
}

func (s *Foreign_key_clauseContext) NOT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOT_, 0)
}

func (s *Foreign_key_clauseContext) INITIALLY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINITIALLY_, 0)
}

func (s *Foreign_key_clauseContext) DEFERRED_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDEFERRED_, 0)
}

func (s *Foreign_key_clauseContext) IMMEDIATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIMMEDIATE_, 0)
}

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

func (s *Foreign_key_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitForeign_key_clause(s)
	}
}

func (p *SQLiteParser) Foreign_key_clause() (localctx IForeign_key_clauseContext) {
	this := p
	_ = this

	localctx = NewForeign_key_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, SQLiteParserRULE_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)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(583)
		p.Match(SQLiteParserREFERENCES_)
	}
	{
		p.SetState(584)
		p.Foreign_table()
	}
	p.SetState(596)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserOPEN_PAR {
		{
			p.SetState(585)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(586)
			p.Column_name()
		}
		p.SetState(591)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(587)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(588)
				p.Column_name()
			}

			p.SetState(593)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(594)
			p.Match(SQLiteParserCLOSE_PAR)
		}

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

	for _la == SQLiteParserMATCH_ || _la == SQLiteParserON_ {
		p.SetState(610)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SQLiteParserON_:
			{
				p.SetState(598)
				p.Match(SQLiteParserON_)
			}
			{
				p.SetState(599)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SQLiteParserDELETE_ || _la == SQLiteParserUPDATE_) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			p.SetState(606)
			p.GetErrorHandler().Sync(p)

			switch p.GetTokenStream().LA(1) {
			case SQLiteParserSET_:
				{
					p.SetState(600)
					p.Match(SQLiteParserSET_)
				}
				{
					p.SetState(601)
					_la = p.GetTokenStream().LA(1)

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

			case SQLiteParserCASCADE_:
				{
					p.SetState(602)
					p.Match(SQLiteParserCASCADE_)
				}

			case SQLiteParserRESTRICT_:
				{
					p.SetState(603)
					p.Match(SQLiteParserRESTRICT_)
				}

			case SQLiteParserNO_:
				{
					p.SetState(604)
					p.Match(SQLiteParserNO_)
				}
				{
					p.SetState(605)
					p.Match(SQLiteParserACTION_)
				}

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

		case SQLiteParserMATCH_:
			{
				p.SetState(608)
				p.Match(SQLiteParserMATCH_)
			}
			{
				p.SetState(609)
				p.Name()
			}

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

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

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

		if _la == SQLiteParserNOT_ {
			{
				p.SetState(615)
				p.Match(SQLiteParserNOT_)
			}

		}
		{
			p.SetState(618)
			p.Match(SQLiteParserDEFERRABLE_)
		}
		p.SetState(621)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserINITIALLY_ {
			{
				p.SetState(619)
				p.Match(SQLiteParserINITIALLY_)
			}
			{
				p.SetState(620)
				_la = p.GetTokenStream().LA(1)

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

		}

	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_conflict_clause

	return p
}

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

func (s *Conflict_clauseContext) ON_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserON_, 0)
}

func (s *Conflict_clauseContext) CONFLICT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCONFLICT_, 0)
}

func (s *Conflict_clauseContext) ROLLBACK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROLLBACK_, 0)
}

func (s *Conflict_clauseContext) ABORT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserABORT_, 0)
}

func (s *Conflict_clauseContext) FAIL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFAIL_, 0)
}

func (s *Conflict_clauseContext) IGNORE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIGNORE_, 0)
}

func (s *Conflict_clauseContext) REPLACE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserREPLACE_, 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.(SQLiteParserListener); ok {
		listenerT.EnterConflict_clause(s)
	}
}

func (s *Conflict_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitConflict_clause(s)
	}
}

func (p *SQLiteParser) Conflict_clause() (localctx IConflict_clauseContext) {
	this := p
	_ = this

	localctx = NewConflict_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, SQLiteParserRULE_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(625)
		p.Match(SQLiteParserON_)
	}
	{
		p.SetState(626)
		p.Match(SQLiteParserCONFLICT_)
	}
	{
		p.SetState(627)
		_la = p.GetTokenStream().LA(1)

		if !(_la == SQLiteParserABORT_ || _la == SQLiteParserFAIL_ || _la == SQLiteParserIGNORE_ || _la == SQLiteParserREPLACE_ || _la == SQLiteParserROLLBACK_) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_create_trigger_stmt

	return p
}

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

func (s *Create_trigger_stmtContext) CREATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCREATE_, 0)
}

func (s *Create_trigger_stmtContext) TRIGGER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTRIGGER_, 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) ON_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserON_, 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) BEGIN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBEGIN_, 0)
}

func (s *Create_trigger_stmtContext) END_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEND_, 0)
}

func (s *Create_trigger_stmtContext) DELETE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDELETE_, 0)
}

func (s *Create_trigger_stmtContext) INSERT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINSERT_, 0)
}

func (s *Create_trigger_stmtContext) UPDATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUPDATE_, 0)
}

func (s *Create_trigger_stmtContext) IF_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIF_, 0)
}

func (s *Create_trigger_stmtContext) NOT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOT_, 0)
}

func (s *Create_trigger_stmtContext) EXISTS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXISTS_, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

func (s *Create_trigger_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDOT, 0)
}

func (s *Create_trigger_stmtContext) BEFORE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBEFORE_, 0)
}

func (s *Create_trigger_stmtContext) AFTER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAFTER_, 0)
}

func (s *Create_trigger_stmtContext) INSTEAD_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINSTEAD_, 0)
}

func (s *Create_trigger_stmtContext) AllOF_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserOF_)
}

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

func (s *Create_trigger_stmtContext) FOR_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFOR_, 0)
}

func (s *Create_trigger_stmtContext) EACH_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEACH_, 0)
}

func (s *Create_trigger_stmtContext) ROW_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROW_, 0)
}

func (s *Create_trigger_stmtContext) WHEN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWHEN_, 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(SQLiteParserSCOL)
}

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

func (s *Create_trigger_stmtContext) TEMP_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTEMP_, 0)
}

func (s *Create_trigger_stmtContext) TEMPORARY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTEMPORARY_, 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(SQLiteParserCOMMA)
}

func (s *Create_trigger_stmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMA, 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.(SQLiteParserListener); ok {
		listenerT.EnterCreate_trigger_stmt(s)
	}
}

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

func (p *SQLiteParser) Create_trigger_stmt() (localctx ICreate_trigger_stmtContext) {
	this := p
	_ = this

	localctx = NewCreate_trigger_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, SQLiteParserRULE_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(629)
		p.Match(SQLiteParserCREATE_)
	}
	p.SetState(631)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserTEMP_ || _la == SQLiteParserTEMPORARY_ {
		{
			p.SetState(630)
			_la = p.GetTokenStream().LA(1)

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

	}
	{
		p.SetState(633)
		p.Match(SQLiteParserTRIGGER_)
	}
	p.SetState(637)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 70, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(634)
			p.Match(SQLiteParserIF_)
		}
		{
			p.SetState(635)
			p.Match(SQLiteParserNOT_)
		}
		{
			p.SetState(636)
			p.Match(SQLiteParserEXISTS_)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 71, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(639)
			p.Schema_name()
		}
		{
			p.SetState(640)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(644)
		p.Trigger_name()
	}
	p.SetState(649)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserBEFORE_:
		{
			p.SetState(645)
			p.Match(SQLiteParserBEFORE_)
		}

	case SQLiteParserAFTER_:
		{
			p.SetState(646)
			p.Match(SQLiteParserAFTER_)
		}

	case SQLiteParserINSTEAD_:
		{
			p.SetState(647)
			p.Match(SQLiteParserINSTEAD_)
		}
		{
			p.SetState(648)
			p.Match(SQLiteParserOF_)
		}

	case SQLiteParserDELETE_, SQLiteParserINSERT_, SQLiteParserUPDATE_:

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

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserDELETE_:
		{
			p.SetState(651)
			p.Match(SQLiteParserDELETE_)
		}

	case SQLiteParserINSERT_:
		{
			p.SetState(652)
			p.Match(SQLiteParserINSERT_)
		}

	case SQLiteParserUPDATE_:
		{
			p.SetState(653)
			p.Match(SQLiteParserUPDATE_)
		}
		p.SetState(663)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserOF_ {
			{
				p.SetState(654)
				p.Match(SQLiteParserOF_)
			}
			{
				p.SetState(655)
				p.Column_name()
			}
			p.SetState(660)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(656)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(657)
					p.Column_name()
				}

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

		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(667)
		p.Match(SQLiteParserON_)
	}
	{
		p.SetState(668)
		p.Table_name()
	}
	p.SetState(672)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserFOR_ {
		{
			p.SetState(669)
			p.Match(SQLiteParserFOR_)
		}
		{
			p.SetState(670)
			p.Match(SQLiteParserEACH_)
		}
		{
			p.SetState(671)
			p.Match(SQLiteParserROW_)
		}

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

	if _la == SQLiteParserWHEN_ {
		{
			p.SetState(674)
			p.Match(SQLiteParserWHEN_)
		}
		{
			p.SetState(675)
			p.expr(0)
		}

	}
	{
		p.SetState(678)
		p.Match(SQLiteParserBEGIN_)
	}
	p.SetState(687)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == SQLiteParserDEFAULT_ || _la == SQLiteParserDELETE_ || _la == SQLiteParserINSERT_ || (((_la-122)&-(0x1f+1)) == 0 && ((1<<uint((_la-122)))&((1<<(SQLiteParserREPLACE_-122))|(1<<(SQLiteParserSELECT_-122))|(1<<(SQLiteParserUPDATE_-122))|(1<<(SQLiteParserVALUES_-122))|(1<<(SQLiteParserWITH_-122)))) != 0) {
		p.SetState(683)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 78, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(679)
				p.Update_stmt()
			}

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

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

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

		}
		{
			p.SetState(685)
			p.Match(SQLiteParserSCOL)
		}

		p.SetState(689)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(691)
		p.Match(SQLiteParserEND_)
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_create_view_stmt

	return p
}

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

func (s *Create_view_stmtContext) CREATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCREATE_, 0)
}

func (s *Create_view_stmtContext) VIEW_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserVIEW_, 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) AS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAS_, 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) IF_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIF_, 0)
}

func (s *Create_view_stmtContext) NOT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOT_, 0)
}

func (s *Create_view_stmtContext) EXISTS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXISTS_, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

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

func (s *Create_view_stmtContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Create_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_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_view_stmtContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

func (s *Create_view_stmtContext) TEMP_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTEMP_, 0)
}

func (s *Create_view_stmtContext) TEMPORARY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTEMPORARY_, 0)
}

func (s *Create_view_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

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

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

func (p *SQLiteParser) Create_view_stmt() (localctx ICreate_view_stmtContext) {
	this := p
	_ = this

	localctx = NewCreate_view_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, SQLiteParserRULE_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(693)
		p.Match(SQLiteParserCREATE_)
	}
	p.SetState(695)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserTEMP_ || _la == SQLiteParserTEMPORARY_ {
		{
			p.SetState(694)
			_la = p.GetTokenStream().LA(1)

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

	}
	{
		p.SetState(697)
		p.Match(SQLiteParserVIEW_)
	}
	p.SetState(701)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 81, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(698)
			p.Match(SQLiteParserIF_)
		}
		{
			p.SetState(699)
			p.Match(SQLiteParserNOT_)
		}
		{
			p.SetState(700)
			p.Match(SQLiteParserEXISTS_)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 82, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(703)
			p.Schema_name()
		}
		{
			p.SetState(704)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(708)
		p.View_name()
	}
	p.SetState(720)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserOPEN_PAR {
		{
			p.SetState(709)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(710)
			p.Column_name()
		}
		p.SetState(715)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(711)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(712)
				p.Column_name()
			}

			p.SetState(717)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(718)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	}
	{
		p.SetState(722)
		p.Match(SQLiteParserAS_)
	}
	{
		p.SetState(723)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_create_virtual_table_stmt

	return p
}

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

func (s *Create_virtual_table_stmtContext) CREATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCREATE_, 0)
}

func (s *Create_virtual_table_stmtContext) VIRTUAL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserVIRTUAL_, 0)
}

func (s *Create_virtual_table_stmtContext) TABLE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTABLE_, 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) USING_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUSING_, 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) IF_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIF_, 0)
}

func (s *Create_virtual_table_stmtContext) NOT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOT_, 0)
}

func (s *Create_virtual_table_stmtContext) EXISTS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXISTS_, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

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

func (s *Create_virtual_table_stmtContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_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(SQLiteParserCLOSE_PAR, 0)
}

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

func (s *Create_virtual_table_stmtContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMA, 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.(SQLiteParserListener); ok {
		listenerT.EnterCreate_virtual_table_stmt(s)
	}
}

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

func (p *SQLiteParser) Create_virtual_table_stmt() (localctx ICreate_virtual_table_stmtContext) {
	this := p
	_ = this

	localctx = NewCreate_virtual_table_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, SQLiteParserRULE_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(725)
		p.Match(SQLiteParserCREATE_)
	}
	{
		p.SetState(726)
		p.Match(SQLiteParserVIRTUAL_)
	}
	{
		p.SetState(727)
		p.Match(SQLiteParserTABLE_)
	}
	p.SetState(731)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 85, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(728)
			p.Match(SQLiteParserIF_)
		}
		{
			p.SetState(729)
			p.Match(SQLiteParserNOT_)
		}
		{
			p.SetState(730)
			p.Match(SQLiteParserEXISTS_)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 86, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(733)
			p.Schema_name()
		}
		{
			p.SetState(734)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(738)
		p.Table_name()
	}
	{
		p.SetState(739)
		p.Match(SQLiteParserUSING_)
	}
	{
		p.SetState(740)
		p.Module_name()
	}
	p.SetState(752)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserOPEN_PAR {
		{
			p.SetState(741)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(742)
			p.Module_argument()
		}
		p.SetState(747)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(743)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(744)
				p.Module_argument()
			}

			p.SetState(749)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(750)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_with_clause

	return p
}

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

func (s *With_clauseContext) WITH_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWITH_, 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) AllAS_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserAS_)
}

func (s *With_clauseContext) AS_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserAS_, i)
}

func (s *With_clauseContext) AllOPEN_PAR() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserOPEN_PAR)
}

func (s *With_clauseContext) OPEN_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_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(SQLiteParserCLOSE_PAR)
}

func (s *With_clauseContext) CLOSE_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, i)
}

func (s *With_clauseContext) RECURSIVE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRECURSIVE_, 0)
}

func (s *With_clauseContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

func (s *With_clauseContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMA, 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.(SQLiteParserListener); ok {
		listenerT.EnterWith_clause(s)
	}
}

func (s *With_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitWith_clause(s)
	}
}

func (p *SQLiteParser) With_clause() (localctx IWith_clauseContext) {
	this := p
	_ = this

	localctx = NewWith_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, SQLiteParserRULE_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(754)
		p.Match(SQLiteParserWITH_)
	}
	p.SetState(756)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 89, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(755)
			p.Match(SQLiteParserRECURSIVE_)
		}

	}
	{
		p.SetState(758)
		p.Cte_table_name()
	}
	{
		p.SetState(759)
		p.Match(SQLiteParserAS_)
	}
	{
		p.SetState(760)
		p.Match(SQLiteParserOPEN_PAR)
	}
	{
		p.SetState(761)
		p.Select_stmt()
	}
	{
		p.SetState(762)
		p.Match(SQLiteParserCLOSE_PAR)
	}
	p.SetState(772)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserCOMMA {
		{
			p.SetState(763)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(764)
			p.Cte_table_name()
		}
		{
			p.SetState(765)
			p.Match(SQLiteParserAS_)
		}
		{
			p.SetState(766)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(767)
			p.Select_stmt()
		}
		{
			p.SetState(768)
			p.Match(SQLiteParserCLOSE_PAR)
		}

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

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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(SQLiteParserOPEN_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(SQLiteParserCLOSE_PAR, 0)
}

func (s *Cte_table_nameContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

func (s *Cte_table_nameContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMA, 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.(SQLiteParserListener); ok {
		listenerT.EnterCte_table_name(s)
	}
}

func (s *Cte_table_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitCte_table_name(s)
	}
}

func (p *SQLiteParser) Cte_table_name() (localctx ICte_table_nameContext) {
	this := p
	_ = this

	localctx = NewCte_table_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 50, SQLiteParserRULE_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(775)
		p.Table_name()
	}
	p.SetState(787)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserOPEN_PAR {
		{
			p.SetState(776)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(777)
			p.Column_name()
		}
		p.SetState(782)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(778)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(779)
				p.Column_name()
			}

			p.SetState(784)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(785)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyRecursive_cteContext() *Recursive_cteContext {
	var p = new(Recursive_cteContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_recursive_cte
	return p
}

func (*Recursive_cteContext) IsRecursive_cteContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_recursive_cte

	return p
}

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

func (s *Recursive_cteContext) Cte_table_name() ICte_table_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICte_table_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICte_table_nameContext)
}

func (s *Recursive_cteContext) AS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAS_, 0)
}

func (s *Recursive_cteContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Recursive_cteContext) Initial_select() IInitial_selectContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInitial_selectContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IInitial_selectContext)
}

func (s *Recursive_cteContext) UNION_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUNION_, 0)
}

func (s *Recursive_cteContext) Recursive__select() IRecursive__selectContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRecursive__selectContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IRecursive__selectContext)
}

func (s *Recursive_cteContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

func (s *Recursive_cteContext) ALL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserALL_, 0)
}

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

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

func (s *Recursive_cteContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterRecursive_cte(s)
	}
}

func (s *Recursive_cteContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitRecursive_cte(s)
	}
}

func (p *SQLiteParser) Recursive_cte() (localctx IRecursive_cteContext) {
	this := p
	_ = this

	localctx = NewRecursive_cteContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, SQLiteParserRULE_recursive_cte)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(789)
		p.Cte_table_name()
	}
	{
		p.SetState(790)
		p.Match(SQLiteParserAS_)
	}
	{
		p.SetState(791)
		p.Match(SQLiteParserOPEN_PAR)
	}
	{
		p.SetState(792)
		p.Initial_select()
	}
	{
		p.SetState(793)
		p.Match(SQLiteParserUNION_)
	}
	p.SetState(795)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserALL_ {
		{
			p.SetState(794)
			p.Match(SQLiteParserALL_)
		}

	}
	{
		p.SetState(797)
		p.Recursive__select()
	}
	{
		p.SetState(798)
		p.Match(SQLiteParserCLOSE_PAR)
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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) AS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAS_, 0)
}

func (s *Common_table_expressionContext) AllOPEN_PAR() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserOPEN_PAR)
}

func (s *Common_table_expressionContext) OPEN_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_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(SQLiteParserCLOSE_PAR)
}

func (s *Common_table_expressionContext) CLOSE_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_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(SQLiteParserCOMMA)
}

func (s *Common_table_expressionContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMA, 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.(SQLiteParserListener); ok {
		listenerT.EnterCommon_table_expression(s)
	}
}

func (s *Common_table_expressionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitCommon_table_expression(s)
	}
}

func (p *SQLiteParser) Common_table_expression() (localctx ICommon_table_expressionContext) {
	this := p
	_ = this

	localctx = NewCommon_table_expressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 54, SQLiteParserRULE_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(800)
		p.Table_name()
	}
	p.SetState(812)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserOPEN_PAR {
		{
			p.SetState(801)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(802)
			p.Column_name()
		}
		p.SetState(807)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(803)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(804)
				p.Column_name()
			}

			p.SetState(809)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(810)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	}
	{
		p.SetState(814)
		p.Match(SQLiteParserAS_)
	}
	{
		p.SetState(815)
		p.Match(SQLiteParserOPEN_PAR)
	}
	{
		p.SetState(816)
		p.Select_stmt()
	}
	{
		p.SetState(817)
		p.Match(SQLiteParserCLOSE_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 = SQLiteParserRULE_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 = SQLiteParserRULE_delete_stmt

	return p
}

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

func (s *Delete_stmtContext) DELETE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDELETE_, 0)
}

func (s *Delete_stmtContext) FROM_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFROM_, 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) WHERE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWHERE_, 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.(SQLiteParserListener); ok {
		listenerT.EnterDelete_stmt(s)
	}
}

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

func (p *SQLiteParser) Delete_stmt() (localctx IDelete_stmtContext) {
	this := p
	_ = this

	localctx = NewDelete_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, SQLiteParserRULE_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(820)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserWITH_ {
		{
			p.SetState(819)
			p.With_clause()
		}

	}
	{
		p.SetState(822)
		p.Match(SQLiteParserDELETE_)
	}
	{
		p.SetState(823)
		p.Match(SQLiteParserFROM_)
	}
	{
		p.SetState(824)
		p.Qualified_table_name()
	}
	p.SetState(827)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserWHERE_ {
		{
			p.SetState(825)
			p.Match(SQLiteParserWHERE_)
		}
		{
			p.SetState(826)
			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 = SQLiteParserRULE_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 = SQLiteParserRULE_delete_stmt_limited

	return p
}

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

func (s *Delete_stmt_limitedContext) DELETE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDELETE_, 0)
}

func (s *Delete_stmt_limitedContext) FROM_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFROM_, 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) WHERE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWHERE_, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ILimit_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IOrder_by_stmtContext)
}

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

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

func (p *SQLiteParser) Delete_stmt_limited() (localctx IDelete_stmt_limitedContext) {
	this := p
	_ = this

	localctx = NewDelete_stmt_limitedContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, SQLiteParserRULE_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(830)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserWITH_ {
		{
			p.SetState(829)
			p.With_clause()
		}

	}
	{
		p.SetState(832)
		p.Match(SQLiteParserDELETE_)
	}
	{
		p.SetState(833)
		p.Match(SQLiteParserFROM_)
	}
	{
		p.SetState(834)
		p.Qualified_table_name()
	}
	p.SetState(837)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserWHERE_ {
		{
			p.SetState(835)
			p.Match(SQLiteParserWHERE_)
		}
		{
			p.SetState(836)
			p.expr(0)
		}

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

	if _la == SQLiteParserLIMIT_ || _la == SQLiteParserORDER_ {
		p.SetState(840)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserORDER_ {
			{
				p.SetState(839)
				p.Order_by_stmt()
			}

		}
		{
			p.SetState(842)
			p.Limit_stmt()
		}

	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_detach_stmt

	return p
}

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

func (s *Detach_stmtContext) DETACH_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDETACH_, 0)
}

func (s *Detach_stmtContext) Schema_name() ISchema_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISchema_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

func (s *Detach_stmtContext) DATABASE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDATABASE_, 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.(SQLiteParserListener); ok {
		listenerT.EnterDetach_stmt(s)
	}
}

func (s *Detach_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitDetach_stmt(s)
	}
}

func (p *SQLiteParser) Detach_stmt() (localctx IDetach_stmtContext) {
	this := p
	_ = this

	localctx = NewDetach_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 60, SQLiteParserRULE_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(845)
		p.Match(SQLiteParserDETACH_)
	}
	p.SetState(847)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 102, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(846)
			p.Match(SQLiteParserDATABASE_)
		}

	}
	{
		p.SetState(849)
		p.Schema_name()
	}

	return localctx
}

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

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

	// GetObject returns the object token.
	GetObject() antlr.Token

	// SetObject sets the object token.
	SetObject(antlr.Token)

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

type Drop_stmtContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
	object antlr.Token
}

func NewEmptyDrop_stmtContext() *Drop_stmtContext {
	var p = new(Drop_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_drop_stmt
	return p
}

func (*Drop_stmtContext) IsDrop_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_drop_stmt

	return p
}

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

func (s *Drop_stmtContext) GetObject() antlr.Token { return s.object }

func (s *Drop_stmtContext) SetObject(v antlr.Token) { s.object = v }

func (s *Drop_stmtContext) DROP_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDROP_, 0)
}

func (s *Drop_stmtContext) 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 *Drop_stmtContext) INDEX_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINDEX_, 0)
}

func (s *Drop_stmtContext) TABLE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTABLE_, 0)
}

func (s *Drop_stmtContext) TRIGGER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTRIGGER_, 0)
}

func (s *Drop_stmtContext) VIEW_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserVIEW_, 0)
}

func (s *Drop_stmtContext) IF_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIF_, 0)
}

func (s *Drop_stmtContext) EXISTS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXISTS_, 0)
}

func (s *Drop_stmtContext) Schema_name() ISchema_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISchema_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

func (s *Drop_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDOT, 0)
}

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

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

func (s *Drop_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterDrop_stmt(s)
	}
}

func (s *Drop_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitDrop_stmt(s)
	}
}

func (p *SQLiteParser) Drop_stmt() (localctx IDrop_stmtContext) {
	this := p
	_ = this

	localctx = NewDrop_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 62, SQLiteParserRULE_drop_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(851)
		p.Match(SQLiteParserDROP_)
	}
	{
		p.SetState(852)

		var _lt = p.GetTokenStream().LT(1)

		localctx.(*Drop_stmtContext).object = _lt

		_la = p.GetTokenStream().LA(1)

		if !(_la == SQLiteParserINDEX_ || (((_la-131)&-(0x1f+1)) == 0 && ((1<<uint((_la-131)))&((1<<(SQLiteParserTABLE_-131))|(1<<(SQLiteParserTRIGGER_-131))|(1<<(SQLiteParserVIEW_-131)))) != 0)) {
			var _ri = p.GetErrorHandler().RecoverInline(p)

			localctx.(*Drop_stmtContext).object = _ri
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(855)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 103, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(853)
			p.Match(SQLiteParserIF_)
		}
		{
			p.SetState(854)
			p.Match(SQLiteParserEXISTS_)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 104, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(857)
			p.Schema_name()
		}
		{
			p.SetState(858)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(862)
		p.Any_name()
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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(SQLiteParserBIND_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(SQLiteParserDOT)
}

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

func (s *ExprContext) Schema_name() ISchema_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISchema_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISchema_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(SQLiteParserOPEN_PAR, 0)
}

func (s *ExprContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

func (s *ExprContext) STAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSTAR, 0)
}

func (s *ExprContext) Filter_clause() IFilter_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFilter_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFilter_clauseContext)
}

func (s *ExprContext) Over_clause() IOver_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOver_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOver_clauseContext)
}

func (s *ExprContext) DISTINCT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDISTINCT_, 0)
}

func (s *ExprContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

func (s *ExprContext) CAST_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCAST_, 0)
}

func (s *ExprContext) AS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAS_, 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) EXISTS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXISTS_, 0)
}

func (s *ExprContext) NOT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOT_, 0)
}

func (s *ExprContext) CASE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCASE_, 0)
}

func (s *ExprContext) END_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEND_, 0)
}

func (s *ExprContext) AllWHEN_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserWHEN_)
}

func (s *ExprContext) WHEN_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserWHEN_, i)
}

func (s *ExprContext) AllTHEN_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserTHEN_)
}

func (s *ExprContext) THEN_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserTHEN_, i)
}

func (s *ExprContext) ELSE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserELSE_, 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(SQLiteParserPIPE2, 0)
}

func (s *ExprContext) DIV() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDIV, 0)
}

func (s *ExprContext) MOD() antlr.TerminalNode {
	return s.GetToken(SQLiteParserMOD, 0)
}

func (s *ExprContext) PLUS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPLUS, 0)
}

func (s *ExprContext) MINUS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserMINUS, 0)
}

func (s *ExprContext) LT2() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLT2, 0)
}

func (s *ExprContext) GT2() antlr.TerminalNode {
	return s.GetToken(SQLiteParserGT2, 0)
}

func (s *ExprContext) AMP() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAMP, 0)
}

func (s *ExprContext) PIPE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPIPE, 0)
}

func (s *ExprContext) LT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLT, 0)
}

func (s *ExprContext) LT_EQ() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLT_EQ, 0)
}

func (s *ExprContext) GT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserGT, 0)
}

func (s *ExprContext) GT_EQ() antlr.TerminalNode {
	return s.GetToken(SQLiteParserGT_EQ, 0)
}

func (s *ExprContext) ASSIGN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserASSIGN, 0)
}

func (s *ExprContext) EQ() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEQ, 0)
}

func (s *ExprContext) NOT_EQ1() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOT_EQ1, 0)
}

func (s *ExprContext) NOT_EQ2() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOT_EQ2, 0)
}

func (s *ExprContext) IS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIS_, 0)
}

func (s *ExprContext) IN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIN_, 0)
}

func (s *ExprContext) LIKE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLIKE_, 0)
}

func (s *ExprContext) GLOB_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserGLOB_, 0)
}

func (s *ExprContext) MATCH_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserMATCH_, 0)
}

func (s *ExprContext) REGEXP_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserREGEXP_, 0)
}

func (s *ExprContext) AND_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAND_, 0)
}

func (s *ExprContext) OR_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOR_, 0)
}

func (s *ExprContext) BETWEEN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBETWEEN_, 0)
}

func (s *ExprContext) COLLATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOLLATE_, 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) ESCAPE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserESCAPE_, 0)
}

func (s *ExprContext) ISNULL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserISNULL_, 0)
}

func (s *ExprContext) NOTNULL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOTNULL_, 0)
}

func (s *ExprContext) NULL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNULL_, 0)
}

func (s *ExprContext) Table_function_name() ITable_function_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_function_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_function_nameContext)
}

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

func (s *ExprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitExpr(s)
	}
}

func (p *SQLiteParser) Expr() (localctx IExprContext) {
	return p.expr(0)
}

func (p *SQLiteParser) expr(_p int) (localctx IExprContext) {
	this := p
	_ = this

	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 := 64
	p.EnterRecursionRule(localctx, 64, SQLiteParserRULE_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(952)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 118, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(865)
			p.Literal_value()
		}

	case 2:
		{
			p.SetState(866)
			p.Match(SQLiteParserBIND_PARAMETER)
		}

	case 3:
		p.SetState(875)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 106, p.GetParserRuleContext()) == 1 {
			p.SetState(870)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 105, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(867)
					p.Schema_name()
				}
				{
					p.SetState(868)
					p.Match(SQLiteParserDOT)
				}

			}
			{
				p.SetState(872)
				p.Table_name()
			}
			{
				p.SetState(873)
				p.Match(SQLiteParserDOT)
			}

		}
		{
			p.SetState(877)
			p.Column_name()
		}

	case 4:
		{
			p.SetState(878)
			p.Unary_operator()
		}
		{
			p.SetState(879)
			p.expr(21)
		}

	case 5:
		{
			p.SetState(881)
			p.Function_name()
		}
		{
			p.SetState(882)
			p.Match(SQLiteParserOPEN_PAR)
		}
		p.SetState(895)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SQLiteParserOPEN_PAR, SQLiteParserPLUS, SQLiteParserMINUS, SQLiteParserTILDE, SQLiteParserABORT_, SQLiteParserACTION_, SQLiteParserADD_, SQLiteParserAFTER_, SQLiteParserALL_, SQLiteParserALTER_, SQLiteParserANALYZE_, SQLiteParserAND_, SQLiteParserAS_, SQLiteParserASC_, SQLiteParserATTACH_, SQLiteParserAUTOINCREMENT_, SQLiteParserBEFORE_, SQLiteParserBEGIN_, SQLiteParserBETWEEN_, SQLiteParserBY_, SQLiteParserCASCADE_, SQLiteParserCASE_, SQLiteParserCAST_, SQLiteParserCHECK_, SQLiteParserCOLLATE_, SQLiteParserCOLUMN_, SQLiteParserCOMMIT_, SQLiteParserCONFLICT_, SQLiteParserCONSTRAINT_, SQLiteParserCREATE_, SQLiteParserCROSS_, SQLiteParserCURRENT_DATE_, SQLiteParserCURRENT_TIME_, SQLiteParserCURRENT_TIMESTAMP_, SQLiteParserDATABASE_, SQLiteParserDEFAULT_, SQLiteParserDEFERRABLE_, SQLiteParserDEFERRED_, SQLiteParserDELETE_, SQLiteParserDESC_, SQLiteParserDETACH_, SQLiteParserDISTINCT_, SQLiteParserDROP_, SQLiteParserEACH_, SQLiteParserELSE_, SQLiteParserEND_, SQLiteParserESCAPE_, SQLiteParserEXCEPT_, SQLiteParserEXCLUSIVE_, SQLiteParserEXISTS_, SQLiteParserEXPLAIN_, SQLiteParserFAIL_, SQLiteParserFOR_, SQLiteParserFOREIGN_, SQLiteParserFROM_, SQLiteParserFULL_, SQLiteParserGLOB_, SQLiteParserGROUP_, SQLiteParserHAVING_, SQLiteParserIF_, SQLiteParserIGNORE_, SQLiteParserIMMEDIATE_, SQLiteParserIN_, SQLiteParserINDEX_, SQLiteParserINDEXED_, SQLiteParserINITIALLY_, SQLiteParserINNER_, SQLiteParserINSERT_, SQLiteParserINSTEAD_, SQLiteParserINTERSECT_, SQLiteParserINTO_, SQLiteParserIS_, SQLiteParserISNULL_, SQLiteParserJOIN_, SQLiteParserKEY_, SQLiteParserLEFT_, SQLiteParserLIKE_, SQLiteParserLIMIT_, SQLiteParserMATCH_, SQLiteParserNATURAL_, SQLiteParserNO_, SQLiteParserNOT_, SQLiteParserNOTNULL_, SQLiteParserNULL_, SQLiteParserOF_, SQLiteParserOFFSET_, SQLiteParserON_, SQLiteParserOR_, SQLiteParserORDER_, SQLiteParserOUTER_, SQLiteParserPLAN_, SQLiteParserPRAGMA_, SQLiteParserPRIMARY_, SQLiteParserQUERY_, SQLiteParserRAISE_, SQLiteParserRECURSIVE_, SQLiteParserREFERENCES_, SQLiteParserREGEXP_, SQLiteParserREINDEX_, SQLiteParserRELEASE_, SQLiteParserRENAME_, SQLiteParserREPLACE_, SQLiteParserRESTRICT_, SQLiteParserRIGHT_, SQLiteParserROLLBACK_, SQLiteParserROW_, SQLiteParserROWS_, SQLiteParserSAVEPOINT_, SQLiteParserSELECT_, SQLiteParserSET_, SQLiteParserTABLE_, SQLiteParserTEMP_, SQLiteParserTEMPORARY_, SQLiteParserTHEN_, SQLiteParserTO_, SQLiteParserTRANSACTION_, SQLiteParserTRIGGER_, SQLiteParserUNION_, SQLiteParserUNIQUE_, SQLiteParserUPDATE_, SQLiteParserUSING_, SQLiteParserVACUUM_, SQLiteParserVALUES_, SQLiteParserVIEW_, SQLiteParserVIRTUAL_, SQLiteParserWHEN_, SQLiteParserWHERE_, SQLiteParserWITH_, SQLiteParserWITHOUT_, SQLiteParserFIRST_VALUE_, SQLiteParserOVER_, SQLiteParserPARTITION_, SQLiteParserRANGE_, SQLiteParserPRECEDING_, SQLiteParserUNBOUNDED_, SQLiteParserCURRENT_, SQLiteParserFOLLOWING_, SQLiteParserCUME_DIST_, SQLiteParserDENSE_RANK_, SQLiteParserLAG_, SQLiteParserLAST_VALUE_, SQLiteParserLEAD_, SQLiteParserNTH_VALUE_, SQLiteParserNTILE_, SQLiteParserPERCENT_RANK_, SQLiteParserRANK_, SQLiteParserROW_NUMBER_, SQLiteParserGENERATED_, SQLiteParserALWAYS_, SQLiteParserSTORED_, SQLiteParserTRUE_, SQLiteParserFALSE_, SQLiteParserWINDOW_, SQLiteParserNULLS_, SQLiteParserFIRST_, SQLiteParserLAST_, SQLiteParserFILTER_, SQLiteParserGROUPS_, SQLiteParserEXCLUDE_, SQLiteParserIDENTIFIER, SQLiteParserNUMERIC_LITERAL, SQLiteParserBIND_PARAMETER, SQLiteParserSTRING_LITERAL, SQLiteParserBLOB_LITERAL:
			p.SetState(884)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 107, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(883)
					p.Match(SQLiteParserDISTINCT_)
				}

			}
			{
				p.SetState(886)
				p.expr(0)
			}
			p.SetState(891)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(887)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(888)
					p.expr(0)
				}

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

		case SQLiteParserSTAR:
			{
				p.SetState(894)
				p.Match(SQLiteParserSTAR)
			}

		case SQLiteParserCLOSE_PAR:

		default:
		}
		{
			p.SetState(897)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		p.SetState(899)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 110, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(898)
				p.Filter_clause()
			}

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

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 111, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(901)
				p.Over_clause()
			}

		}

	case 6:
		{
			p.SetState(904)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(905)
			p.expr(0)
		}
		p.SetState(910)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(906)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(907)
				p.expr(0)
			}

			p.SetState(912)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(913)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case 7:
		{
			p.SetState(915)
			p.Match(SQLiteParserCAST_)
		}
		{
			p.SetState(916)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(917)
			p.expr(0)
		}
		{
			p.SetState(918)
			p.Match(SQLiteParserAS_)
		}
		{
			p.SetState(919)
			p.Type_name()
		}
		{
			p.SetState(920)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case 8:
		p.SetState(926)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserEXISTS_ || _la == SQLiteParserNOT_ {
			p.SetState(923)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == SQLiteParserNOT_ {
				{
					p.SetState(922)
					p.Match(SQLiteParserNOT_)
				}

			}
			{
				p.SetState(925)
				p.Match(SQLiteParserEXISTS_)
			}

		}
		{
			p.SetState(928)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(929)
			p.Select_stmt()
		}
		{
			p.SetState(930)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case 9:
		{
			p.SetState(932)
			p.Match(SQLiteParserCASE_)
		}
		p.SetState(934)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 115, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(933)
				p.expr(0)
			}

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

		for ok := true; ok; ok = _la == SQLiteParserWHEN_ {
			{
				p.SetState(936)
				p.Match(SQLiteParserWHEN_)
			}
			{
				p.SetState(937)
				p.expr(0)
			}
			{
				p.SetState(938)
				p.Match(SQLiteParserTHEN_)
			}
			{
				p.SetState(939)
				p.expr(0)
			}

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

		if _la == SQLiteParserELSE_ {
			{
				p.SetState(945)
				p.Match(SQLiteParserELSE_)
			}
			{
				p.SetState(946)
				p.expr(0)
			}

		}
		{
			p.SetState(949)
			p.Match(SQLiteParserEND_)
		}

	case 10:
		{
			p.SetState(951)
			p.Raise_function()
		}

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

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			if p.GetParseListeners() != nil {
				p.TriggerExitRuleEvent()
			}
			_prevctx = localctx
			p.SetState(1071)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 133, p.GetParserRuleContext()) {
			case 1:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SQLiteParserRULE_expr)
				p.SetState(954)

				if !(p.Precpred(p.GetParserRuleContext(), 20)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 20)", ""))
				}
				{
					p.SetState(955)
					p.Match(SQLiteParserPIPE2)
				}
				{
					p.SetState(956)
					p.expr(21)
				}

			case 2:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SQLiteParserRULE_expr)
				p.SetState(957)

				if !(p.Precpred(p.GetParserRuleContext(), 19)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 19)", ""))
				}
				{
					p.SetState(958)
					_la = p.GetTokenStream().LA(1)

					if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SQLiteParserSTAR)|(1<<SQLiteParserDIV)|(1<<SQLiteParserMOD))) != 0) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(959)
					p.expr(20)
				}

			case 3:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SQLiteParserRULE_expr)
				p.SetState(960)

				if !(p.Precpred(p.GetParserRuleContext(), 18)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 18)", ""))
				}
				{
					p.SetState(961)
					_la = p.GetTokenStream().LA(1)

					if !(_la == SQLiteParserPLUS || _la == SQLiteParserMINUS) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(962)
					p.expr(19)
				}

			case 4:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SQLiteParserRULE_expr)
				p.SetState(963)

				if !(p.Precpred(p.GetParserRuleContext(), 17)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 17)", ""))
				}
				{
					p.SetState(964)
					_la = p.GetTokenStream().LA(1)

					if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SQLiteParserLT2)|(1<<SQLiteParserGT2)|(1<<SQLiteParserAMP)|(1<<SQLiteParserPIPE))) != 0) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(965)
					p.expr(18)
				}

			case 5:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SQLiteParserRULE_expr)
				p.SetState(966)

				if !(p.Precpred(p.GetParserRuleContext(), 16)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 16)", ""))
				}
				{
					p.SetState(967)
					_la = p.GetTokenStream().LA(1)

					if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SQLiteParserLT)|(1<<SQLiteParserLT_EQ)|(1<<SQLiteParserGT)|(1<<SQLiteParserGT_EQ))) != 0) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(968)
					p.expr(17)
				}

			case 6:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SQLiteParserRULE_expr)
				p.SetState(969)

				if !(p.Precpred(p.GetParserRuleContext(), 15)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 15)", ""))
				}
				p.SetState(982)
				p.GetErrorHandler().Sync(p)
				switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 119, p.GetParserRuleContext()) {
				case 1:
					{
						p.SetState(970)
						p.Match(SQLiteParserASSIGN)
					}

				case 2:
					{
						p.SetState(971)
						p.Match(SQLiteParserEQ)
					}

				case 3:
					{
						p.SetState(972)
						p.Match(SQLiteParserNOT_EQ1)
					}

				case 4:
					{
						p.SetState(973)
						p.Match(SQLiteParserNOT_EQ2)
					}

				case 5:
					{
						p.SetState(974)
						p.Match(SQLiteParserIS_)
					}

				case 6:
					{
						p.SetState(975)
						p.Match(SQLiteParserIS_)
					}
					{
						p.SetState(976)
						p.Match(SQLiteParserNOT_)
					}

				case 7:
					{
						p.SetState(977)
						p.Match(SQLiteParserIN_)
					}

				case 8:
					{
						p.SetState(978)
						p.Match(SQLiteParserLIKE_)
					}

				case 9:
					{
						p.SetState(979)
						p.Match(SQLiteParserGLOB_)
					}

				case 10:
					{
						p.SetState(980)
						p.Match(SQLiteParserMATCH_)
					}

				case 11:
					{
						p.SetState(981)
						p.Match(SQLiteParserREGEXP_)
					}

				}
				{
					p.SetState(984)
					p.expr(16)
				}

			case 7:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SQLiteParserRULE_expr)
				p.SetState(985)

				if !(p.Precpred(p.GetParserRuleContext(), 14)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", ""))
				}
				{
					p.SetState(986)
					p.Match(SQLiteParserAND_)
				}
				{
					p.SetState(987)
					p.expr(15)
				}

			case 8:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SQLiteParserRULE_expr)
				p.SetState(988)

				if !(p.Precpred(p.GetParserRuleContext(), 13)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 13)", ""))
				}
				{
					p.SetState(989)
					p.Match(SQLiteParserOR_)
				}
				{
					p.SetState(990)
					p.expr(14)
				}

			case 9:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SQLiteParserRULE_expr)
				p.SetState(991)

				if !(p.Precpred(p.GetParserRuleContext(), 6)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", ""))
				}
				{
					p.SetState(992)
					p.Match(SQLiteParserIS_)
				}
				p.SetState(994)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 120, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(993)
						p.Match(SQLiteParserNOT_)
					}

				}
				{
					p.SetState(996)
					p.expr(7)
				}

			case 10:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SQLiteParserRULE_expr)
				p.SetState(997)

				if !(p.Precpred(p.GetParserRuleContext(), 5)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
				}
				p.SetState(999)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == SQLiteParserNOT_ {
					{
						p.SetState(998)
						p.Match(SQLiteParserNOT_)
					}

				}
				{
					p.SetState(1001)
					p.Match(SQLiteParserBETWEEN_)
				}
				{
					p.SetState(1002)
					p.expr(0)
				}
				{
					p.SetState(1003)
					p.Match(SQLiteParserAND_)
				}
				{
					p.SetState(1004)
					p.expr(6)
				}

			case 11:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SQLiteParserRULE_expr)
				p.SetState(1006)

				if !(p.Precpred(p.GetParserRuleContext(), 9)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", ""))
				}
				{
					p.SetState(1007)
					p.Match(SQLiteParserCOLLATE_)
				}
				{
					p.SetState(1008)
					p.Collation_name()
				}

			case 12:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SQLiteParserRULE_expr)
				p.SetState(1009)

				if !(p.Precpred(p.GetParserRuleContext(), 8)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", ""))
				}
				p.SetState(1011)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == SQLiteParserNOT_ {
					{
						p.SetState(1010)
						p.Match(SQLiteParserNOT_)
					}

				}
				{
					p.SetState(1013)
					_la = p.GetTokenStream().LA(1)

					if !((((_la-77)&-(0x1f+1)) == 0 && ((1<<uint((_la-77)))&((1<<(SQLiteParserGLOB_-77))|(1<<(SQLiteParserLIKE_-77))|(1<<(SQLiteParserMATCH_-77)))) != 0) || _la == SQLiteParserREGEXP_) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1014)
					p.expr(0)
				}
				p.SetState(1017)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 123, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(1015)
						p.Match(SQLiteParserESCAPE_)
					}
					{
						p.SetState(1016)
						p.expr(0)
					}

				}

			case 13:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SQLiteParserRULE_expr)
				p.SetState(1019)

				if !(p.Precpred(p.GetParserRuleContext(), 7)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", ""))
				}
				p.SetState(1024)
				p.GetErrorHandler().Sync(p)

				switch p.GetTokenStream().LA(1) {
				case SQLiteParserISNULL_:
					{
						p.SetState(1020)
						p.Match(SQLiteParserISNULL_)
					}

				case SQLiteParserNOTNULL_:
					{
						p.SetState(1021)
						p.Match(SQLiteParserNOTNULL_)
					}

				case SQLiteParserNOT_:
					{
						p.SetState(1022)
						p.Match(SQLiteParserNOT_)
					}
					{
						p.SetState(1023)
						p.Match(SQLiteParserNULL_)
					}

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

			case 14:
				localctx = NewExprContext(p, _parentctx, _parentState)
				p.PushNewRecursionContext(localctx, _startState, SQLiteParserRULE_expr)
				p.SetState(1026)

				if !(p.Precpred(p.GetParserRuleContext(), 4)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
				}
				p.SetState(1028)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				if _la == SQLiteParserNOT_ {
					{
						p.SetState(1027)
						p.Match(SQLiteParserNOT_)
					}

				}
				{
					p.SetState(1030)
					p.Match(SQLiteParserIN_)
				}
				p.SetState(1069)
				p.GetErrorHandler().Sync(p)
				switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 132, p.GetParserRuleContext()) {
				case 1:
					{
						p.SetState(1031)
						p.Match(SQLiteParserOPEN_PAR)
					}
					p.SetState(1041)
					p.GetErrorHandler().Sync(p)

					if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 127, p.GetParserRuleContext()) == 1 {
						{
							p.SetState(1032)
							p.Select_stmt()
						}

					} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 127, p.GetParserRuleContext()) == 2 {
						{
							p.SetState(1033)
							p.expr(0)
						}
						p.SetState(1038)
						p.GetErrorHandler().Sync(p)
						_la = p.GetTokenStream().LA(1)

						for _la == SQLiteParserCOMMA {
							{
								p.SetState(1034)
								p.Match(SQLiteParserCOMMA)
							}
							{
								p.SetState(1035)
								p.expr(0)
							}

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

					}
					{
						p.SetState(1043)
						p.Match(SQLiteParserCLOSE_PAR)
					}

				case 2:
					p.SetState(1047)
					p.GetErrorHandler().Sync(p)

					if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 128, p.GetParserRuleContext()) == 1 {
						{
							p.SetState(1044)
							p.Schema_name()
						}
						{
							p.SetState(1045)
							p.Match(SQLiteParserDOT)
						}

					}
					{
						p.SetState(1049)
						p.Table_name()
					}

				case 3:
					p.SetState(1053)
					p.GetErrorHandler().Sync(p)

					if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 129, p.GetParserRuleContext()) == 1 {
						{
							p.SetState(1050)
							p.Schema_name()
						}
						{
							p.SetState(1051)
							p.Match(SQLiteParserDOT)
						}

					}
					{
						p.SetState(1055)
						p.Table_function_name()
					}
					{
						p.SetState(1056)
						p.Match(SQLiteParserOPEN_PAR)
					}
					p.SetState(1065)
					p.GetErrorHandler().Sync(p)
					_la = p.GetTokenStream().LA(1)

					if (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SQLiteParserOPEN_PAR)|(1<<SQLiteParserPLUS)|(1<<SQLiteParserMINUS)|(1<<SQLiteParserTILDE)|(1<<SQLiteParserABORT_)|(1<<SQLiteParserACTION_)|(1<<SQLiteParserADD_)|(1<<SQLiteParserAFTER_)|(1<<SQLiteParserALL_)|(1<<SQLiteParserALTER_)|(1<<SQLiteParserANALYZE_))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(SQLiteParserAND_-32))|(1<<(SQLiteParserAS_-32))|(1<<(SQLiteParserASC_-32))|(1<<(SQLiteParserATTACH_-32))|(1<<(SQLiteParserAUTOINCREMENT_-32))|(1<<(SQLiteParserBEFORE_-32))|(1<<(SQLiteParserBEGIN_-32))|(1<<(SQLiteParserBETWEEN_-32))|(1<<(SQLiteParserBY_-32))|(1<<(SQLiteParserCASCADE_-32))|(1<<(SQLiteParserCASE_-32))|(1<<(SQLiteParserCAST_-32))|(1<<(SQLiteParserCHECK_-32))|(1<<(SQLiteParserCOLLATE_-32))|(1<<(SQLiteParserCOLUMN_-32))|(1<<(SQLiteParserCOMMIT_-32))|(1<<(SQLiteParserCONFLICT_-32))|(1<<(SQLiteParserCONSTRAINT_-32))|(1<<(SQLiteParserCREATE_-32))|(1<<(SQLiteParserCROSS_-32))|(1<<(SQLiteParserCURRENT_DATE_-32))|(1<<(SQLiteParserCURRENT_TIME_-32))|(1<<(SQLiteParserCURRENT_TIMESTAMP_-32))|(1<<(SQLiteParserDATABASE_-32))|(1<<(SQLiteParserDEFAULT_-32))|(1<<(SQLiteParserDEFERRABLE_-32))|(1<<(SQLiteParserDEFERRED_-32))|(1<<(SQLiteParserDELETE_-32))|(1<<(SQLiteParserDESC_-32))|(1<<(SQLiteParserDETACH_-32))|(1<<(SQLiteParserDISTINCT_-32))|(1<<(SQLiteParserDROP_-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(SQLiteParserEACH_-64))|(1<<(SQLiteParserELSE_-64))|(1<<(SQLiteParserEND_-64))|(1<<(SQLiteParserESCAPE_-64))|(1<<(SQLiteParserEXCEPT_-64))|(1<<(SQLiteParserEXCLUSIVE_-64))|(1<<(SQLiteParserEXISTS_-64))|(1<<(SQLiteParserEXPLAIN_-64))|(1<<(SQLiteParserFAIL_-64))|(1<<(SQLiteParserFOR_-64))|(1<<(SQLiteParserFOREIGN_-64))|(1<<(SQLiteParserFROM_-64))|(1<<(SQLiteParserFULL_-64))|(1<<(SQLiteParserGLOB_-64))|(1<<(SQLiteParserGROUP_-64))|(1<<(SQLiteParserHAVING_-64))|(1<<(SQLiteParserIF_-64))|(1<<(SQLiteParserIGNORE_-64))|(1<<(SQLiteParserIMMEDIATE_-64))|(1<<(SQLiteParserIN_-64))|(1<<(SQLiteParserINDEX_-64))|(1<<(SQLiteParserINDEXED_-64))|(1<<(SQLiteParserINITIALLY_-64))|(1<<(SQLiteParserINNER_-64))|(1<<(SQLiteParserINSERT_-64))|(1<<(SQLiteParserINSTEAD_-64))|(1<<(SQLiteParserINTERSECT_-64))|(1<<(SQLiteParserINTO_-64))|(1<<(SQLiteParserIS_-64))|(1<<(SQLiteParserISNULL_-64))|(1<<(SQLiteParserJOIN_-64))|(1<<(SQLiteParserKEY_-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(SQLiteParserLEFT_-96))|(1<<(SQLiteParserLIKE_-96))|(1<<(SQLiteParserLIMIT_-96))|(1<<(SQLiteParserMATCH_-96))|(1<<(SQLiteParserNATURAL_-96))|(1<<(SQLiteParserNO_-96))|(1<<(SQLiteParserNOT_-96))|(1<<(SQLiteParserNOTNULL_-96))|(1<<(SQLiteParserNULL_-96))|(1<<(SQLiteParserOF_-96))|(1<<(SQLiteParserOFFSET_-96))|(1<<(SQLiteParserON_-96))|(1<<(SQLiteParserOR_-96))|(1<<(SQLiteParserORDER_-96))|(1<<(SQLiteParserOUTER_-96))|(1<<(SQLiteParserPLAN_-96))|(1<<(SQLiteParserPRAGMA_-96))|(1<<(SQLiteParserPRIMARY_-96))|(1<<(SQLiteParserQUERY_-96))|(1<<(SQLiteParserRAISE_-96))|(1<<(SQLiteParserRECURSIVE_-96))|(1<<(SQLiteParserREFERENCES_-96))|(1<<(SQLiteParserREGEXP_-96))|(1<<(SQLiteParserREINDEX_-96))|(1<<(SQLiteParserRELEASE_-96))|(1<<(SQLiteParserRENAME_-96))|(1<<(SQLiteParserREPLACE_-96))|(1<<(SQLiteParserRESTRICT_-96))|(1<<(SQLiteParserRIGHT_-96))|(1<<(SQLiteParserROLLBACK_-96))|(1<<(SQLiteParserROW_-96))|(1<<(SQLiteParserROWS_-96)))) != 0) || (((_la-128)&-(0x1f+1)) == 0 && ((1<<uint((_la-128)))&((1<<(SQLiteParserSAVEPOINT_-128))|(1<<(SQLiteParserSELECT_-128))|(1<<(SQLiteParserSET_-128))|(1<<(SQLiteParserTABLE_-128))|(1<<(SQLiteParserTEMP_-128))|(1<<(SQLiteParserTEMPORARY_-128))|(1<<(SQLiteParserTHEN_-128))|(1<<(SQLiteParserTO_-128))|(1<<(SQLiteParserTRANSACTION_-128))|(1<<(SQLiteParserTRIGGER_-128))|(1<<(SQLiteParserUNION_-128))|(1<<(SQLiteParserUNIQUE_-128))|(1<<(SQLiteParserUPDATE_-128))|(1<<(SQLiteParserUSING_-128))|(1<<(SQLiteParserVACUUM_-128))|(1<<(SQLiteParserVALUES_-128))|(1<<(SQLiteParserVIEW_-128))|(1<<(SQLiteParserVIRTUAL_-128))|(1<<(SQLiteParserWHEN_-128))|(1<<(SQLiteParserWHERE_-128))|(1<<(SQLiteParserWITH_-128))|(1<<(SQLiteParserWITHOUT_-128))|(1<<(SQLiteParserFIRST_VALUE_-128))|(1<<(SQLiteParserOVER_-128))|(1<<(SQLiteParserPARTITION_-128))|(1<<(SQLiteParserRANGE_-128))|(1<<(SQLiteParserPRECEDING_-128))|(1<<(SQLiteParserUNBOUNDED_-128))|(1<<(SQLiteParserCURRENT_-128))|(1<<(SQLiteParserFOLLOWING_-128))|(1<<(SQLiteParserCUME_DIST_-128))|(1<<(SQLiteParserDENSE_RANK_-128)))) != 0) || (((_la-160)&-(0x1f+1)) == 0 && ((1<<uint((_la-160)))&((1<<(SQLiteParserLAG_-160))|(1<<(SQLiteParserLAST_VALUE_-160))|(1<<(SQLiteParserLEAD_-160))|(1<<(SQLiteParserNTH_VALUE_-160))|(1<<(SQLiteParserNTILE_-160))|(1<<(SQLiteParserPERCENT_RANK_-160))|(1<<(SQLiteParserRANK_-160))|(1<<(SQLiteParserROW_NUMBER_-160))|(1<<(SQLiteParserGENERATED_-160))|(1<<(SQLiteParserALWAYS_-160))|(1<<(SQLiteParserSTORED_-160))|(1<<(SQLiteParserTRUE_-160))|(1<<(SQLiteParserFALSE_-160))|(1<<(SQLiteParserWINDOW_-160))|(1<<(SQLiteParserNULLS_-160))|(1<<(SQLiteParserFIRST_-160))|(1<<(SQLiteParserLAST_-160))|(1<<(SQLiteParserFILTER_-160))|(1<<(SQLiteParserGROUPS_-160))|(1<<(SQLiteParserEXCLUDE_-160))|(1<<(SQLiteParserIDENTIFIER-160))|(1<<(SQLiteParserNUMERIC_LITERAL-160))|(1<<(SQLiteParserBIND_PARAMETER-160))|(1<<(SQLiteParserSTRING_LITERAL-160))|(1<<(SQLiteParserBLOB_LITERAL-160)))) != 0) {
						{
							p.SetState(1057)
							p.expr(0)
						}
						p.SetState(1062)
						p.GetErrorHandler().Sync(p)
						_la = p.GetTokenStream().LA(1)

						for _la == SQLiteParserCOMMA {
							{
								p.SetState(1058)
								p.Match(SQLiteParserCOMMA)
							}
							{
								p.SetState(1059)
								p.expr(0)
							}

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

					}
					{
						p.SetState(1067)
						p.Match(SQLiteParserCLOSE_PAR)
					}

				}

			}

		}
		p.SetState(1075)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 134, p.GetParserRuleContext())
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_raise_function

	return p
}

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

func (s *Raise_functionContext) RAISE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRAISE_, 0)
}

func (s *Raise_functionContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Raise_functionContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

func (s *Raise_functionContext) IGNORE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIGNORE_, 0)
}

func (s *Raise_functionContext) COMMA() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMA, 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) ROLLBACK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROLLBACK_, 0)
}

func (s *Raise_functionContext) ABORT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserABORT_, 0)
}

func (s *Raise_functionContext) FAIL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFAIL_, 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.(SQLiteParserListener); ok {
		listenerT.EnterRaise_function(s)
	}
}

func (s *Raise_functionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitRaise_function(s)
	}
}

func (p *SQLiteParser) Raise_function() (localctx IRaise_functionContext) {
	this := p
	_ = this

	localctx = NewRaise_functionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, SQLiteParserRULE_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(1076)
		p.Match(SQLiteParserRAISE_)
	}
	{
		p.SetState(1077)
		p.Match(SQLiteParserOPEN_PAR)
	}
	p.SetState(1082)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserIGNORE_:
		{
			p.SetState(1078)
			p.Match(SQLiteParserIGNORE_)
		}

	case SQLiteParserABORT_, SQLiteParserFAIL_, SQLiteParserROLLBACK_:
		{
			p.SetState(1079)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SQLiteParserABORT_ || _la == SQLiteParserFAIL_ || _la == SQLiteParserROLLBACK_) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1080)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(1081)
			p.Error_message()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(1084)
		p.Match(SQLiteParserCLOSE_PAR)
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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(SQLiteParserNUMERIC_LITERAL, 0)
}

func (s *Literal_valueContext) STRING_LITERAL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSTRING_LITERAL, 0)
}

func (s *Literal_valueContext) BLOB_LITERAL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBLOB_LITERAL, 0)
}

func (s *Literal_valueContext) NULL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNULL_, 0)
}

func (s *Literal_valueContext) TRUE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTRUE_, 0)
}

func (s *Literal_valueContext) FALSE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFALSE_, 0)
}

func (s *Literal_valueContext) CURRENT_TIME_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCURRENT_TIME_, 0)
}

func (s *Literal_valueContext) CURRENT_DATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCURRENT_DATE_, 0)
}

func (s *Literal_valueContext) CURRENT_TIMESTAMP_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCURRENT_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.(SQLiteParserListener); ok {
		listenerT.EnterLiteral_value(s)
	}
}

func (s *Literal_valueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitLiteral_value(s)
	}
}

func (p *SQLiteParser) Literal_value() (localctx ILiteral_valueContext) {
	this := p
	_ = this

	localctx = NewLiteral_valueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, SQLiteParserRULE_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(1086)
		_la = p.GetTokenStream().LA(1)

		if !((((_la-52)&-(0x1f+1)) == 0 && ((1<<uint((_la-52)))&((1<<(SQLiteParserCURRENT_DATE_-52))|(1<<(SQLiteParserCURRENT_TIME_-52))|(1<<(SQLiteParserCURRENT_TIMESTAMP_-52)))) != 0) || _la == SQLiteParserNULL_ || (((_la-171)&-(0x1f+1)) == 0 && ((1<<uint((_la-171)))&((1<<(SQLiteParserTRUE_-171))|(1<<(SQLiteParserFALSE_-171))|(1<<(SQLiteParserNUMERIC_LITERAL-171))|(1<<(SQLiteParserSTRING_LITERAL-171))|(1<<(SQLiteParserBLOB_LITERAL-171)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_insert_stmt

	return p
}

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

func (s *Insert_stmtContext) INTO_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINTO_, 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) INSERT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINSERT_, 0)
}

func (s *Insert_stmtContext) REPLACE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserREPLACE_, 0)
}

func (s *Insert_stmtContext) OR_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOR_, 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) ROLLBACK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROLLBACK_, 0)
}

func (s *Insert_stmtContext) ABORT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserABORT_, 0)
}

func (s *Insert_stmtContext) FAIL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFAIL_, 0)
}

func (s *Insert_stmtContext) IGNORE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIGNORE_, 0)
}

func (s *Insert_stmtContext) Schema_name() ISchema_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISchema_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

func (s *Insert_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDOT, 0)
}

func (s *Insert_stmtContext) AS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAS_, 0)
}

func (s *Insert_stmtContext) 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 *Insert_stmtContext) AllOPEN_PAR() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserOPEN_PAR)
}

func (s *Insert_stmtContext) OPEN_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, i)
}

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) AllCLOSE_PAR() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCLOSE_PAR)
}

func (s *Insert_stmtContext) CLOSE_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, i)
}

func (s *Insert_stmtContext) VALUES_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserVALUES_, 0)
}

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) 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) Upsert_clause() IUpsert_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IUpsert_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IUpsert_clauseContext)
}

func (s *Insert_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

func (s *Insert_stmtContext) DEFAULT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDEFAULT_, 0)
}

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

func (s *Insert_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitInsert_stmt(s)
	}
}

func (p *SQLiteParser) Insert_stmt() (localctx IInsert_stmtContext) {
	this := p
	_ = this

	localctx = NewInsert_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, SQLiteParserRULE_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.SetState(1158)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserINSERT_, SQLiteParserREPLACE_, SQLiteParserWITH_:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(1089)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserWITH_ {
			{
				p.SetState(1088)
				p.With_clause()
			}

		}
		p.SetState(1096)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 137, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1091)
				p.Match(SQLiteParserINSERT_)
			}

		case 2:
			{
				p.SetState(1092)
				p.Match(SQLiteParserREPLACE_)
			}

		case 3:
			{
				p.SetState(1093)
				p.Match(SQLiteParserINSERT_)
			}
			{
				p.SetState(1094)
				p.Match(SQLiteParserOR_)
			}
			{
				p.SetState(1095)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SQLiteParserABORT_ || _la == SQLiteParserFAIL_ || _la == SQLiteParserIGNORE_ || _la == SQLiteParserREPLACE_ || _la == SQLiteParserROLLBACK_) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}

		}
		{
			p.SetState(1098)
			p.Match(SQLiteParserINTO_)
		}
		p.SetState(1102)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 138, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1099)
				p.Schema_name()
			}
			{
				p.SetState(1100)
				p.Match(SQLiteParserDOT)
			}

		}
		{
			p.SetState(1104)
			p.Table_name()
		}
		p.SetState(1107)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserAS_ {
			{
				p.SetState(1105)
				p.Match(SQLiteParserAS_)
			}
			{
				p.SetState(1106)
				p.Table_alias()
			}

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

		if _la == SQLiteParserOPEN_PAR {
			{
				p.SetState(1109)
				p.Match(SQLiteParserOPEN_PAR)
			}
			{
				p.SetState(1110)
				p.Column_name()
			}
			p.SetState(1115)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(1111)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(1112)
					p.Column_name()
				}

				p.SetState(1117)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(1118)
				p.Match(SQLiteParserCLOSE_PAR)
			}

		}

		p.SetState(1151)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 145, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1122)
				p.Match(SQLiteParserVALUES_)
			}
			{
				p.SetState(1123)
				p.Match(SQLiteParserOPEN_PAR)
			}
			{
				p.SetState(1124)
				p.expr(0)
			}
			p.SetState(1129)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(1125)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(1126)
					p.expr(0)
				}

				p.SetState(1131)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(1132)
				p.Match(SQLiteParserCLOSE_PAR)
			}
			p.SetState(1147)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(1133)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(1134)
					p.Match(SQLiteParserOPEN_PAR)
				}
				{
					p.SetState(1135)
					p.expr(0)
				}
				p.SetState(1140)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				for _la == SQLiteParserCOMMA {
					{
						p.SetState(1136)
						p.Match(SQLiteParserCOMMA)
					}
					{
						p.SetState(1137)
						p.expr(0)
					}

					p.SetState(1142)
					p.GetErrorHandler().Sync(p)
					_la = p.GetTokenStream().LA(1)
				}
				{
					p.SetState(1143)
					p.Match(SQLiteParserCLOSE_PAR)
				}

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

		case 2:
			{
				p.SetState(1150)
				p.Select_stmt()
			}

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

		if _la == SQLiteParserON_ {
			{
				p.SetState(1153)
				p.Upsert_clause()
			}

		}

	case SQLiteParserDEFAULT_:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1156)
			p.Match(SQLiteParserDEFAULT_)
		}
		{
			p.SetState(1157)
			p.Match(SQLiteParserVALUES_)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyUpsert_clauseContext() *Upsert_clauseContext {
	var p = new(Upsert_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_upsert_clause
	return p
}

func (*Upsert_clauseContext) IsUpsert_clauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_upsert_clause

	return p
}

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

func (s *Upsert_clauseContext) ON_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserON_, 0)
}

func (s *Upsert_clauseContext) CONFLICT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCONFLICT_, 0)
}

func (s *Upsert_clauseContext) DO_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDO_, 0)
}

func (s *Upsert_clauseContext) NOTHING_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOTHING_, 0)
}

func (s *Upsert_clauseContext) UPDATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUPDATE_, 0)
}

func (s *Upsert_clauseContext) SET_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSET_, 0)
}

func (s *Upsert_clauseContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Upsert_clauseContext) 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 *Upsert_clauseContext) 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 *Upsert_clauseContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

func (s *Upsert_clauseContext) AllEQ() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserEQ)
}

func (s *Upsert_clauseContext) EQ(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserEQ, i)
}

func (s *Upsert_clauseContext) 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 *Upsert_clauseContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Upsert_clauseContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

func (s *Upsert_clauseContext) AllWHERE_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserWHERE_)
}

func (s *Upsert_clauseContext) WHERE_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserWHERE_, i)
}

func (s *Upsert_clauseContext) 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 *Upsert_clauseContext) 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 *Upsert_clauseContext) AllColumn_name_list() []IColumn_name_listContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumn_name_listContext)(nil)).Elem())
	var tst = make([]IColumn_name_listContext, len(ts))

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

	return tst
}

func (s *Upsert_clauseContext) Column_name_list(i int) IColumn_name_listContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_name_listContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumn_name_listContext)
}

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

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

func (s *Upsert_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterUpsert_clause(s)
	}
}

func (s *Upsert_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitUpsert_clause(s)
	}
}

func (p *SQLiteParser) Upsert_clause() (localctx IUpsert_clauseContext) {
	this := p
	_ = this

	localctx = NewUpsert_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, SQLiteParserRULE_upsert_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(1160)
		p.Match(SQLiteParserON_)
	}
	{
		p.SetState(1161)
		p.Match(SQLiteParserCONFLICT_)
	}
	p.SetState(1176)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserOPEN_PAR {
		{
			p.SetState(1162)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1163)
			p.Indexed_column()
		}
		p.SetState(1168)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1164)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1165)
				p.Indexed_column()
			}

			p.SetState(1170)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1171)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		p.SetState(1174)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserWHERE_ {
			{
				p.SetState(1172)
				p.Match(SQLiteParserWHERE_)
			}
			{
				p.SetState(1173)
				p.expr(0)
			}

		}

	}
	{
		p.SetState(1178)
		p.Match(SQLiteParserDO_)
	}
	p.SetState(1205)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserNOTHING_:
		{
			p.SetState(1179)
			p.Match(SQLiteParserNOTHING_)
		}

	case SQLiteParserUPDATE_:
		{
			p.SetState(1180)
			p.Match(SQLiteParserUPDATE_)
		}
		{
			p.SetState(1181)
			p.Match(SQLiteParserSET_)
		}

		p.SetState(1184)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 151, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1182)
				p.Column_name()
			}

		case 2:
			{
				p.SetState(1183)
				p.Column_name_list()
			}

		}
		{
			p.SetState(1186)
			p.Match(SQLiteParserEQ)
		}
		{
			p.SetState(1187)
			p.expr(0)
		}
		p.SetState(1198)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1188)
				p.Match(SQLiteParserCOMMA)
			}
			p.SetState(1191)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 152, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(1189)
					p.Column_name()
				}

			case 2:
				{
					p.SetState(1190)
					p.Column_name_list()
				}

			}
			{
				p.SetState(1193)
				p.Match(SQLiteParserEQ)
			}
			{
				p.SetState(1194)
				p.expr(0)
			}

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

		if _la == SQLiteParserWHERE_ {
			{
				p.SetState(1201)
				p.Match(SQLiteParserWHERE_)
			}
			{
				p.SetState(1202)
				p.expr(0)
			}

		}

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

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_pragma_stmt

	return p
}

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

func (s *Pragma_stmtContext) PRAGMA_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPRAGMA_, 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) Schema_name() ISchema_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISchema_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

func (s *Pragma_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDOT, 0)
}

func (s *Pragma_stmtContext) ASSIGN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserASSIGN, 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(SQLiteParserOPEN_PAR, 0)
}

func (s *Pragma_stmtContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_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.(SQLiteParserListener); ok {
		listenerT.EnterPragma_stmt(s)
	}
}

func (s *Pragma_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitPragma_stmt(s)
	}
}

func (p *SQLiteParser) Pragma_stmt() (localctx IPragma_stmtContext) {
	this := p
	_ = this

	localctx = NewPragma_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, SQLiteParserRULE_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(1207)
		p.Match(SQLiteParserPRAGMA_)
	}
	p.SetState(1211)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 156, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1208)
			p.Schema_name()
		}
		{
			p.SetState(1209)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(1213)
		p.Pragma_name()
	}
	p.SetState(1220)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserASSIGN:
		{
			p.SetState(1214)
			p.Match(SQLiteParserASSIGN)
		}
		{
			p.SetState(1215)
			p.Pragma_value()
		}

	case SQLiteParserOPEN_PAR:
		{
			p.SetState(1216)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1217)
			p.Pragma_value()
		}
		{
			p.SetState(1218)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case SQLiteParserEOF, SQLiteParserSCOL, SQLiteParserALTER_, SQLiteParserANALYZE_, SQLiteParserATTACH_, SQLiteParserBEGIN_, SQLiteParserCOMMIT_, SQLiteParserCREATE_, SQLiteParserDEFAULT_, SQLiteParserDELETE_, SQLiteParserDETACH_, SQLiteParserDROP_, SQLiteParserEND_, SQLiteParserEXPLAIN_, SQLiteParserINSERT_, SQLiteParserPRAGMA_, SQLiteParserREINDEX_, SQLiteParserRELEASE_, SQLiteParserREPLACE_, SQLiteParserROLLBACK_, SQLiteParserSAVEPOINT_, SQLiteParserSELECT_, SQLiteParserUPDATE_, SQLiteParserVACUUM_, SQLiteParserVALUES_, SQLiteParserWITH_:

	default:
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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(SQLiteParserSTRING_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.(SQLiteParserListener); ok {
		listenerT.EnterPragma_value(s)
	}
}

func (s *Pragma_valueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitPragma_value(s)
	}
}

func (p *SQLiteParser) Pragma_value() (localctx IPragma_valueContext) {
	this := p
	_ = this

	localctx = NewPragma_valueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 76, SQLiteParserRULE_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(1225)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 158, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1222)
			p.Signed_number()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1223)
			p.Name()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1224)
			p.Match(SQLiteParserSTRING_LITERAL)
		}

	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_reindex_stmt

	return p
}

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

func (s *Reindex_stmtContext) REINDEX_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserREINDEX_, 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) Schema_name() ISchema_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISchema_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

func (s *Reindex_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDOT, 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.(SQLiteParserListener); ok {
		listenerT.EnterReindex_stmt(s)
	}
}

func (s *Reindex_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitReindex_stmt(s)
	}
}

func (p *SQLiteParser) Reindex_stmt() (localctx IReindex_stmtContext) {
	this := p
	_ = this

	localctx = NewReindex_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, SQLiteParserRULE_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(1227)
		p.Match(SQLiteParserREINDEX_)
	}
	p.SetState(1238)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 161, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1228)
			p.Collation_name()
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 161, p.GetParserRuleContext()) == 2 {
		p.SetState(1232)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 159, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1229)
				p.Schema_name()
			}
			{
				p.SetState(1230)
				p.Match(SQLiteParserDOT)
			}

		}
		p.SetState(1236)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 160, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1234)
				p.Table_name()
			}

		case 2:
			{
				p.SetState(1235)
				p.Index_name()
			}

		}

	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_select_stmt

	return p
}

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

func (s *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 *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 *Select_stmtContext) Common_table_stmt() ICommon_table_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommon_table_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICommon_table_stmtContext)
}

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) Order_by_stmt() IOrder_by_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrder_by_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOrder_by_stmtContext)
}

func (s *Select_stmtContext) Limit_stmt() ILimit_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILimit_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILimit_stmtContext)
}

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

func (s *Select_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitSelect_stmt(s)
	}
}

func (p *SQLiteParser) Select_stmt() (localctx ISelect_stmtContext) {
	this := p
	_ = this

	localctx = NewSelect_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, SQLiteParserRULE_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)
			}
		}
	}()

	var _alt int

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

	if _la == SQLiteParserWITH_ {
		{
			p.SetState(1240)
			p.Common_table_stmt()
		}

	}
	{
		p.SetState(1243)
		p.Select_core()
	}
	p.SetState(1249)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 163, p.GetParserRuleContext())

	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		if _alt == 1 {
			{
				p.SetState(1244)
				p.Compound_operator()
			}
			{
				p.SetState(1245)
				p.Select_core()
			}

		}
		p.SetState(1251)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 163, p.GetParserRuleContext())
	}
	p.SetState(1253)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserORDER_ {
		{
			p.SetState(1252)
			p.Order_by_stmt()
		}

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

	if _la == SQLiteParserLIMIT_ {
		{
			p.SetState(1255)
			p.Limit_stmt()
		}

	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterJoin_clause(s)
	}
}

func (s *Join_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitJoin_clause(s)
	}
}

func (p *SQLiteParser) Join_clause() (localctx IJoin_clauseContext) {
	this := p
	_ = this

	localctx = NewJoin_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, SQLiteParserRULE_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(1258)
		p.Table_or_subquery()
	}
	p.SetState(1266)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserCOMMA || _la == SQLiteParserCROSS_ || (((_la-87)&-(0x1f+1)) == 0 && ((1<<uint((_la-87)))&((1<<(SQLiteParserINNER_-87))|(1<<(SQLiteParserJOIN_-87))|(1<<(SQLiteParserLEFT_-87))|(1<<(SQLiteParserNATURAL_-87)))) != 0) {
		{
			p.SetState(1259)
			p.Join_operator()
		}
		{
			p.SetState(1260)
			p.Table_or_subquery()
		}
		p.SetState(1262)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 166, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1261)
				p.Join_constraint()
			}

		}

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

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_select_core

	return p
}

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

func (s *Select_coreContext) SELECT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSELECT_, 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(SQLiteParserCOMMA)
}

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

func (s *Select_coreContext) FROM_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFROM_, 0)
}

func (s *Select_coreContext) WHERE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWHERE_, 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) GROUP_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserGROUP_, 0)
}

func (s *Select_coreContext) BY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBY_, 0)
}

func (s *Select_coreContext) WINDOW_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWINDOW_, 0)
}

func (s *Select_coreContext) AllWindow_name() []IWindow_nameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IWindow_nameContext)(nil)).Elem())
	var tst = make([]IWindow_nameContext, len(ts))

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

	return tst
}

func (s *Select_coreContext) Window_name(i int) IWindow_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWindow_nameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IWindow_nameContext)
}

func (s *Select_coreContext) AllAS_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserAS_)
}

func (s *Select_coreContext) AS_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserAS_, i)
}

func (s *Select_coreContext) AllWindow_defn() []IWindow_defnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IWindow_defnContext)(nil)).Elem())
	var tst = make([]IWindow_defnContext, len(ts))

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

	return tst
}

func (s *Select_coreContext) Window_defn(i int) IWindow_defnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWindow_defnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IWindow_defnContext)
}

func (s *Select_coreContext) DISTINCT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDISTINCT_, 0)
}

func (s *Select_coreContext) ALL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserALL_, 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) HAVING_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserHAVING_, 0)
}

func (s *Select_coreContext) VALUES_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserVALUES_, 0)
}

func (s *Select_coreContext) AllOPEN_PAR() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserOPEN_PAR)
}

func (s *Select_coreContext) OPEN_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, i)
}

func (s *Select_coreContext) AllCLOSE_PAR() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCLOSE_PAR)
}

func (s *Select_coreContext) CLOSE_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_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.(SQLiteParserListener); ok {
		listenerT.EnterSelect_core(s)
	}
}

func (s *Select_coreContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitSelect_core(s)
	}
}

func (p *SQLiteParser) Select_core() (localctx ISelect_coreContext) {
	this := p
	_ = this

	localctx = NewSelect_coreContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 84, SQLiteParserRULE_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(1359)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserSELECT_:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1269)
			p.Match(SQLiteParserSELECT_)
		}
		p.SetState(1271)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 168, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1270)
				_la = p.GetTokenStream().LA(1)

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

		}
		{
			p.SetState(1273)
			p.Result_column()
		}
		p.SetState(1278)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1274)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1275)
				p.Result_column()
			}

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

		if _la == SQLiteParserFROM_ {
			{
				p.SetState(1281)
				p.Match(SQLiteParserFROM_)
			}
			p.SetState(1291)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 171, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(1282)
					p.Table_or_subquery()
				}
				p.SetState(1287)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				for _la == SQLiteParserCOMMA {
					{
						p.SetState(1283)
						p.Match(SQLiteParserCOMMA)
					}
					{
						p.SetState(1284)
						p.Table_or_subquery()
					}

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

			case 2:
				{
					p.SetState(1290)
					p.Join_clause()
				}

			}

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

		if _la == SQLiteParserWHERE_ {
			{
				p.SetState(1295)
				p.Match(SQLiteParserWHERE_)
			}
			{
				p.SetState(1296)
				p.expr(0)
			}

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

		if _la == SQLiteParserGROUP_ {
			{
				p.SetState(1299)
				p.Match(SQLiteParserGROUP_)
			}
			{
				p.SetState(1300)
				p.Match(SQLiteParserBY_)
			}
			{
				p.SetState(1301)
				p.expr(0)
			}
			p.SetState(1306)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(1302)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(1303)
					p.expr(0)
				}

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

			if _la == SQLiteParserHAVING_ {
				{
					p.SetState(1309)
					p.Match(SQLiteParserHAVING_)
				}
				{
					p.SetState(1310)
					p.expr(0)
				}

			}

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

		if _la == SQLiteParserWINDOW_ {
			{
				p.SetState(1315)
				p.Match(SQLiteParserWINDOW_)
			}
			{
				p.SetState(1316)
				p.Window_name()
			}
			{
				p.SetState(1317)
				p.Match(SQLiteParserAS_)
			}
			{
				p.SetState(1318)
				p.Window_defn()
			}
			p.SetState(1326)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(1319)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(1320)
					p.Window_name()
				}
				{
					p.SetState(1321)
					p.Match(SQLiteParserAS_)
				}
				{
					p.SetState(1322)
					p.Window_defn()
				}

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

		}

	case SQLiteParserVALUES_:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1331)
			p.Match(SQLiteParserVALUES_)
		}
		{
			p.SetState(1332)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1333)
			p.expr(0)
		}
		p.SetState(1338)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1334)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1335)
				p.expr(0)
			}

			p.SetState(1340)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1341)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		p.SetState(1356)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1342)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1343)
				p.Match(SQLiteParserOPEN_PAR)
			}
			{
				p.SetState(1344)
				p.expr(0)
			}
			p.SetState(1349)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(1345)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(1346)
					p.expr(0)
				}

				p.SetState(1351)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(1352)
				p.Match(SQLiteParserCLOSE_PAR)
			}

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

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

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_factored_select_stmt

	return p
}

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

func (s *Factored_select_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 *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.(SQLiteParserListener); ok {
		listenerT.EnterFactored_select_stmt(s)
	}
}

func (s *Factored_select_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitFactored_select_stmt(s)
	}
}

func (p *SQLiteParser) Factored_select_stmt() (localctx IFactored_select_stmtContext) {
	this := p
	_ = this

	localctx = NewFactored_select_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, SQLiteParserRULE_factored_select_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(1361)
		p.Select_stmt()
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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) Common_table_stmt() ICommon_table_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommon_table_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICommon_table_stmtContext)
}

func (s *Simple_select_stmtContext) Order_by_stmt() IOrder_by_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrder_by_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOrder_by_stmtContext)
}

func (s *Simple_select_stmtContext) Limit_stmt() ILimit_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILimit_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILimit_stmtContext)
}

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

func (s *Simple_select_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitSimple_select_stmt(s)
	}
}

func (p *SQLiteParser) Simple_select_stmt() (localctx ISimple_select_stmtContext) {
	this := p
	_ = this

	localctx = NewSimple_select_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, SQLiteParserRULE_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(1364)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserWITH_ {
		{
			p.SetState(1363)
			p.Common_table_stmt()
		}

	}
	{
		p.SetState(1366)
		p.Select_core()
	}
	p.SetState(1368)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserORDER_ {
		{
			p.SetState(1367)
			p.Order_by_stmt()
		}

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

	if _la == SQLiteParserLIMIT_ {
		{
			p.SetState(1370)
			p.Limit_stmt()
		}

	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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) Common_table_stmt() ICommon_table_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICommon_table_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICommon_table_stmtContext)
}

func (s *Compound_select_stmtContext) Order_by_stmt() IOrder_by_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrder_by_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOrder_by_stmtContext)
}

func (s *Compound_select_stmtContext) Limit_stmt() ILimit_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILimit_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILimit_stmtContext)
}

func (s *Compound_select_stmtContext) AllUNION_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserUNION_)
}

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

func (s *Compound_select_stmtContext) AllINTERSECT_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserINTERSECT_)
}

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

func (s *Compound_select_stmtContext) AllEXCEPT_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserEXCEPT_)
}

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

func (s *Compound_select_stmtContext) AllALL_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserALL_)
}

func (s *Compound_select_stmtContext) ALL_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserALL_, 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.(SQLiteParserListener); ok {
		listenerT.EnterCompound_select_stmt(s)
	}
}

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

func (p *SQLiteParser) Compound_select_stmt() (localctx ICompound_select_stmtContext) {
	this := p
	_ = this

	localctx = NewCompound_select_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, SQLiteParserRULE_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(1374)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserWITH_ {
		{
			p.SetState(1373)
			p.Common_table_stmt()
		}

	}
	{
		p.SetState(1376)
		p.Select_core()
	}
	p.SetState(1386)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == SQLiteParserEXCEPT_ || _la == SQLiteParserINTERSECT_ || _la == SQLiteParserUNION_ {
		p.SetState(1383)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SQLiteParserUNION_:
			{
				p.SetState(1377)
				p.Match(SQLiteParserUNION_)
			}
			p.SetState(1379)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == SQLiteParserALL_ {
				{
					p.SetState(1378)
					p.Match(SQLiteParserALL_)
				}

			}

		case SQLiteParserINTERSECT_:
			{
				p.SetState(1381)
				p.Match(SQLiteParserINTERSECT_)
			}

		case SQLiteParserEXCEPT_:
			{
				p.SetState(1382)
				p.Match(SQLiteParserEXCEPT_)
			}

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

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

	if _la == SQLiteParserORDER_ {
		{
			p.SetState(1390)
			p.Order_by_stmt()
		}

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

	if _la == SQLiteParserLIMIT_ {
		{
			p.SetState(1393)
			p.Limit_stmt()
		}

	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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) Schema_name() ISchema_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISchema_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

func (s *Table_or_subqueryContext) DOT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDOT, 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) INDEXED_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINDEXED_, 0)
}

func (s *Table_or_subqueryContext) BY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBY_, 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) NOT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOT_, 0)
}

func (s *Table_or_subqueryContext) AS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAS_, 0)
}

func (s *Table_or_subqueryContext) Table_function_name() ITable_function_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_function_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ITable_function_nameContext)
}

func (s *Table_or_subqueryContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Table_or_subqueryContext) 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 *Table_or_subqueryContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Table_or_subqueryContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

func (s *Table_or_subqueryContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

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

func (s *Table_or_subqueryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitTable_or_subquery(s)
	}
}

func (p *SQLiteParser) Table_or_subquery() (localctx ITable_or_subqueryContext) {
	this := p
	_ = this

	localctx = NewTable_or_subqueryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, SQLiteParserRULE_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(1460)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 204, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(1399)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 192, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1396)
				p.Schema_name()
			}
			{
				p.SetState(1397)
				p.Match(SQLiteParserDOT)
			}

		}
		{
			p.SetState(1401)
			p.Table_name()
		}
		p.SetState(1406)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 194, p.GetParserRuleContext()) == 1 {
			p.SetState(1403)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 193, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1402)
					p.Match(SQLiteParserAS_)
				}

			}
			{
				p.SetState(1405)
				p.Table_alias()
			}

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

		switch p.GetTokenStream().LA(1) {
		case SQLiteParserINDEXED_:
			{
				p.SetState(1408)
				p.Match(SQLiteParserINDEXED_)
			}
			{
				p.SetState(1409)
				p.Match(SQLiteParserBY_)
			}
			{
				p.SetState(1410)
				p.Index_name()
			}

		case SQLiteParserNOT_:
			{
				p.SetState(1411)
				p.Match(SQLiteParserNOT_)
			}
			{
				p.SetState(1412)
				p.Match(SQLiteParserINDEXED_)
			}

		case SQLiteParserEOF, SQLiteParserSCOL, SQLiteParserCLOSE_PAR, SQLiteParserCOMMA, SQLiteParserALTER_, SQLiteParserANALYZE_, SQLiteParserATTACH_, SQLiteParserBEGIN_, SQLiteParserCOMMIT_, SQLiteParserCREATE_, SQLiteParserCROSS_, SQLiteParserDEFAULT_, SQLiteParserDELETE_, SQLiteParserDETACH_, SQLiteParserDROP_, SQLiteParserEND_, SQLiteParserEXCEPT_, SQLiteParserEXPLAIN_, SQLiteParserGROUP_, SQLiteParserINNER_, SQLiteParserINSERT_, SQLiteParserINTERSECT_, SQLiteParserJOIN_, SQLiteParserLEFT_, SQLiteParserLIMIT_, SQLiteParserNATURAL_, SQLiteParserON_, SQLiteParserORDER_, SQLiteParserPRAGMA_, SQLiteParserREINDEX_, SQLiteParserRELEASE_, SQLiteParserREPLACE_, SQLiteParserROLLBACK_, SQLiteParserSAVEPOINT_, SQLiteParserSELECT_, SQLiteParserUNION_, SQLiteParserUPDATE_, SQLiteParserUSING_, SQLiteParserVACUUM_, SQLiteParserVALUES_, SQLiteParserWHERE_, SQLiteParserWITH_, SQLiteParserWINDOW_:

		default:
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(1418)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 196, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1415)
				p.Schema_name()
			}
			{
				p.SetState(1416)
				p.Match(SQLiteParserDOT)
			}

		}
		{
			p.SetState(1420)
			p.Table_function_name()
		}
		{
			p.SetState(1421)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1422)
			p.expr(0)
		}
		p.SetState(1427)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1423)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1424)
				p.expr(0)
			}

			p.SetState(1429)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1430)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		p.SetState(1435)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 199, p.GetParserRuleContext()) == 1 {
			p.SetState(1432)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 198, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1431)
					p.Match(SQLiteParserAS_)
				}

			}
			{
				p.SetState(1434)
				p.Table_alias()
			}

		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1437)
			p.Match(SQLiteParserOPEN_PAR)
		}
		p.SetState(1447)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 201, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1438)
				p.Table_or_subquery()
			}
			p.SetState(1443)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(1439)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(1440)
					p.Table_or_subquery()
				}

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

		case 2:
			{
				p.SetState(1446)
				p.Join_clause()
			}

		}
		{
			p.SetState(1449)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1451)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1452)
			p.Select_stmt()
		}
		{
			p.SetState(1453)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		p.SetState(1458)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 203, p.GetParserRuleContext()) == 1 {
			p.SetState(1455)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 202, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1454)
					p.Match(SQLiteParserAS_)
				}

			}
			{
				p.SetState(1457)
				p.Table_alias()
			}

		}

	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_result_column

	return p
}

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

func (s *Result_columnContext) STAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSTAR, 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(SQLiteParserDOT, 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) AS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAS_, 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.(SQLiteParserListener); ok {
		listenerT.EnterResult_column(s)
	}
}

func (s *Result_columnContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitResult_column(s)
	}
}

func (p *SQLiteParser) Result_column() (localctx IResult_columnContext) {
	this := p
	_ = this

	localctx = NewResult_columnContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, SQLiteParserRULE_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(1474)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 207, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1462)
			p.Match(SQLiteParserSTAR)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1463)
			p.Table_name()
		}
		{
			p.SetState(1464)
			p.Match(SQLiteParserDOT)
		}
		{
			p.SetState(1465)
			p.Match(SQLiteParserSTAR)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1467)
			p.expr(0)
		}
		p.SetState(1472)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserAS_ || _la == SQLiteParserIDENTIFIER || _la == SQLiteParserSTRING_LITERAL {
			p.SetState(1469)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == SQLiteParserAS_ {
				{
					p.SetState(1468)
					p.Match(SQLiteParserAS_)
				}

			}
			{
				p.SetState(1471)
				p.Column_alias()
			}

		}

	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_join_operator

	return p
}

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

func (s *Join_operatorContext) COMMA() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMA, 0)
}

func (s *Join_operatorContext) JOIN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserJOIN_, 0)
}

func (s *Join_operatorContext) NATURAL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNATURAL_, 0)
}

func (s *Join_operatorContext) LEFT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLEFT_, 0)
}

func (s *Join_operatorContext) INNER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINNER_, 0)
}

func (s *Join_operatorContext) CROSS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCROSS_, 0)
}

func (s *Join_operatorContext) OUTER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOUTER_, 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.(SQLiteParserListener); ok {
		listenerT.EnterJoin_operator(s)
	}
}

func (s *Join_operatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitJoin_operator(s)
	}
}

func (p *SQLiteParser) Join_operator() (localctx IJoin_operatorContext) {
	this := p
	_ = this

	localctx = NewJoin_operatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 96, SQLiteParserRULE_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(1489)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserCOMMA:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1476)
			p.Match(SQLiteParserCOMMA)
		}

	case SQLiteParserCROSS_, SQLiteParserINNER_, SQLiteParserJOIN_, SQLiteParserLEFT_, SQLiteParserNATURAL_:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(1478)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserNATURAL_ {
			{
				p.SetState(1477)
				p.Match(SQLiteParserNATURAL_)
			}

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

		switch p.GetTokenStream().LA(1) {
		case SQLiteParserLEFT_:
			{
				p.SetState(1480)
				p.Match(SQLiteParserLEFT_)
			}
			p.SetState(1482)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == SQLiteParserOUTER_ {
				{
					p.SetState(1481)
					p.Match(SQLiteParserOUTER_)
				}

			}

		case SQLiteParserINNER_:
			{
				p.SetState(1484)
				p.Match(SQLiteParserINNER_)
			}

		case SQLiteParserCROSS_:
			{
				p.SetState(1485)
				p.Match(SQLiteParserCROSS_)
			}

		case SQLiteParserJOIN_:

		default:
		}
		{
			p.SetState(1488)
			p.Match(SQLiteParserJOIN_)
		}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_join_constraint

	return p
}

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

func (s *Join_constraintContext) ON_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserON_, 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) USING_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUSING_, 0)
}

func (s *Join_constraintContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_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(SQLiteParserCLOSE_PAR, 0)
}

func (s *Join_constraintContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

func (s *Join_constraintContext) COMMA(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMA, 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.(SQLiteParserListener); ok {
		listenerT.EnterJoin_constraint(s)
	}
}

func (s *Join_constraintContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitJoin_constraint(s)
	}
}

func (p *SQLiteParser) Join_constraint() (localctx IJoin_constraintContext) {
	this := p
	_ = this

	localctx = NewJoin_constraintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 98, SQLiteParserRULE_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.SetState(1505)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserON_:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1491)
			p.Match(SQLiteParserON_)
		}
		{
			p.SetState(1492)
			p.expr(0)
		}

	case SQLiteParserUSING_:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1493)
			p.Match(SQLiteParserUSING_)
		}
		{
			p.SetState(1494)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1495)
			p.Column_name()
		}
		p.SetState(1500)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1496)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1497)
				p.Column_name()
			}

			p.SetState(1502)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1503)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_compound_operator

	return p
}

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

func (s *Compound_operatorContext) UNION_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUNION_, 0)
}

func (s *Compound_operatorContext) ALL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserALL_, 0)
}

func (s *Compound_operatorContext) INTERSECT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINTERSECT_, 0)
}

func (s *Compound_operatorContext) EXCEPT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXCEPT_, 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.(SQLiteParserListener); ok {
		listenerT.EnterCompound_operator(s)
	}
}

func (s *Compound_operatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitCompound_operator(s)
	}
}

func (p *SQLiteParser) Compound_operator() (localctx ICompound_operatorContext) {
	this := p
	_ = this

	localctx = NewCompound_operatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, SQLiteParserRULE_compound_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(1513)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserUNION_:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1507)
			p.Match(SQLiteParserUNION_)
		}
		p.SetState(1509)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserALL_ {
			{
				p.SetState(1508)
				p.Match(SQLiteParserALL_)
			}

		}

	case SQLiteParserINTERSECT_:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1511)
			p.Match(SQLiteParserINTERSECT_)
		}

	case SQLiteParserEXCEPT_:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1512)
			p.Match(SQLiteParserEXCEPT_)
		}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_update_stmt

	return p
}

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

func (s *Update_stmtContext) UPDATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUPDATE_, 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) SET_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSET_, 0)
}

func (s *Update_stmtContext) AllASSIGN() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserASSIGN)
}

func (s *Update_stmtContext) ASSIGN(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserASSIGN, 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) 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) AllColumn_name_list() []IColumn_name_listContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumn_name_listContext)(nil)).Elem())
	var tst = make([]IColumn_name_listContext, len(ts))

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

	return tst
}

func (s *Update_stmtContext) Column_name_list(i int) IColumn_name_listContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_name_listContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumn_name_listContext)
}

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) OR_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOR_, 0)
}

func (s *Update_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

func (s *Update_stmtContext) WHERE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWHERE_, 0)
}

func (s *Update_stmtContext) ROLLBACK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROLLBACK_, 0)
}

func (s *Update_stmtContext) ABORT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserABORT_, 0)
}

func (s *Update_stmtContext) REPLACE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserREPLACE_, 0)
}

func (s *Update_stmtContext) FAIL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFAIL_, 0)
}

func (s *Update_stmtContext) IGNORE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIGNORE_, 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.(SQLiteParserListener); ok {
		listenerT.EnterUpdate_stmt(s)
	}
}

func (s *Update_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitUpdate_stmt(s)
	}
}

func (p *SQLiteParser) Update_stmt() (localctx IUpdate_stmtContext) {
	this := p
	_ = this

	localctx = NewUpdate_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, SQLiteParserRULE_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(1516)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserWITH_ {
		{
			p.SetState(1515)
			p.With_clause()
		}

	}
	{
		p.SetState(1518)
		p.Match(SQLiteParserUPDATE_)
	}
	p.SetState(1521)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 217, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1519)
			p.Match(SQLiteParserOR_)
		}
		{
			p.SetState(1520)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SQLiteParserABORT_ || _la == SQLiteParserFAIL_ || _la == SQLiteParserIGNORE_ || _la == SQLiteParserREPLACE_ || _la == SQLiteParserROLLBACK_) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	}
	{
		p.SetState(1523)
		p.Qualified_table_name()
	}
	{
		p.SetState(1524)
		p.Match(SQLiteParserSET_)
	}
	p.SetState(1527)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 218, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1525)
			p.Column_name()
		}

	case 2:
		{
			p.SetState(1526)
			p.Column_name_list()
		}

	}
	{
		p.SetState(1529)
		p.Match(SQLiteParserASSIGN)
	}
	{
		p.SetState(1530)
		p.expr(0)
	}
	p.SetState(1541)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserCOMMA {
		{
			p.SetState(1531)
			p.Match(SQLiteParserCOMMA)
		}
		p.SetState(1534)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 219, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1532)
				p.Column_name()
			}

		case 2:
			{
				p.SetState(1533)
				p.Column_name_list()
			}

		}
		{
			p.SetState(1536)
			p.Match(SQLiteParserASSIGN)
		}
		{
			p.SetState(1537)
			p.expr(0)
		}

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

	if _la == SQLiteParserWHERE_ {
		{
			p.SetState(1544)
			p.Match(SQLiteParserWHERE_)
		}
		{
			p.SetState(1545)
			p.expr(0)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyColumn_name_listContext() *Column_name_listContext {
	var p = new(Column_name_listContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_column_name_list
	return p
}

func (*Column_name_listContext) IsColumn_name_listContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_column_name_list

	return p
}

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

func (s *Column_name_listContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Column_name_listContext) 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 *Column_name_listContext) 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 *Column_name_listContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

func (s *Column_name_listContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

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

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

func (s *Column_name_listContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterColumn_name_list(s)
	}
}

func (s *Column_name_listContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitColumn_name_list(s)
	}
}

func (p *SQLiteParser) Column_name_list() (localctx IColumn_name_listContext) {
	this := p
	_ = this

	localctx = NewColumn_name_listContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 104, SQLiteParserRULE_column_name_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)
			}
		}
	}()

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1548)
		p.Match(SQLiteParserOPEN_PAR)
	}
	{
		p.SetState(1549)
		p.Column_name()
	}
	p.SetState(1554)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserCOMMA {
		{
			p.SetState(1550)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(1551)
			p.Column_name()
		}

		p.SetState(1556)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(1557)
		p.Match(SQLiteParserCLOSE_PAR)
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_update_stmt_limited

	return p
}

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

func (s *Update_stmt_limitedContext) UPDATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUPDATE_, 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) SET_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSET_, 0)
}

func (s *Update_stmt_limitedContext) AllASSIGN() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserASSIGN)
}

func (s *Update_stmt_limitedContext) ASSIGN(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserASSIGN, 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) 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) AllColumn_name_list() []IColumn_name_listContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IColumn_name_listContext)(nil)).Elem())
	var tst = make([]IColumn_name_listContext, len(ts))

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

	return tst
}

func (s *Update_stmt_limitedContext) Column_name_list(i int) IColumn_name_listContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IColumn_name_listContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IColumn_name_listContext)
}

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) OR_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOR_, 0)
}

func (s *Update_stmt_limitedContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

func (s *Update_stmt_limitedContext) WHERE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWHERE_, 0)
}

func (s *Update_stmt_limitedContext) Limit_stmt() ILimit_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ILimit_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ILimit_stmtContext)
}

func (s *Update_stmt_limitedContext) ROLLBACK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROLLBACK_, 0)
}

func (s *Update_stmt_limitedContext) ABORT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserABORT_, 0)
}

func (s *Update_stmt_limitedContext) REPLACE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserREPLACE_, 0)
}

func (s *Update_stmt_limitedContext) FAIL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFAIL_, 0)
}

func (s *Update_stmt_limitedContext) IGNORE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIGNORE_, 0)
}

func (s *Update_stmt_limitedContext) Order_by_stmt() IOrder_by_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrder_by_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOrder_by_stmtContext)
}

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

func (s *Update_stmt_limitedContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitUpdate_stmt_limited(s)
	}
}

func (p *SQLiteParser) Update_stmt_limited() (localctx IUpdate_stmt_limitedContext) {
	this := p
	_ = this

	localctx = NewUpdate_stmt_limitedContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, SQLiteParserRULE_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(1560)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserWITH_ {
		{
			p.SetState(1559)
			p.With_clause()
		}

	}
	{
		p.SetState(1562)
		p.Match(SQLiteParserUPDATE_)
	}
	p.SetState(1565)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 224, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1563)
			p.Match(SQLiteParserOR_)
		}
		{
			p.SetState(1564)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SQLiteParserABORT_ || _la == SQLiteParserFAIL_ || _la == SQLiteParserIGNORE_ || _la == SQLiteParserREPLACE_ || _la == SQLiteParserROLLBACK_) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	}
	{
		p.SetState(1567)
		p.Qualified_table_name()
	}
	{
		p.SetState(1568)
		p.Match(SQLiteParserSET_)
	}
	p.SetState(1571)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 225, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1569)
			p.Column_name()
		}

	case 2:
		{
			p.SetState(1570)
			p.Column_name_list()
		}

	}
	{
		p.SetState(1573)
		p.Match(SQLiteParserASSIGN)
	}
	{
		p.SetState(1574)
		p.expr(0)
	}
	p.SetState(1585)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserCOMMA {
		{
			p.SetState(1575)
			p.Match(SQLiteParserCOMMA)
		}
		p.SetState(1578)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 226, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1576)
				p.Column_name()
			}

		case 2:
			{
				p.SetState(1577)
				p.Column_name_list()
			}

		}
		{
			p.SetState(1580)
			p.Match(SQLiteParserASSIGN)
		}
		{
			p.SetState(1581)
			p.expr(0)
		}

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

	if _la == SQLiteParserWHERE_ {
		{
			p.SetState(1588)
			p.Match(SQLiteParserWHERE_)
		}
		{
			p.SetState(1589)
			p.expr(0)
		}

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

	if _la == SQLiteParserLIMIT_ || _la == SQLiteParserORDER_ {
		p.SetState(1593)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserORDER_ {
			{
				p.SetState(1592)
				p.Order_by_stmt()
			}

		}
		{
			p.SetState(1595)
			p.Limit_stmt()
		}

	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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) Schema_name() ISchema_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISchema_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

func (s *Qualified_table_nameContext) DOT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDOT, 0)
}

func (s *Qualified_table_nameContext) AS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAS_, 0)
}

func (s *Qualified_table_nameContext) Alias() IAliasContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAliasContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAliasContext)
}

func (s *Qualified_table_nameContext) INDEXED_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINDEXED_, 0)
}

func (s *Qualified_table_nameContext) BY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBY_, 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) NOT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOT_, 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.(SQLiteParserListener); ok {
		listenerT.EnterQualified_table_name(s)
	}
}

func (s *Qualified_table_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitQualified_table_name(s)
	}
}

func (p *SQLiteParser) Qualified_table_name() (localctx IQualified_table_nameContext) {
	this := p
	_ = this

	localctx = NewQualified_table_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, SQLiteParserRULE_qualified_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(1601)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 231, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1598)
			p.Schema_name()
		}
		{
			p.SetState(1599)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(1603)
		p.Table_name()
	}
	p.SetState(1606)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserAS_ {
		{
			p.SetState(1604)
			p.Match(SQLiteParserAS_)
		}
		{
			p.SetState(1605)
			p.Alias()
		}

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

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserINDEXED_:
		{
			p.SetState(1608)
			p.Match(SQLiteParserINDEXED_)
		}
		{
			p.SetState(1609)
			p.Match(SQLiteParserBY_)
		}
		{
			p.SetState(1610)
			p.Index_name()
		}

	case SQLiteParserNOT_:
		{
			p.SetState(1611)
			p.Match(SQLiteParserNOT_)
		}
		{
			p.SetState(1612)
			p.Match(SQLiteParserINDEXED_)
		}

	case SQLiteParserEOF, SQLiteParserSCOL, SQLiteParserALTER_, SQLiteParserANALYZE_, SQLiteParserATTACH_, SQLiteParserBEGIN_, SQLiteParserCOMMIT_, SQLiteParserCREATE_, SQLiteParserDEFAULT_, SQLiteParserDELETE_, SQLiteParserDETACH_, SQLiteParserDROP_, SQLiteParserEND_, SQLiteParserEXPLAIN_, SQLiteParserINSERT_, SQLiteParserLIMIT_, SQLiteParserORDER_, SQLiteParserPRAGMA_, SQLiteParserREINDEX_, SQLiteParserRELEASE_, SQLiteParserREPLACE_, SQLiteParserROLLBACK_, SQLiteParserSAVEPOINT_, SQLiteParserSELECT_, SQLiteParserSET_, SQLiteParserUPDATE_, SQLiteParserVACUUM_, SQLiteParserVALUES_, SQLiteParserWHERE_, SQLiteParserWITH_:

	default:
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_vacuum_stmt

	return p
}

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

func (s *Vacuum_stmtContext) VACUUM_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserVACUUM_, 0)
}

func (s *Vacuum_stmtContext) Schema_name() ISchema_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISchema_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISchema_nameContext)
}

func (s *Vacuum_stmtContext) INTO_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINTO_, 0)
}

func (s *Vacuum_stmtContext) Filename() IFilenameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFilenameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFilenameContext)
}

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

func (s *Vacuum_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitVacuum_stmt(s)
	}
}

func (p *SQLiteParser) Vacuum_stmt() (localctx IVacuum_stmtContext) {
	this := p
	_ = this

	localctx = NewVacuum_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, SQLiteParserRULE_vacuum_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(1615)
		p.Match(SQLiteParserVACUUM_)
	}
	p.SetState(1617)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 234, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1616)
			p.Schema_name()
		}

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

	if _la == SQLiteParserINTO_ {
		{
			p.SetState(1619)
			p.Match(SQLiteParserINTO_)
		}
		{
			p.SetState(1620)
			p.Filename()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyFilter_clauseContext() *Filter_clauseContext {
	var p = new(Filter_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_filter_clause
	return p
}

func (*Filter_clauseContext) IsFilter_clauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_filter_clause

	return p
}

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

func (s *Filter_clauseContext) FILTER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFILTER_, 0)
}

func (s *Filter_clauseContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Filter_clauseContext) WHERE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWHERE_, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Filter_clauseContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

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

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

func (s *Filter_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterFilter_clause(s)
	}
}

func (s *Filter_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitFilter_clause(s)
	}
}

func (p *SQLiteParser) Filter_clause() (localctx IFilter_clauseContext) {
	this := p
	_ = this

	localctx = NewFilter_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 112, SQLiteParserRULE_filter_clause)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1623)
		p.Match(SQLiteParserFILTER_)
	}
	{
		p.SetState(1624)
		p.Match(SQLiteParserOPEN_PAR)
	}
	{
		p.SetState(1625)
		p.Match(SQLiteParserWHERE_)
	}
	{
		p.SetState(1626)
		p.expr(0)
	}
	{
		p.SetState(1627)
		p.Match(SQLiteParserCLOSE_PAR)
	}

	return localctx
}

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

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

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

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

func NewEmptyWindow_defnContext() *Window_defnContext {
	var p = new(Window_defnContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_window_defn
	return p
}

func (*Window_defnContext) IsWindow_defnContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_window_defn

	return p
}

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

func (s *Window_defnContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Window_defnContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

func (s *Window_defnContext) ORDER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserORDER_, 0)
}

func (s *Window_defnContext) AllBY_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserBY_)
}

func (s *Window_defnContext) BY_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserBY_, i)
}

func (s *Window_defnContext) 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 *Window_defnContext) 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 *Window_defnContext) Base_window_name() IBase_window_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBase_window_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBase_window_nameContext)
}

func (s *Window_defnContext) PARTITION_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPARTITION_, 0)
}

func (s *Window_defnContext) 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 *Window_defnContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Window_defnContext) Frame_spec() IFrame_specContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFrame_specContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFrame_specContext)
}

func (s *Window_defnContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

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

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

func (s *Window_defnContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterWindow_defn(s)
	}
}

func (s *Window_defnContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitWindow_defn(s)
	}
}

func (p *SQLiteParser) Window_defn() (localctx IWindow_defnContext) {
	this := p
	_ = this

	localctx = NewWindow_defnContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 114, SQLiteParserRULE_window_defn)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1629)
		p.Match(SQLiteParserOPEN_PAR)
	}
	p.SetState(1631)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 236, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1630)
			p.Base_window_name()
		}

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

	if _la == SQLiteParserPARTITION_ {
		{
			p.SetState(1633)
			p.Match(SQLiteParserPARTITION_)
		}
		{
			p.SetState(1634)
			p.Match(SQLiteParserBY_)
		}
		{
			p.SetState(1635)
			p.expr(0)
		}
		p.SetState(1640)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1636)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1637)
				p.expr(0)
			}

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

	}

	{
		p.SetState(1645)
		p.Match(SQLiteParserORDER_)
	}
	{
		p.SetState(1646)
		p.Match(SQLiteParserBY_)
	}
	{
		p.SetState(1647)
		p.Ordering_term()
	}
	p.SetState(1652)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserCOMMA {
		{
			p.SetState(1648)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(1649)
			p.Ordering_term()
		}

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

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

	if _la == SQLiteParserROWS_ || _la == SQLiteParserRANGE_ || _la == SQLiteParserGROUPS_ {
		{
			p.SetState(1655)
			p.Frame_spec()
		}

	}
	{
		p.SetState(1658)
		p.Match(SQLiteParserCLOSE_PAR)
	}

	return localctx
}

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

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

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

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

func NewEmptyOver_clauseContext() *Over_clauseContext {
	var p = new(Over_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_over_clause
	return p
}

func (*Over_clauseContext) IsOver_clauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_over_clause

	return p
}

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

func (s *Over_clauseContext) OVER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOVER_, 0)
}

func (s *Over_clauseContext) Window_name() IWindow_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWindow_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWindow_nameContext)
}

func (s *Over_clauseContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Over_clauseContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

func (s *Over_clauseContext) Base_window_name() IBase_window_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBase_window_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IBase_window_nameContext)
}

func (s *Over_clauseContext) PARTITION_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPARTITION_, 0)
}

func (s *Over_clauseContext) AllBY_() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserBY_)
}

func (s *Over_clauseContext) BY_(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserBY_, i)
}

func (s *Over_clauseContext) 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 *Over_clauseContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Over_clauseContext) ORDER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserORDER_, 0)
}

func (s *Over_clauseContext) 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 *Over_clauseContext) 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 *Over_clauseContext) Frame_spec() IFrame_specContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFrame_specContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFrame_specContext)
}

func (s *Over_clauseContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

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

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

func (s *Over_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterOver_clause(s)
	}
}

func (s *Over_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitOver_clause(s)
	}
}

func (p *SQLiteParser) Over_clause() (localctx IOver_clauseContext) {
	this := p
	_ = this

	localctx = NewOver_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, SQLiteParserRULE_over_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(1660)
		p.Match(SQLiteParserOVER_)
	}
	p.SetState(1694)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 247, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1661)
			p.Window_name()
		}

	case 2:
		{
			p.SetState(1662)
			p.Match(SQLiteParserOPEN_PAR)
		}
		p.SetState(1664)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 241, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1663)
				p.Base_window_name()
			}

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

		if _la == SQLiteParserPARTITION_ {
			{
				p.SetState(1666)
				p.Match(SQLiteParserPARTITION_)
			}
			{
				p.SetState(1667)
				p.Match(SQLiteParserBY_)
			}
			{
				p.SetState(1668)
				p.expr(0)
			}
			p.SetState(1673)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(1669)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(1670)
					p.expr(0)
				}

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

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

		if _la == SQLiteParserORDER_ {
			{
				p.SetState(1678)
				p.Match(SQLiteParserORDER_)
			}
			{
				p.SetState(1679)
				p.Match(SQLiteParserBY_)
			}
			{
				p.SetState(1680)
				p.Ordering_term()
			}
			p.SetState(1685)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(1681)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(1682)
					p.Ordering_term()
				}

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

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

		if _la == SQLiteParserROWS_ || _la == SQLiteParserRANGE_ || _la == SQLiteParserGROUPS_ {
			{
				p.SetState(1690)
				p.Frame_spec()
			}

		}
		{
			p.SetState(1693)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyFrame_specContext() *Frame_specContext {
	var p = new(Frame_specContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_frame_spec
	return p
}

func (*Frame_specContext) IsFrame_specContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_frame_spec

	return p
}

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

func (s *Frame_specContext) Frame_clause() IFrame_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFrame_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFrame_clauseContext)
}

func (s *Frame_specContext) EXCLUDE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXCLUDE_, 0)
}

func (s *Frame_specContext) CURRENT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCURRENT_, 0)
}

func (s *Frame_specContext) ROW_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROW_, 0)
}

func (s *Frame_specContext) GROUP_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserGROUP_, 0)
}

func (s *Frame_specContext) TIES_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTIES_, 0)
}

func (s *Frame_specContext) NO_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNO_, 0)
}

func (s *Frame_specContext) OTHERS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOTHERS_, 0)
}

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

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

func (s *Frame_specContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterFrame_spec(s)
	}
}

func (s *Frame_specContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitFrame_spec(s)
	}
}

func (p *SQLiteParser) Frame_spec() (localctx IFrame_specContext) {
	this := p
	_ = this

	localctx = NewFrame_specContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, SQLiteParserRULE_frame_spec)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1696)
		p.Frame_clause()
	}
	p.SetState(1704)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserEXCLUDE_:
		{
			p.SetState(1697)
			p.Match(SQLiteParserEXCLUDE_)
		}

		{
			p.SetState(1698)
			p.Match(SQLiteParserNO_)
		}
		{
			p.SetState(1699)
			p.Match(SQLiteParserOTHERS_)
		}

	case SQLiteParserCURRENT_:
		{
			p.SetState(1700)
			p.Match(SQLiteParserCURRENT_)
		}
		{
			p.SetState(1701)
			p.Match(SQLiteParserROW_)
		}

	case SQLiteParserGROUP_:
		{
			p.SetState(1702)
			p.Match(SQLiteParserGROUP_)
		}

	case SQLiteParserTIES_:
		{
			p.SetState(1703)
			p.Match(SQLiteParserTIES_)
		}

	case SQLiteParserCLOSE_PAR:

	default:
	}

	return localctx
}

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

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

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

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

func NewEmptyFrame_clauseContext() *Frame_clauseContext {
	var p = new(Frame_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_frame_clause
	return p
}

func (*Frame_clauseContext) IsFrame_clauseContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_frame_clause

	return p
}

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

func (s *Frame_clauseContext) RANGE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRANGE_, 0)
}

func (s *Frame_clauseContext) ROWS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROWS_, 0)
}

func (s *Frame_clauseContext) GROUPS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserGROUPS_, 0)
}

func (s *Frame_clauseContext) Frame_single() IFrame_singleContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFrame_singleContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFrame_singleContext)
}

func (s *Frame_clauseContext) BETWEEN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBETWEEN_, 0)
}

func (s *Frame_clauseContext) Frame_left() IFrame_leftContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFrame_leftContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFrame_leftContext)
}

func (s *Frame_clauseContext) AND_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAND_, 0)
}

func (s *Frame_clauseContext) Frame_right() IFrame_rightContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFrame_rightContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFrame_rightContext)
}

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

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

func (s *Frame_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterFrame_clause(s)
	}
}

func (s *Frame_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitFrame_clause(s)
	}
}

func (p *SQLiteParser) Frame_clause() (localctx IFrame_clauseContext) {
	this := p
	_ = this

	localctx = NewFrame_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, SQLiteParserRULE_frame_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(1706)
		_la = p.GetTokenStream().LA(1)

		if !(_la == SQLiteParserROWS_ || _la == SQLiteParserRANGE_ || _la == SQLiteParserGROUPS_) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(1713)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 249, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1707)
			p.Frame_single()
		}

	case 2:
		{
			p.SetState(1708)
			p.Match(SQLiteParserBETWEEN_)
		}
		{
			p.SetState(1709)
			p.Frame_left()
		}
		{
			p.SetState(1710)
			p.Match(SQLiteParserAND_)
		}
		{
			p.SetState(1711)
			p.Frame_right()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptySimple_function_invocationContext() *Simple_function_invocationContext {
	var p = new(Simple_function_invocationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_simple_function_invocation
	return p
}

func (*Simple_function_invocationContext) IsSimple_function_invocationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_simple_function_invocation

	return p
}

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

func (s *Simple_function_invocationContext) Simple_func() ISimple_funcContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISimple_funcContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISimple_funcContext)
}

func (s *Simple_function_invocationContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Simple_function_invocationContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

func (s *Simple_function_invocationContext) 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_function_invocationContext) 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_function_invocationContext) STAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSTAR, 0)
}

func (s *Simple_function_invocationContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

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

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

func (s *Simple_function_invocationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterSimple_function_invocation(s)
	}
}

func (s *Simple_function_invocationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitSimple_function_invocation(s)
	}
}

func (p *SQLiteParser) Simple_function_invocation() (localctx ISimple_function_invocationContext) {
	this := p
	_ = this

	localctx = NewSimple_function_invocationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 122, SQLiteParserRULE_simple_function_invocation)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1715)
		p.Simple_func()
	}
	{
		p.SetState(1716)
		p.Match(SQLiteParserOPEN_PAR)
	}
	p.SetState(1726)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserOPEN_PAR, SQLiteParserPLUS, SQLiteParserMINUS, SQLiteParserTILDE, SQLiteParserABORT_, SQLiteParserACTION_, SQLiteParserADD_, SQLiteParserAFTER_, SQLiteParserALL_, SQLiteParserALTER_, SQLiteParserANALYZE_, SQLiteParserAND_, SQLiteParserAS_, SQLiteParserASC_, SQLiteParserATTACH_, SQLiteParserAUTOINCREMENT_, SQLiteParserBEFORE_, SQLiteParserBEGIN_, SQLiteParserBETWEEN_, SQLiteParserBY_, SQLiteParserCASCADE_, SQLiteParserCASE_, SQLiteParserCAST_, SQLiteParserCHECK_, SQLiteParserCOLLATE_, SQLiteParserCOLUMN_, SQLiteParserCOMMIT_, SQLiteParserCONFLICT_, SQLiteParserCONSTRAINT_, SQLiteParserCREATE_, SQLiteParserCROSS_, SQLiteParserCURRENT_DATE_, SQLiteParserCURRENT_TIME_, SQLiteParserCURRENT_TIMESTAMP_, SQLiteParserDATABASE_, SQLiteParserDEFAULT_, SQLiteParserDEFERRABLE_, SQLiteParserDEFERRED_, SQLiteParserDELETE_, SQLiteParserDESC_, SQLiteParserDETACH_, SQLiteParserDISTINCT_, SQLiteParserDROP_, SQLiteParserEACH_, SQLiteParserELSE_, SQLiteParserEND_, SQLiteParserESCAPE_, SQLiteParserEXCEPT_, SQLiteParserEXCLUSIVE_, SQLiteParserEXISTS_, SQLiteParserEXPLAIN_, SQLiteParserFAIL_, SQLiteParserFOR_, SQLiteParserFOREIGN_, SQLiteParserFROM_, SQLiteParserFULL_, SQLiteParserGLOB_, SQLiteParserGROUP_, SQLiteParserHAVING_, SQLiteParserIF_, SQLiteParserIGNORE_, SQLiteParserIMMEDIATE_, SQLiteParserIN_, SQLiteParserINDEX_, SQLiteParserINDEXED_, SQLiteParserINITIALLY_, SQLiteParserINNER_, SQLiteParserINSERT_, SQLiteParserINSTEAD_, SQLiteParserINTERSECT_, SQLiteParserINTO_, SQLiteParserIS_, SQLiteParserISNULL_, SQLiteParserJOIN_, SQLiteParserKEY_, SQLiteParserLEFT_, SQLiteParserLIKE_, SQLiteParserLIMIT_, SQLiteParserMATCH_, SQLiteParserNATURAL_, SQLiteParserNO_, SQLiteParserNOT_, SQLiteParserNOTNULL_, SQLiteParserNULL_, SQLiteParserOF_, SQLiteParserOFFSET_, SQLiteParserON_, SQLiteParserOR_, SQLiteParserORDER_, SQLiteParserOUTER_, SQLiteParserPLAN_, SQLiteParserPRAGMA_, SQLiteParserPRIMARY_, SQLiteParserQUERY_, SQLiteParserRAISE_, SQLiteParserRECURSIVE_, SQLiteParserREFERENCES_, SQLiteParserREGEXP_, SQLiteParserREINDEX_, SQLiteParserRELEASE_, SQLiteParserRENAME_, SQLiteParserREPLACE_, SQLiteParserRESTRICT_, SQLiteParserRIGHT_, SQLiteParserROLLBACK_, SQLiteParserROW_, SQLiteParserROWS_, SQLiteParserSAVEPOINT_, SQLiteParserSELECT_, SQLiteParserSET_, SQLiteParserTABLE_, SQLiteParserTEMP_, SQLiteParserTEMPORARY_, SQLiteParserTHEN_, SQLiteParserTO_, SQLiteParserTRANSACTION_, SQLiteParserTRIGGER_, SQLiteParserUNION_, SQLiteParserUNIQUE_, SQLiteParserUPDATE_, SQLiteParserUSING_, SQLiteParserVACUUM_, SQLiteParserVALUES_, SQLiteParserVIEW_, SQLiteParserVIRTUAL_, SQLiteParserWHEN_, SQLiteParserWHERE_, SQLiteParserWITH_, SQLiteParserWITHOUT_, SQLiteParserFIRST_VALUE_, SQLiteParserOVER_, SQLiteParserPARTITION_, SQLiteParserRANGE_, SQLiteParserPRECEDING_, SQLiteParserUNBOUNDED_, SQLiteParserCURRENT_, SQLiteParserFOLLOWING_, SQLiteParserCUME_DIST_, SQLiteParserDENSE_RANK_, SQLiteParserLAG_, SQLiteParserLAST_VALUE_, SQLiteParserLEAD_, SQLiteParserNTH_VALUE_, SQLiteParserNTILE_, SQLiteParserPERCENT_RANK_, SQLiteParserRANK_, SQLiteParserROW_NUMBER_, SQLiteParserGENERATED_, SQLiteParserALWAYS_, SQLiteParserSTORED_, SQLiteParserTRUE_, SQLiteParserFALSE_, SQLiteParserWINDOW_, SQLiteParserNULLS_, SQLiteParserFIRST_, SQLiteParserLAST_, SQLiteParserFILTER_, SQLiteParserGROUPS_, SQLiteParserEXCLUDE_, SQLiteParserIDENTIFIER, SQLiteParserNUMERIC_LITERAL, SQLiteParserBIND_PARAMETER, SQLiteParserSTRING_LITERAL, SQLiteParserBLOB_LITERAL:
		{
			p.SetState(1717)
			p.expr(0)
		}
		p.SetState(1722)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1718)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1719)
				p.expr(0)
			}

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

	case SQLiteParserSTAR:
		{
			p.SetState(1725)
			p.Match(SQLiteParserSTAR)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(1728)
		p.Match(SQLiteParserCLOSE_PAR)
	}

	return localctx
}

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

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

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

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

func NewEmptyAggregate_function_invocationContext() *Aggregate_function_invocationContext {
	var p = new(Aggregate_function_invocationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_aggregate_function_invocation
	return p
}

func (*Aggregate_function_invocationContext) IsAggregate_function_invocationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_aggregate_function_invocation

	return p
}

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

func (s *Aggregate_function_invocationContext) Aggregate_func() IAggregate_funcContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAggregate_funcContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAggregate_funcContext)
}

func (s *Aggregate_function_invocationContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Aggregate_function_invocationContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

func (s *Aggregate_function_invocationContext) 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 *Aggregate_function_invocationContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Aggregate_function_invocationContext) STAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSTAR, 0)
}

func (s *Aggregate_function_invocationContext) Filter_clause() IFilter_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFilter_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFilter_clauseContext)
}

func (s *Aggregate_function_invocationContext) DISTINCT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDISTINCT_, 0)
}

func (s *Aggregate_function_invocationContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

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

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

func (s *Aggregate_function_invocationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterAggregate_function_invocation(s)
	}
}

func (s *Aggregate_function_invocationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitAggregate_function_invocation(s)
	}
}

func (p *SQLiteParser) Aggregate_function_invocation() (localctx IAggregate_function_invocationContext) {
	this := p
	_ = this

	localctx = NewAggregate_function_invocationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 124, SQLiteParserRULE_aggregate_function_invocation)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1730)
		p.Aggregate_func()
	}
	{
		p.SetState(1731)
		p.Match(SQLiteParserOPEN_PAR)
	}
	p.SetState(1744)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserOPEN_PAR, SQLiteParserPLUS, SQLiteParserMINUS, SQLiteParserTILDE, SQLiteParserABORT_, SQLiteParserACTION_, SQLiteParserADD_, SQLiteParserAFTER_, SQLiteParserALL_, SQLiteParserALTER_, SQLiteParserANALYZE_, SQLiteParserAND_, SQLiteParserAS_, SQLiteParserASC_, SQLiteParserATTACH_, SQLiteParserAUTOINCREMENT_, SQLiteParserBEFORE_, SQLiteParserBEGIN_, SQLiteParserBETWEEN_, SQLiteParserBY_, SQLiteParserCASCADE_, SQLiteParserCASE_, SQLiteParserCAST_, SQLiteParserCHECK_, SQLiteParserCOLLATE_, SQLiteParserCOLUMN_, SQLiteParserCOMMIT_, SQLiteParserCONFLICT_, SQLiteParserCONSTRAINT_, SQLiteParserCREATE_, SQLiteParserCROSS_, SQLiteParserCURRENT_DATE_, SQLiteParserCURRENT_TIME_, SQLiteParserCURRENT_TIMESTAMP_, SQLiteParserDATABASE_, SQLiteParserDEFAULT_, SQLiteParserDEFERRABLE_, SQLiteParserDEFERRED_, SQLiteParserDELETE_, SQLiteParserDESC_, SQLiteParserDETACH_, SQLiteParserDISTINCT_, SQLiteParserDROP_, SQLiteParserEACH_, SQLiteParserELSE_, SQLiteParserEND_, SQLiteParserESCAPE_, SQLiteParserEXCEPT_, SQLiteParserEXCLUSIVE_, SQLiteParserEXISTS_, SQLiteParserEXPLAIN_, SQLiteParserFAIL_, SQLiteParserFOR_, SQLiteParserFOREIGN_, SQLiteParserFROM_, SQLiteParserFULL_, SQLiteParserGLOB_, SQLiteParserGROUP_, SQLiteParserHAVING_, SQLiteParserIF_, SQLiteParserIGNORE_, SQLiteParserIMMEDIATE_, SQLiteParserIN_, SQLiteParserINDEX_, SQLiteParserINDEXED_, SQLiteParserINITIALLY_, SQLiteParserINNER_, SQLiteParserINSERT_, SQLiteParserINSTEAD_, SQLiteParserINTERSECT_, SQLiteParserINTO_, SQLiteParserIS_, SQLiteParserISNULL_, SQLiteParserJOIN_, SQLiteParserKEY_, SQLiteParserLEFT_, SQLiteParserLIKE_, SQLiteParserLIMIT_, SQLiteParserMATCH_, SQLiteParserNATURAL_, SQLiteParserNO_, SQLiteParserNOT_, SQLiteParserNOTNULL_, SQLiteParserNULL_, SQLiteParserOF_, SQLiteParserOFFSET_, SQLiteParserON_, SQLiteParserOR_, SQLiteParserORDER_, SQLiteParserOUTER_, SQLiteParserPLAN_, SQLiteParserPRAGMA_, SQLiteParserPRIMARY_, SQLiteParserQUERY_, SQLiteParserRAISE_, SQLiteParserRECURSIVE_, SQLiteParserREFERENCES_, SQLiteParserREGEXP_, SQLiteParserREINDEX_, SQLiteParserRELEASE_, SQLiteParserRENAME_, SQLiteParserREPLACE_, SQLiteParserRESTRICT_, SQLiteParserRIGHT_, SQLiteParserROLLBACK_, SQLiteParserROW_, SQLiteParserROWS_, SQLiteParserSAVEPOINT_, SQLiteParserSELECT_, SQLiteParserSET_, SQLiteParserTABLE_, SQLiteParserTEMP_, SQLiteParserTEMPORARY_, SQLiteParserTHEN_, SQLiteParserTO_, SQLiteParserTRANSACTION_, SQLiteParserTRIGGER_, SQLiteParserUNION_, SQLiteParserUNIQUE_, SQLiteParserUPDATE_, SQLiteParserUSING_, SQLiteParserVACUUM_, SQLiteParserVALUES_, SQLiteParserVIEW_, SQLiteParserVIRTUAL_, SQLiteParserWHEN_, SQLiteParserWHERE_, SQLiteParserWITH_, SQLiteParserWITHOUT_, SQLiteParserFIRST_VALUE_, SQLiteParserOVER_, SQLiteParserPARTITION_, SQLiteParserRANGE_, SQLiteParserPRECEDING_, SQLiteParserUNBOUNDED_, SQLiteParserCURRENT_, SQLiteParserFOLLOWING_, SQLiteParserCUME_DIST_, SQLiteParserDENSE_RANK_, SQLiteParserLAG_, SQLiteParserLAST_VALUE_, SQLiteParserLEAD_, SQLiteParserNTH_VALUE_, SQLiteParserNTILE_, SQLiteParserPERCENT_RANK_, SQLiteParserRANK_, SQLiteParserROW_NUMBER_, SQLiteParserGENERATED_, SQLiteParserALWAYS_, SQLiteParserSTORED_, SQLiteParserTRUE_, SQLiteParserFALSE_, SQLiteParserWINDOW_, SQLiteParserNULLS_, SQLiteParserFIRST_, SQLiteParserLAST_, SQLiteParserFILTER_, SQLiteParserGROUPS_, SQLiteParserEXCLUDE_, SQLiteParserIDENTIFIER, SQLiteParserNUMERIC_LITERAL, SQLiteParserBIND_PARAMETER, SQLiteParserSTRING_LITERAL, SQLiteParserBLOB_LITERAL:
		p.SetState(1733)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 252, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1732)
				p.Match(SQLiteParserDISTINCT_)
			}

		}
		{
			p.SetState(1735)
			p.expr(0)
		}
		p.SetState(1740)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1736)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1737)
				p.expr(0)
			}

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

	case SQLiteParserSTAR:
		{
			p.SetState(1743)
			p.Match(SQLiteParserSTAR)
		}

	case SQLiteParserCLOSE_PAR:

	default:
	}
	{
		p.SetState(1746)
		p.Match(SQLiteParserCLOSE_PAR)
	}
	p.SetState(1748)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserFILTER_ {
		{
			p.SetState(1747)
			p.Filter_clause()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyWindow_function_invocationContext() *Window_function_invocationContext {
	var p = new(Window_function_invocationContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_window_function_invocation
	return p
}

func (*Window_function_invocationContext) IsWindow_function_invocationContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_window_function_invocation

	return p
}

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

func (s *Window_function_invocationContext) Window_function() IWindow_functionContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWindow_functionContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWindow_functionContext)
}

func (s *Window_function_invocationContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Window_function_invocationContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

func (s *Window_function_invocationContext) OVER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOVER_, 0)
}

func (s *Window_function_invocationContext) Window_defn() IWindow_defnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWindow_defnContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWindow_defnContext)
}

func (s *Window_function_invocationContext) Window_name() IWindow_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWindow_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWindow_nameContext)
}

func (s *Window_function_invocationContext) 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 *Window_function_invocationContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Window_function_invocationContext) STAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSTAR, 0)
}

func (s *Window_function_invocationContext) Filter_clause() IFilter_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFilter_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFilter_clauseContext)
}

func (s *Window_function_invocationContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

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

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

func (s *Window_function_invocationContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterWindow_function_invocation(s)
	}
}

func (s *Window_function_invocationContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitWindow_function_invocation(s)
	}
}

func (p *SQLiteParser) Window_function_invocation() (localctx IWindow_function_invocationContext) {
	this := p
	_ = this

	localctx = NewWindow_function_invocationContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 126, SQLiteParserRULE_window_function_invocation)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1750)
		p.Window_function()
	}
	{
		p.SetState(1751)
		p.Match(SQLiteParserOPEN_PAR)
	}
	p.SetState(1761)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserOPEN_PAR, SQLiteParserPLUS, SQLiteParserMINUS, SQLiteParserTILDE, SQLiteParserABORT_, SQLiteParserACTION_, SQLiteParserADD_, SQLiteParserAFTER_, SQLiteParserALL_, SQLiteParserALTER_, SQLiteParserANALYZE_, SQLiteParserAND_, SQLiteParserAS_, SQLiteParserASC_, SQLiteParserATTACH_, SQLiteParserAUTOINCREMENT_, SQLiteParserBEFORE_, SQLiteParserBEGIN_, SQLiteParserBETWEEN_, SQLiteParserBY_, SQLiteParserCASCADE_, SQLiteParserCASE_, SQLiteParserCAST_, SQLiteParserCHECK_, SQLiteParserCOLLATE_, SQLiteParserCOLUMN_, SQLiteParserCOMMIT_, SQLiteParserCONFLICT_, SQLiteParserCONSTRAINT_, SQLiteParserCREATE_, SQLiteParserCROSS_, SQLiteParserCURRENT_DATE_, SQLiteParserCURRENT_TIME_, SQLiteParserCURRENT_TIMESTAMP_, SQLiteParserDATABASE_, SQLiteParserDEFAULT_, SQLiteParserDEFERRABLE_, SQLiteParserDEFERRED_, SQLiteParserDELETE_, SQLiteParserDESC_, SQLiteParserDETACH_, SQLiteParserDISTINCT_, SQLiteParserDROP_, SQLiteParserEACH_, SQLiteParserELSE_, SQLiteParserEND_, SQLiteParserESCAPE_, SQLiteParserEXCEPT_, SQLiteParserEXCLUSIVE_, SQLiteParserEXISTS_, SQLiteParserEXPLAIN_, SQLiteParserFAIL_, SQLiteParserFOR_, SQLiteParserFOREIGN_, SQLiteParserFROM_, SQLiteParserFULL_, SQLiteParserGLOB_, SQLiteParserGROUP_, SQLiteParserHAVING_, SQLiteParserIF_, SQLiteParserIGNORE_, SQLiteParserIMMEDIATE_, SQLiteParserIN_, SQLiteParserINDEX_, SQLiteParserINDEXED_, SQLiteParserINITIALLY_, SQLiteParserINNER_, SQLiteParserINSERT_, SQLiteParserINSTEAD_, SQLiteParserINTERSECT_, SQLiteParserINTO_, SQLiteParserIS_, SQLiteParserISNULL_, SQLiteParserJOIN_, SQLiteParserKEY_, SQLiteParserLEFT_, SQLiteParserLIKE_, SQLiteParserLIMIT_, SQLiteParserMATCH_, SQLiteParserNATURAL_, SQLiteParserNO_, SQLiteParserNOT_, SQLiteParserNOTNULL_, SQLiteParserNULL_, SQLiteParserOF_, SQLiteParserOFFSET_, SQLiteParserON_, SQLiteParserOR_, SQLiteParserORDER_, SQLiteParserOUTER_, SQLiteParserPLAN_, SQLiteParserPRAGMA_, SQLiteParserPRIMARY_, SQLiteParserQUERY_, SQLiteParserRAISE_, SQLiteParserRECURSIVE_, SQLiteParserREFERENCES_, SQLiteParserREGEXP_, SQLiteParserREINDEX_, SQLiteParserRELEASE_, SQLiteParserRENAME_, SQLiteParserREPLACE_, SQLiteParserRESTRICT_, SQLiteParserRIGHT_, SQLiteParserROLLBACK_, SQLiteParserROW_, SQLiteParserROWS_, SQLiteParserSAVEPOINT_, SQLiteParserSELECT_, SQLiteParserSET_, SQLiteParserTABLE_, SQLiteParserTEMP_, SQLiteParserTEMPORARY_, SQLiteParserTHEN_, SQLiteParserTO_, SQLiteParserTRANSACTION_, SQLiteParserTRIGGER_, SQLiteParserUNION_, SQLiteParserUNIQUE_, SQLiteParserUPDATE_, SQLiteParserUSING_, SQLiteParserVACUUM_, SQLiteParserVALUES_, SQLiteParserVIEW_, SQLiteParserVIRTUAL_, SQLiteParserWHEN_, SQLiteParserWHERE_, SQLiteParserWITH_, SQLiteParserWITHOUT_, SQLiteParserFIRST_VALUE_, SQLiteParserOVER_, SQLiteParserPARTITION_, SQLiteParserRANGE_, SQLiteParserPRECEDING_, SQLiteParserUNBOUNDED_, SQLiteParserCURRENT_, SQLiteParserFOLLOWING_, SQLiteParserCUME_DIST_, SQLiteParserDENSE_RANK_, SQLiteParserLAG_, SQLiteParserLAST_VALUE_, SQLiteParserLEAD_, SQLiteParserNTH_VALUE_, SQLiteParserNTILE_, SQLiteParserPERCENT_RANK_, SQLiteParserRANK_, SQLiteParserROW_NUMBER_, SQLiteParserGENERATED_, SQLiteParserALWAYS_, SQLiteParserSTORED_, SQLiteParserTRUE_, SQLiteParserFALSE_, SQLiteParserWINDOW_, SQLiteParserNULLS_, SQLiteParserFIRST_, SQLiteParserLAST_, SQLiteParserFILTER_, SQLiteParserGROUPS_, SQLiteParserEXCLUDE_, SQLiteParserIDENTIFIER, SQLiteParserNUMERIC_LITERAL, SQLiteParserBIND_PARAMETER, SQLiteParserSTRING_LITERAL, SQLiteParserBLOB_LITERAL:
		{
			p.SetState(1752)
			p.expr(0)
		}
		p.SetState(1757)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1753)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1754)
				p.expr(0)
			}

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

	case SQLiteParserSTAR:
		{
			p.SetState(1760)
			p.Match(SQLiteParserSTAR)
		}

	case SQLiteParserCLOSE_PAR:

	default:
	}
	{
		p.SetState(1763)
		p.Match(SQLiteParserCLOSE_PAR)
	}
	p.SetState(1765)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserFILTER_ {
		{
			p.SetState(1764)
			p.Filter_clause()
		}

	}
	{
		p.SetState(1767)
		p.Match(SQLiteParserOVER_)
	}
	p.SetState(1770)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 259, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1768)
			p.Window_defn()
		}

	case 2:
		{
			p.SetState(1769)
			p.Window_name()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyCommon_table_stmtContext() *Common_table_stmtContext {
	var p = new(Common_table_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_common_table_stmt
	return p
}

func (*Common_table_stmtContext) IsCommon_table_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_common_table_stmt

	return p
}

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

func (s *Common_table_stmtContext) WITH_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWITH_, 0)
}

func (s *Common_table_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 *Common_table_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 *Common_table_stmtContext) RECURSIVE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRECURSIVE_, 0)
}

func (s *Common_table_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

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

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

func (s *Common_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterCommon_table_stmt(s)
	}
}

func (s *Common_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitCommon_table_stmt(s)
	}
}

func (p *SQLiteParser) Common_table_stmt() (localctx ICommon_table_stmtContext) {
	this := p
	_ = this

	localctx = NewCommon_table_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 128, SQLiteParserRULE_common_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(1772)
		p.Match(SQLiteParserWITH_)
	}
	p.SetState(1774)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 260, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1773)
			p.Match(SQLiteParserRECURSIVE_)
		}

	}
	{
		p.SetState(1776)
		p.Common_table_expression()
	}
	p.SetState(1781)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserCOMMA {
		{
			p.SetState(1777)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(1778)
			p.Common_table_expression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyOrder_by_stmtContext() *Order_by_stmtContext {
	var p = new(Order_by_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_order_by_stmt
	return p
}

func (*Order_by_stmtContext) IsOrder_by_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_order_by_stmt

	return p
}

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

func (s *Order_by_stmtContext) ORDER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserORDER_, 0)
}

func (s *Order_by_stmtContext) BY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBY_, 0)
}

func (s *Order_by_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 *Order_by_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 *Order_by_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

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

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

func (s *Order_by_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterOrder_by_stmt(s)
	}
}

func (s *Order_by_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitOrder_by_stmt(s)
	}
}

func (p *SQLiteParser) Order_by_stmt() (localctx IOrder_by_stmtContext) {
	this := p
	_ = this

	localctx = NewOrder_by_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 130, SQLiteParserRULE_order_by_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(1784)
		p.Match(SQLiteParserORDER_)
	}
	{
		p.SetState(1785)
		p.Match(SQLiteParserBY_)
	}
	{
		p.SetState(1786)
		p.Ordering_term()
	}
	p.SetState(1791)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserCOMMA {
		{
			p.SetState(1787)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(1788)
			p.Ordering_term()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyLimit_stmtContext() *Limit_stmtContext {
	var p = new(Limit_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_limit_stmt
	return p
}

func (*Limit_stmtContext) IsLimit_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_limit_stmt

	return p
}

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

func (s *Limit_stmtContext) LIMIT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLIMIT_, 0)
}

func (s *Limit_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 *Limit_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 *Limit_stmtContext) OFFSET_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOFFSET_, 0)
}

func (s *Limit_stmtContext) COMMA() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMA, 0)
}

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

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

func (s *Limit_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterLimit_stmt(s)
	}
}

func (s *Limit_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitLimit_stmt(s)
	}
}

func (p *SQLiteParser) Limit_stmt() (localctx ILimit_stmtContext) {
	this := p
	_ = this

	localctx = NewLimit_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 132, SQLiteParserRULE_limit_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(1794)
		p.Match(SQLiteParserLIMIT_)
	}
	{
		p.SetState(1795)
		p.expr(0)
	}
	p.SetState(1798)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserCOMMA || _la == SQLiteParserOFFSET_ {
		{
			p.SetState(1796)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SQLiteParserCOMMA || _la == SQLiteParserOFFSET_) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1797)
			p.expr(0)
		}

	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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) COLLATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOLLATE_, 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) Asc_desc() IAsc_descContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAsc_descContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IAsc_descContext)
}

func (s *Ordering_termContext) NULLS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNULLS_, 0)
}

func (s *Ordering_termContext) FIRST_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFIRST_, 0)
}

func (s *Ordering_termContext) LAST_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLAST_, 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.(SQLiteParserListener); ok {
		listenerT.EnterOrdering_term(s)
	}
}

func (s *Ordering_termContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitOrdering_term(s)
	}
}

func (p *SQLiteParser) Ordering_term() (localctx IOrdering_termContext) {
	this := p
	_ = this

	localctx = NewOrdering_termContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 134, SQLiteParserRULE_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(1800)
		p.expr(0)
	}
	p.SetState(1803)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserCOLLATE_ {
		{
			p.SetState(1801)
			p.Match(SQLiteParserCOLLATE_)
		}
		{
			p.SetState(1802)
			p.Collation_name()
		}

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

	if _la == SQLiteParserASC_ || _la == SQLiteParserDESC_ {
		{
			p.SetState(1805)
			p.Asc_desc()
		}

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

	if _la == SQLiteParserNULLS_ {
		{
			p.SetState(1808)
			p.Match(SQLiteParserNULLS_)
		}
		{
			p.SetState(1809)
			_la = p.GetTokenStream().LA(1)

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

	}

	return localctx
}

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

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

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

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

func NewEmptyAsc_descContext() *Asc_descContext {
	var p = new(Asc_descContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_asc_desc
	return p
}

func (*Asc_descContext) IsAsc_descContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_asc_desc

	return p
}

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

func (s *Asc_descContext) ASC_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserASC_, 0)
}

func (s *Asc_descContext) DESC_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDESC_, 0)
}

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

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

func (s *Asc_descContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterAsc_desc(s)
	}
}

func (s *Asc_descContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitAsc_desc(s)
	}
}

func (p *SQLiteParser) Asc_desc() (localctx IAsc_descContext) {
	this := p
	_ = this

	localctx = NewAsc_descContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 136, SQLiteParserRULE_asc_desc)
	var _la int

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

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

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

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

	return localctx
}

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

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

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

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

func NewEmptyFrame_leftContext() *Frame_leftContext {
	var p = new(Frame_leftContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_frame_left
	return p
}

func (*Frame_leftContext) IsFrame_leftContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_frame_left

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Frame_leftContext) PRECEDING_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPRECEDING_, 0)
}

func (s *Frame_leftContext) FOLLOWING_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFOLLOWING_, 0)
}

func (s *Frame_leftContext) CURRENT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCURRENT_, 0)
}

func (s *Frame_leftContext) ROW_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROW_, 0)
}

func (s *Frame_leftContext) UNBOUNDED_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUNBOUNDED_, 0)
}

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

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

func (s *Frame_leftContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterFrame_left(s)
	}
}

func (s *Frame_leftContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitFrame_left(s)
	}
}

func (p *SQLiteParser) Frame_left() (localctx IFrame_leftContext) {
	this := p
	_ = this

	localctx = NewFrame_leftContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 138, SQLiteParserRULE_frame_left)

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

	defer func() {
		if err := recover(); err != nil {
			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(1824)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 267, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1814)
			p.expr(0)
		}
		{
			p.SetState(1815)
			p.Match(SQLiteParserPRECEDING_)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1817)
			p.expr(0)
		}
		{
			p.SetState(1818)
			p.Match(SQLiteParserFOLLOWING_)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1820)
			p.Match(SQLiteParserCURRENT_)
		}
		{
			p.SetState(1821)
			p.Match(SQLiteParserROW_)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1822)
			p.Match(SQLiteParserUNBOUNDED_)
		}
		{
			p.SetState(1823)
			p.Match(SQLiteParserPRECEDING_)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyFrame_rightContext() *Frame_rightContext {
	var p = new(Frame_rightContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_frame_right
	return p
}

func (*Frame_rightContext) IsFrame_rightContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_frame_right

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Frame_rightContext) PRECEDING_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPRECEDING_, 0)
}

func (s *Frame_rightContext) FOLLOWING_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFOLLOWING_, 0)
}

func (s *Frame_rightContext) CURRENT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCURRENT_, 0)
}

func (s *Frame_rightContext) ROW_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROW_, 0)
}

func (s *Frame_rightContext) UNBOUNDED_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUNBOUNDED_, 0)
}

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

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

func (s *Frame_rightContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterFrame_right(s)
	}
}

func (s *Frame_rightContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitFrame_right(s)
	}
}

func (p *SQLiteParser) Frame_right() (localctx IFrame_rightContext) {
	this := p
	_ = this

	localctx = NewFrame_rightContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 140, SQLiteParserRULE_frame_right)

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

	defer func() {
		if err := recover(); err != nil {
			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(1836)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 268, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1826)
			p.expr(0)
		}
		{
			p.SetState(1827)
			p.Match(SQLiteParserPRECEDING_)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1829)
			p.expr(0)
		}
		{
			p.SetState(1830)
			p.Match(SQLiteParserFOLLOWING_)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1832)
			p.Match(SQLiteParserCURRENT_)
		}
		{
			p.SetState(1833)
			p.Match(SQLiteParserROW_)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1834)
			p.Match(SQLiteParserUNBOUNDED_)
		}
		{
			p.SetState(1835)
			p.Match(SQLiteParserFOLLOWING_)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyFrame_singleContext() *Frame_singleContext {
	var p = new(Frame_singleContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_frame_single
	return p
}

func (*Frame_singleContext) IsFrame_singleContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_frame_single

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Frame_singleContext) PRECEDING_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPRECEDING_, 0)
}

func (s *Frame_singleContext) UNBOUNDED_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUNBOUNDED_, 0)
}

func (s *Frame_singleContext) CURRENT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCURRENT_, 0)
}

func (s *Frame_singleContext) ROW_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROW_, 0)
}

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

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

func (s *Frame_singleContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterFrame_single(s)
	}
}

func (s *Frame_singleContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitFrame_single(s)
	}
}

func (p *SQLiteParser) Frame_single() (localctx IFrame_singleContext) {
	this := p
	_ = this

	localctx = NewFrame_singleContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 142, SQLiteParserRULE_frame_single)

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

	defer func() {
		if err := recover(); err != nil {
			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(1845)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 269, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1838)
			p.expr(0)
		}
		{
			p.SetState(1839)
			p.Match(SQLiteParserPRECEDING_)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1841)
			p.Match(SQLiteParserUNBOUNDED_)
		}
		{
			p.SetState(1842)
			p.Match(SQLiteParserPRECEDING_)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1843)
			p.Match(SQLiteParserCURRENT_)
		}
		{
			p.SetState(1844)
			p.Match(SQLiteParserROW_)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyWindow_functionContext() *Window_functionContext {
	var p = new(Window_functionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_window_function
	return p
}

func (*Window_functionContext) IsWindow_functionContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_window_function

	return p
}

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

func (s *Window_functionContext) AllOPEN_PAR() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserOPEN_PAR)
}

func (s *Window_functionContext) OPEN_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, i)
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Window_functionContext) AllCLOSE_PAR() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCLOSE_PAR)
}

func (s *Window_functionContext) CLOSE_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, i)
}

func (s *Window_functionContext) OVER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOVER_, 0)
}

func (s *Window_functionContext) Order_by_expr_asc_desc() IOrder_by_expr_asc_descContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrder_by_expr_asc_descContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOrder_by_expr_asc_descContext)
}

func (s *Window_functionContext) FIRST_VALUE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFIRST_VALUE_, 0)
}

func (s *Window_functionContext) LAST_VALUE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLAST_VALUE_, 0)
}

func (s *Window_functionContext) Partition_by() IPartition_byContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPartition_byContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPartition_byContext)
}

func (s *Window_functionContext) Frame_clause() IFrame_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFrame_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IFrame_clauseContext)
}

func (s *Window_functionContext) CUME_DIST_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCUME_DIST_, 0)
}

func (s *Window_functionContext) PERCENT_RANK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPERCENT_RANK_, 0)
}

func (s *Window_functionContext) Order_by_expr() IOrder_by_exprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrder_by_exprContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOrder_by_exprContext)
}

func (s *Window_functionContext) DENSE_RANK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDENSE_RANK_, 0)
}

func (s *Window_functionContext) RANK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRANK_, 0)
}

func (s *Window_functionContext) ROW_NUMBER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROW_NUMBER_, 0)
}

func (s *Window_functionContext) LAG_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLAG_, 0)
}

func (s *Window_functionContext) LEAD_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLEAD_, 0)
}

func (s *Window_functionContext) Of_OF_fset() IOf_OF_fsetContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOf_OF_fsetContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOf_OF_fsetContext)
}

func (s *Window_functionContext) Default_DEFAULT__value() IDefault_DEFAULT__valueContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDefault_DEFAULT__valueContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDefault_DEFAULT__valueContext)
}

func (s *Window_functionContext) NTH_VALUE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNTH_VALUE_, 0)
}

func (s *Window_functionContext) COMMA() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMA, 0)
}

func (s *Window_functionContext) 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 *Window_functionContext) NTILE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNTILE_, 0)
}

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

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

func (s *Window_functionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterWindow_function(s)
	}
}

func (s *Window_functionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitWindow_function(s)
	}
}

func (p *SQLiteParser) Window_function() (localctx IWindow_functionContext) {
	this := p
	_ = this

	localctx = NewWindow_functionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 144, SQLiteParserRULE_window_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.SetState(1932)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserFIRST_VALUE_, SQLiteParserLAST_VALUE_:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1847)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SQLiteParserFIRST_VALUE_ || _la == SQLiteParserLAST_VALUE_) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1848)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1849)
			p.expr(0)
		}
		{
			p.SetState(1850)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		{
			p.SetState(1851)
			p.Match(SQLiteParserOVER_)
		}
		{
			p.SetState(1852)
			p.Match(SQLiteParserOPEN_PAR)
		}
		p.SetState(1854)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserPARTITION_ {
			{
				p.SetState(1853)
				p.Partition_by()
			}

		}
		{
			p.SetState(1856)
			p.Order_by_expr_asc_desc()
		}
		p.SetState(1858)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserROWS_ || _la == SQLiteParserRANGE_ || _la == SQLiteParserGROUPS_ {
			{
				p.SetState(1857)
				p.Frame_clause()
			}

		}
		{
			p.SetState(1860)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case SQLiteParserCUME_DIST_, SQLiteParserPERCENT_RANK_:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1862)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SQLiteParserCUME_DIST_ || _la == SQLiteParserPERCENT_RANK_) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1863)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1864)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		{
			p.SetState(1865)
			p.Match(SQLiteParserOVER_)
		}
		{
			p.SetState(1866)
			p.Match(SQLiteParserOPEN_PAR)
		}
		p.SetState(1868)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserPARTITION_ {
			{
				p.SetState(1867)
				p.Partition_by()
			}

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

		if _la == SQLiteParserORDER_ {
			{
				p.SetState(1870)
				p.Order_by_expr()
			}

		}
		{
			p.SetState(1873)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case SQLiteParserDENSE_RANK_, SQLiteParserRANK_, SQLiteParserROW_NUMBER_:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1874)
			_la = p.GetTokenStream().LA(1)

			if !(((_la-159)&-(0x1f+1)) == 0 && ((1<<uint((_la-159)))&((1<<(SQLiteParserDENSE_RANK_-159))|(1<<(SQLiteParserRANK_-159))|(1<<(SQLiteParserROW_NUMBER_-159)))) != 0) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1875)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1876)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		{
			p.SetState(1877)
			p.Match(SQLiteParserOVER_)
		}
		{
			p.SetState(1878)
			p.Match(SQLiteParserOPEN_PAR)
		}
		p.SetState(1880)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserPARTITION_ {
			{
				p.SetState(1879)
				p.Partition_by()
			}

		}
		{
			p.SetState(1882)
			p.Order_by_expr_asc_desc()
		}
		{
			p.SetState(1883)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case SQLiteParserLAG_, SQLiteParserLEAD_:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1885)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SQLiteParserLAG_ || _la == SQLiteParserLEAD_) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1886)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1887)
			p.expr(0)
		}
		p.SetState(1889)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 275, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1888)
				p.Of_OF_fset()
			}

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

		if _la == SQLiteParserCOMMA {
			{
				p.SetState(1891)
				p.Default_DEFAULT__value()
			}

		}
		{
			p.SetState(1894)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		{
			p.SetState(1895)
			p.Match(SQLiteParserOVER_)
		}
		{
			p.SetState(1896)
			p.Match(SQLiteParserOPEN_PAR)
		}
		p.SetState(1898)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserPARTITION_ {
			{
				p.SetState(1897)
				p.Partition_by()
			}

		}
		{
			p.SetState(1900)
			p.Order_by_expr_asc_desc()
		}
		{
			p.SetState(1901)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case SQLiteParserNTH_VALUE_:
		p.EnterOuterAlt(localctx, 5)
		{
			p.SetState(1903)
			p.Match(SQLiteParserNTH_VALUE_)
		}
		{
			p.SetState(1904)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1905)
			p.expr(0)
		}
		{
			p.SetState(1906)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(1907)
			p.Signed_number()
		}
		{
			p.SetState(1908)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		{
			p.SetState(1909)
			p.Match(SQLiteParserOVER_)
		}
		{
			p.SetState(1910)
			p.Match(SQLiteParserOPEN_PAR)
		}
		p.SetState(1912)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserPARTITION_ {
			{
				p.SetState(1911)
				p.Partition_by()
			}

		}
		{
			p.SetState(1914)
			p.Order_by_expr_asc_desc()
		}
		p.SetState(1916)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserROWS_ || _la == SQLiteParserRANGE_ || _la == SQLiteParserGROUPS_ {
			{
				p.SetState(1915)
				p.Frame_clause()
			}

		}
		{
			p.SetState(1918)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case SQLiteParserNTILE_:
		p.EnterOuterAlt(localctx, 6)
		{
			p.SetState(1920)
			p.Match(SQLiteParserNTILE_)
		}
		{
			p.SetState(1921)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1922)
			p.expr(0)
		}
		{
			p.SetState(1923)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		{
			p.SetState(1924)
			p.Match(SQLiteParserOVER_)
		}
		{
			p.SetState(1925)
			p.Match(SQLiteParserOPEN_PAR)
		}
		p.SetState(1927)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserPARTITION_ {
			{
				p.SetState(1926)
				p.Partition_by()
			}

		}
		{
			p.SetState(1929)
			p.Order_by_expr_asc_desc()
		}
		{
			p.SetState(1930)
			p.Match(SQLiteParserCLOSE_PAR)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyOf_OF_fsetContext() *Of_OF_fsetContext {
	var p = new(Of_OF_fsetContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_of_OF_fset
	return p
}

func (*Of_OF_fsetContext) IsOf_OF_fsetContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_of_OF_fset

	return p
}

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

func (s *Of_OF_fsetContext) COMMA() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMA, 0)
}

func (s *Of_OF_fsetContext) 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 *Of_OF_fsetContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *Of_OF_fsetContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterOf_OF_fset(s)
	}
}

func (s *Of_OF_fsetContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitOf_OF_fset(s)
	}
}

func (p *SQLiteParser) Of_OF_fset() (localctx IOf_OF_fsetContext) {
	this := p
	_ = this

	localctx = NewOf_OF_fsetContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 146, SQLiteParserRULE_of_OF_fset)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1934)
		p.Match(SQLiteParserCOMMA)
	}
	{
		p.SetState(1935)
		p.Signed_number()
	}

	return localctx
}

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

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

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

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

func NewEmptyDefault_DEFAULT__valueContext() *Default_DEFAULT__valueContext {
	var p = new(Default_DEFAULT__valueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_default_DEFAULT__value
	return p
}

func (*Default_DEFAULT__valueContext) IsDefault_DEFAULT__valueContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_default_DEFAULT__value

	return p
}

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

func (s *Default_DEFAULT__valueContext) COMMA() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMA, 0)
}

func (s *Default_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 *Default_DEFAULT__valueContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *Default_DEFAULT__valueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterDefault_DEFAULT__value(s)
	}
}

func (s *Default_DEFAULT__valueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitDefault_DEFAULT__value(s)
	}
}

func (p *SQLiteParser) Default_DEFAULT__value() (localctx IDefault_DEFAULT__valueContext) {
	this := p
	_ = this

	localctx = NewDefault_DEFAULT__valueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 148, SQLiteParserRULE_default_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(1937)
		p.Match(SQLiteParserCOMMA)
	}
	{
		p.SetState(1938)
		p.Signed_number()
	}

	return localctx
}

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

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

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

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

func NewEmptyPartition_byContext() *Partition_byContext {
	var p = new(Partition_byContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_partition_by
	return p
}

func (*Partition_byContext) IsPartition_byContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_partition_by

	return p
}

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

func (s *Partition_byContext) PARTITION_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPARTITION_, 0)
}

func (s *Partition_byContext) BY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBY_, 0)
}

func (s *Partition_byContext) 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 *Partition_byContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

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

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

func (s *Partition_byContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterPartition_by(s)
	}
}

func (s *Partition_byContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitPartition_by(s)
	}
}

func (p *SQLiteParser) Partition_by() (localctx IPartition_byContext) {
	this := p
	_ = this

	localctx = NewPartition_byContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 150, SQLiteParserRULE_partition_by)

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

	defer func() {
		if err := recover(); err != 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(1940)
		p.Match(SQLiteParserPARTITION_)
	}
	{
		p.SetState(1941)
		p.Match(SQLiteParserBY_)
	}
	p.SetState(1943)
	p.GetErrorHandler().Sync(p)
	_alt = 1
	for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1:
			{
				p.SetState(1942)
				p.expr(0)
			}

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

		p.SetState(1945)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 282, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyOrder_by_exprContext() *Order_by_exprContext {
	var p = new(Order_by_exprContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_order_by_expr
	return p
}

func (*Order_by_exprContext) IsOrder_by_exprContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_order_by_expr

	return p
}

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

func (s *Order_by_exprContext) ORDER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserORDER_, 0)
}

func (s *Order_by_exprContext) BY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBY_, 0)
}

func (s *Order_by_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 *Order_by_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 *Order_by_exprContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *Order_by_exprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterOrder_by_expr(s)
	}
}

func (s *Order_by_exprContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitOrder_by_expr(s)
	}
}

func (p *SQLiteParser) Order_by_expr() (localctx IOrder_by_exprContext) {
	this := p
	_ = this

	localctx = NewOrder_by_exprContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 152, SQLiteParserRULE_order_by_expr)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1947)
		p.Match(SQLiteParserORDER_)
	}
	{
		p.SetState(1948)
		p.Match(SQLiteParserBY_)
	}
	p.SetState(1950)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SQLiteParserOPEN_PAR)|(1<<SQLiteParserPLUS)|(1<<SQLiteParserMINUS)|(1<<SQLiteParserTILDE)|(1<<SQLiteParserABORT_)|(1<<SQLiteParserACTION_)|(1<<SQLiteParserADD_)|(1<<SQLiteParserAFTER_)|(1<<SQLiteParserALL_)|(1<<SQLiteParserALTER_)|(1<<SQLiteParserANALYZE_))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(SQLiteParserAND_-32))|(1<<(SQLiteParserAS_-32))|(1<<(SQLiteParserASC_-32))|(1<<(SQLiteParserATTACH_-32))|(1<<(SQLiteParserAUTOINCREMENT_-32))|(1<<(SQLiteParserBEFORE_-32))|(1<<(SQLiteParserBEGIN_-32))|(1<<(SQLiteParserBETWEEN_-32))|(1<<(SQLiteParserBY_-32))|(1<<(SQLiteParserCASCADE_-32))|(1<<(SQLiteParserCASE_-32))|(1<<(SQLiteParserCAST_-32))|(1<<(SQLiteParserCHECK_-32))|(1<<(SQLiteParserCOLLATE_-32))|(1<<(SQLiteParserCOLUMN_-32))|(1<<(SQLiteParserCOMMIT_-32))|(1<<(SQLiteParserCONFLICT_-32))|(1<<(SQLiteParserCONSTRAINT_-32))|(1<<(SQLiteParserCREATE_-32))|(1<<(SQLiteParserCROSS_-32))|(1<<(SQLiteParserCURRENT_DATE_-32))|(1<<(SQLiteParserCURRENT_TIME_-32))|(1<<(SQLiteParserCURRENT_TIMESTAMP_-32))|(1<<(SQLiteParserDATABASE_-32))|(1<<(SQLiteParserDEFAULT_-32))|(1<<(SQLiteParserDEFERRABLE_-32))|(1<<(SQLiteParserDEFERRED_-32))|(1<<(SQLiteParserDELETE_-32))|(1<<(SQLiteParserDESC_-32))|(1<<(SQLiteParserDETACH_-32))|(1<<(SQLiteParserDISTINCT_-32))|(1<<(SQLiteParserDROP_-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(SQLiteParserEACH_-64))|(1<<(SQLiteParserELSE_-64))|(1<<(SQLiteParserEND_-64))|(1<<(SQLiteParserESCAPE_-64))|(1<<(SQLiteParserEXCEPT_-64))|(1<<(SQLiteParserEXCLUSIVE_-64))|(1<<(SQLiteParserEXISTS_-64))|(1<<(SQLiteParserEXPLAIN_-64))|(1<<(SQLiteParserFAIL_-64))|(1<<(SQLiteParserFOR_-64))|(1<<(SQLiteParserFOREIGN_-64))|(1<<(SQLiteParserFROM_-64))|(1<<(SQLiteParserFULL_-64))|(1<<(SQLiteParserGLOB_-64))|(1<<(SQLiteParserGROUP_-64))|(1<<(SQLiteParserHAVING_-64))|(1<<(SQLiteParserIF_-64))|(1<<(SQLiteParserIGNORE_-64))|(1<<(SQLiteParserIMMEDIATE_-64))|(1<<(SQLiteParserIN_-64))|(1<<(SQLiteParserINDEX_-64))|(1<<(SQLiteParserINDEXED_-64))|(1<<(SQLiteParserINITIALLY_-64))|(1<<(SQLiteParserINNER_-64))|(1<<(SQLiteParserINSERT_-64))|(1<<(SQLiteParserINSTEAD_-64))|(1<<(SQLiteParserINTERSECT_-64))|(1<<(SQLiteParserINTO_-64))|(1<<(SQLiteParserIS_-64))|(1<<(SQLiteParserISNULL_-64))|(1<<(SQLiteParserJOIN_-64))|(1<<(SQLiteParserKEY_-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(SQLiteParserLEFT_-96))|(1<<(SQLiteParserLIKE_-96))|(1<<(SQLiteParserLIMIT_-96))|(1<<(SQLiteParserMATCH_-96))|(1<<(SQLiteParserNATURAL_-96))|(1<<(SQLiteParserNO_-96))|(1<<(SQLiteParserNOT_-96))|(1<<(SQLiteParserNOTNULL_-96))|(1<<(SQLiteParserNULL_-96))|(1<<(SQLiteParserOF_-96))|(1<<(SQLiteParserOFFSET_-96))|(1<<(SQLiteParserON_-96))|(1<<(SQLiteParserOR_-96))|(1<<(SQLiteParserORDER_-96))|(1<<(SQLiteParserOUTER_-96))|(1<<(SQLiteParserPLAN_-96))|(1<<(SQLiteParserPRAGMA_-96))|(1<<(SQLiteParserPRIMARY_-96))|(1<<(SQLiteParserQUERY_-96))|(1<<(SQLiteParserRAISE_-96))|(1<<(SQLiteParserRECURSIVE_-96))|(1<<(SQLiteParserREFERENCES_-96))|(1<<(SQLiteParserREGEXP_-96))|(1<<(SQLiteParserREINDEX_-96))|(1<<(SQLiteParserRELEASE_-96))|(1<<(SQLiteParserRENAME_-96))|(1<<(SQLiteParserREPLACE_-96))|(1<<(SQLiteParserRESTRICT_-96))|(1<<(SQLiteParserRIGHT_-96))|(1<<(SQLiteParserROLLBACK_-96))|(1<<(SQLiteParserROW_-96))|(1<<(SQLiteParserROWS_-96)))) != 0) || (((_la-128)&-(0x1f+1)) == 0 && ((1<<uint((_la-128)))&((1<<(SQLiteParserSAVEPOINT_-128))|(1<<(SQLiteParserSELECT_-128))|(1<<(SQLiteParserSET_-128))|(1<<(SQLiteParserTABLE_-128))|(1<<(SQLiteParserTEMP_-128))|(1<<(SQLiteParserTEMPORARY_-128))|(1<<(SQLiteParserTHEN_-128))|(1<<(SQLiteParserTO_-128))|(1<<(SQLiteParserTRANSACTION_-128))|(1<<(SQLiteParserTRIGGER_-128))|(1<<(SQLiteParserUNION_-128))|(1<<(SQLiteParserUNIQUE_-128))|(1<<(SQLiteParserUPDATE_-128))|(1<<(SQLiteParserUSING_-128))|(1<<(SQLiteParserVACUUM_-128))|(1<<(SQLiteParserVALUES_-128))|(1<<(SQLiteParserVIEW_-128))|(1<<(SQLiteParserVIRTUAL_-128))|(1<<(SQLiteParserWHEN_-128))|(1<<(SQLiteParserWHERE_-128))|(1<<(SQLiteParserWITH_-128))|(1<<(SQLiteParserWITHOUT_-128))|(1<<(SQLiteParserFIRST_VALUE_-128))|(1<<(SQLiteParserOVER_-128))|(1<<(SQLiteParserPARTITION_-128))|(1<<(SQLiteParserRANGE_-128))|(1<<(SQLiteParserPRECEDING_-128))|(1<<(SQLiteParserUNBOUNDED_-128))|(1<<(SQLiteParserCURRENT_-128))|(1<<(SQLiteParserFOLLOWING_-128))|(1<<(SQLiteParserCUME_DIST_-128))|(1<<(SQLiteParserDENSE_RANK_-128)))) != 0) || (((_la-160)&-(0x1f+1)) == 0 && ((1<<uint((_la-160)))&((1<<(SQLiteParserLAG_-160))|(1<<(SQLiteParserLAST_VALUE_-160))|(1<<(SQLiteParserLEAD_-160))|(1<<(SQLiteParserNTH_VALUE_-160))|(1<<(SQLiteParserNTILE_-160))|(1<<(SQLiteParserPERCENT_RANK_-160))|(1<<(SQLiteParserRANK_-160))|(1<<(SQLiteParserROW_NUMBER_-160))|(1<<(SQLiteParserGENERATED_-160))|(1<<(SQLiteParserALWAYS_-160))|(1<<(SQLiteParserSTORED_-160))|(1<<(SQLiteParserTRUE_-160))|(1<<(SQLiteParserFALSE_-160))|(1<<(SQLiteParserWINDOW_-160))|(1<<(SQLiteParserNULLS_-160))|(1<<(SQLiteParserFIRST_-160))|(1<<(SQLiteParserLAST_-160))|(1<<(SQLiteParserFILTER_-160))|(1<<(SQLiteParserGROUPS_-160))|(1<<(SQLiteParserEXCLUDE_-160))|(1<<(SQLiteParserIDENTIFIER-160))|(1<<(SQLiteParserNUMERIC_LITERAL-160))|(1<<(SQLiteParserBIND_PARAMETER-160))|(1<<(SQLiteParserSTRING_LITERAL-160))|(1<<(SQLiteParserBLOB_LITERAL-160)))) != 0) {
		{
			p.SetState(1949)
			p.expr(0)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyOrder_by_expr_asc_descContext() *Order_by_expr_asc_descContext {
	var p = new(Order_by_expr_asc_descContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_order_by_expr_asc_desc
	return p
}

func (*Order_by_expr_asc_descContext) IsOrder_by_expr_asc_descContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_order_by_expr_asc_desc

	return p
}

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

func (s *Order_by_expr_asc_descContext) ORDER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserORDER_, 0)
}

func (s *Order_by_expr_asc_descContext) BY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBY_, 0)
}

func (s *Order_by_expr_asc_descContext) Order_by_expr_asc_desc() IOrder_by_expr_asc_descContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IOrder_by_expr_asc_descContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IOrder_by_expr_asc_descContext)
}

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

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

func (s *Order_by_expr_asc_descContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterOrder_by_expr_asc_desc(s)
	}
}

func (s *Order_by_expr_asc_descContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitOrder_by_expr_asc_desc(s)
	}
}

func (p *SQLiteParser) Order_by_expr_asc_desc() (localctx IOrder_by_expr_asc_descContext) {
	this := p
	_ = this

	localctx = NewOrder_by_expr_asc_descContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 154, SQLiteParserRULE_order_by_expr_asc_desc)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1954)
		p.Match(SQLiteParserORDER_)
	}
	{
		p.SetState(1955)
		p.Match(SQLiteParserBY_)
	}
	{
		p.SetState(1956)
		p.Order_by_expr_asc_desc()
	}

	return localctx
}

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

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

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

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

func NewEmptyExpr_asc_descContext() *Expr_asc_descContext {
	var p = new(Expr_asc_descContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_expr_asc_desc
	return p
}

func (*Expr_asc_descContext) IsExpr_asc_descContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_expr_asc_desc

	return p
}

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

func (s *Expr_asc_descContext) 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 *Expr_asc_descContext) Expr(i int) IExprContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Expr_asc_descContext) AllAsc_desc() []IAsc_descContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IAsc_descContext)(nil)).Elem())
	var tst = make([]IAsc_descContext, len(ts))

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

	return tst
}

func (s *Expr_asc_descContext) Asc_desc(i int) IAsc_descContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAsc_descContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IAsc_descContext)
}

func (s *Expr_asc_descContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCOMMA)
}

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

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

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

func (s *Expr_asc_descContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterExpr_asc_desc(s)
	}
}

func (s *Expr_asc_descContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitExpr_asc_desc(s)
	}
}

func (p *SQLiteParser) Expr_asc_desc() (localctx IExpr_asc_descContext) {
	this := p
	_ = this

	localctx = NewExpr_asc_descContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 156, SQLiteParserRULE_expr_asc_desc)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1958)
		p.expr(0)
	}
	p.SetState(1960)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserASC_ || _la == SQLiteParserDESC_ {
		{
			p.SetState(1959)
			p.Asc_desc()
		}

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

	for _la == SQLiteParserCOMMA {
		{
			p.SetState(1962)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(1963)
			p.expr(0)
		}
		p.SetState(1965)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserASC_ || _la == SQLiteParserDESC_ {
			{
				p.SetState(1964)
				p.Asc_desc()
			}

		}

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

	return localctx
}

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

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

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

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

func NewEmptyInitial_selectContext() *Initial_selectContext {
	var p = new(Initial_selectContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_initial_select
	return p
}

func (*Initial_selectContext) IsInitial_selectContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_initial_select

	return p
}

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

func (s *Initial_selectContext) 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 *Initial_selectContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *Initial_selectContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterInitial_select(s)
	}
}

func (s *Initial_selectContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitInitial_select(s)
	}
}

func (p *SQLiteParser) Initial_select() (localctx IInitial_selectContext) {
	this := p
	_ = this

	localctx = NewInitial_selectContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 158, SQLiteParserRULE_initial_select)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1972)
		p.Select_stmt()
	}

	return localctx
}

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

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

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

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

func NewEmptyRecursive__selectContext() *Recursive__selectContext {
	var p = new(Recursive__selectContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_recursive__select
	return p
}

func (*Recursive__selectContext) IsRecursive__selectContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_recursive__select

	return p
}

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

func (s *Recursive__selectContext) 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 *Recursive__selectContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *Recursive__selectContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterRecursive__select(s)
	}
}

func (s *Recursive__selectContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitRecursive__select(s)
	}
}

func (p *SQLiteParser) Recursive__select() (localctx IRecursive__selectContext) {
	this := p
	_ = this

	localctx = NewRecursive__selectContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 160, SQLiteParserRULE_recursive__select)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1974)
		p.Select_stmt()
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_unary_operator

	return p
}

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

func (s *Unary_operatorContext) MINUS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserMINUS, 0)
}

func (s *Unary_operatorContext) PLUS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPLUS, 0)
}

func (s *Unary_operatorContext) TILDE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTILDE, 0)
}

func (s *Unary_operatorContext) NOT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOT_, 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.(SQLiteParserListener); ok {
		listenerT.EnterUnary_operator(s)
	}
}

func (s *Unary_operatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitUnary_operator(s)
	}
}

func (p *SQLiteParser) Unary_operator() (localctx IUnary_operatorContext) {
	this := p
	_ = this

	localctx = NewUnary_operatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 162, SQLiteParserRULE_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(1976)
		_la = p.GetTokenStream().LA(1)

		if !((((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SQLiteParserPLUS)|(1<<SQLiteParserMINUS)|(1<<SQLiteParserTILDE))) != 0) || _la == SQLiteParserNOT_) {
			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 = SQLiteParserRULE_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 = SQLiteParserRULE_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(SQLiteParserSTRING_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.(SQLiteParserListener); ok {
		listenerT.EnterError_message(s)
	}
}

func (s *Error_messageContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitError_message(s)
	}
}

func (p *SQLiteParser) Error_message() (localctx IError_messageContext) {
	this := p
	_ = this

	localctx = NewError_messageContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 164, SQLiteParserRULE_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(1978)
		p.Match(SQLiteParserSTRING_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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterModule_argument(s)
	}
}

func (s *Module_argumentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitModule_argument(s)
	}
}

func (p *SQLiteParser) Module_argument() (localctx IModule_argumentContext) {
	this := p
	_ = this

	localctx = NewModule_argumentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 166, SQLiteParserRULE_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(1982)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 287, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1980)
			p.expr(0)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1981)
			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 = SQLiteParserRULE_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 = SQLiteParserRULE_column_alias

	return p
}

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

func (s *Column_aliasContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIDENTIFIER, 0)
}

func (s *Column_aliasContext) STRING_LITERAL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSTRING_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.(SQLiteParserListener); ok {
		listenerT.EnterColumn_alias(s)
	}
}

func (s *Column_aliasContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitColumn_alias(s)
	}
}

func (p *SQLiteParser) Column_alias() (localctx IColumn_aliasContext) {
	this := p
	_ = this

	localctx = NewColumn_aliasContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 168, SQLiteParserRULE_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(1984)
		_la = p.GetTokenStream().LA(1)

		if !(_la == SQLiteParserIDENTIFIER || _la == SQLiteParserSTRING_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 = SQLiteParserRULE_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 = SQLiteParserRULE_keyword

	return p
}

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

func (s *KeywordContext) ABORT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserABORT_, 0)
}

func (s *KeywordContext) ACTION_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserACTION_, 0)
}

func (s *KeywordContext) ADD_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserADD_, 0)
}

func (s *KeywordContext) AFTER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAFTER_, 0)
}

func (s *KeywordContext) ALL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserALL_, 0)
}

func (s *KeywordContext) ALTER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserALTER_, 0)
}

func (s *KeywordContext) ANALYZE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserANALYZE_, 0)
}

func (s *KeywordContext) AND_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAND_, 0)
}

func (s *KeywordContext) AS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAS_, 0)
}

func (s *KeywordContext) ASC_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserASC_, 0)
}

func (s *KeywordContext) ATTACH_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserATTACH_, 0)
}

func (s *KeywordContext) AUTOINCREMENT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserAUTOINCREMENT_, 0)
}

func (s *KeywordContext) BEFORE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBEFORE_, 0)
}

func (s *KeywordContext) BEGIN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBEGIN_, 0)
}

func (s *KeywordContext) BETWEEN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBETWEEN_, 0)
}

func (s *KeywordContext) BY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserBY_, 0)
}

func (s *KeywordContext) CASCADE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCASCADE_, 0)
}

func (s *KeywordContext) CASE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCASE_, 0)
}

func (s *KeywordContext) CAST_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCAST_, 0)
}

func (s *KeywordContext) CHECK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCHECK_, 0)
}

func (s *KeywordContext) COLLATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOLLATE_, 0)
}

func (s *KeywordContext) COLUMN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOLUMN_, 0)
}

func (s *KeywordContext) COMMIT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCOMMIT_, 0)
}

func (s *KeywordContext) CONFLICT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCONFLICT_, 0)
}

func (s *KeywordContext) CONSTRAINT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCONSTRAINT_, 0)
}

func (s *KeywordContext) CREATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCREATE_, 0)
}

func (s *KeywordContext) CROSS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCROSS_, 0)
}

func (s *KeywordContext) CURRENT_DATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCURRENT_DATE_, 0)
}

func (s *KeywordContext) CURRENT_TIME_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCURRENT_TIME_, 0)
}

func (s *KeywordContext) CURRENT_TIMESTAMP_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCURRENT_TIMESTAMP_, 0)
}

func (s *KeywordContext) DATABASE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDATABASE_, 0)
}

func (s *KeywordContext) DEFAULT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDEFAULT_, 0)
}

func (s *KeywordContext) DEFERRABLE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDEFERRABLE_, 0)
}

func (s *KeywordContext) DEFERRED_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDEFERRED_, 0)
}

func (s *KeywordContext) DELETE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDELETE_, 0)
}

func (s *KeywordContext) DESC_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDESC_, 0)
}

func (s *KeywordContext) DETACH_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDETACH_, 0)
}

func (s *KeywordContext) DISTINCT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDISTINCT_, 0)
}

func (s *KeywordContext) DROP_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDROP_, 0)
}

func (s *KeywordContext) EACH_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEACH_, 0)
}

func (s *KeywordContext) ELSE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserELSE_, 0)
}

func (s *KeywordContext) END_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEND_, 0)
}

func (s *KeywordContext) ESCAPE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserESCAPE_, 0)
}

func (s *KeywordContext) EXCEPT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXCEPT_, 0)
}

func (s *KeywordContext) EXCLUSIVE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXCLUSIVE_, 0)
}

func (s *KeywordContext) EXISTS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXISTS_, 0)
}

func (s *KeywordContext) EXPLAIN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXPLAIN_, 0)
}

func (s *KeywordContext) FAIL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFAIL_, 0)
}

func (s *KeywordContext) FOR_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFOR_, 0)
}

func (s *KeywordContext) FOREIGN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFOREIGN_, 0)
}

func (s *KeywordContext) FROM_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFROM_, 0)
}

func (s *KeywordContext) FULL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFULL_, 0)
}

func (s *KeywordContext) GLOB_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserGLOB_, 0)
}

func (s *KeywordContext) GROUP_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserGROUP_, 0)
}

func (s *KeywordContext) HAVING_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserHAVING_, 0)
}

func (s *KeywordContext) IF_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIF_, 0)
}

func (s *KeywordContext) IGNORE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIGNORE_, 0)
}

func (s *KeywordContext) IMMEDIATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIMMEDIATE_, 0)
}

func (s *KeywordContext) IN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIN_, 0)
}

func (s *KeywordContext) INDEX_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINDEX_, 0)
}

func (s *KeywordContext) INDEXED_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINDEXED_, 0)
}

func (s *KeywordContext) INITIALLY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINITIALLY_, 0)
}

func (s *KeywordContext) INNER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINNER_, 0)
}

func (s *KeywordContext) INSERT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINSERT_, 0)
}

func (s *KeywordContext) INSTEAD_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINSTEAD_, 0)
}

func (s *KeywordContext) INTERSECT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINTERSECT_, 0)
}

func (s *KeywordContext) INTO_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserINTO_, 0)
}

func (s *KeywordContext) IS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIS_, 0)
}

func (s *KeywordContext) ISNULL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserISNULL_, 0)
}

func (s *KeywordContext) JOIN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserJOIN_, 0)
}

func (s *KeywordContext) KEY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserKEY_, 0)
}

func (s *KeywordContext) LEFT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLEFT_, 0)
}

func (s *KeywordContext) LIKE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLIKE_, 0)
}

func (s *KeywordContext) LIMIT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLIMIT_, 0)
}

func (s *KeywordContext) MATCH_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserMATCH_, 0)
}

func (s *KeywordContext) NATURAL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNATURAL_, 0)
}

func (s *KeywordContext) NO_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNO_, 0)
}

func (s *KeywordContext) NOT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOT_, 0)
}

func (s *KeywordContext) NOTNULL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNOTNULL_, 0)
}

func (s *KeywordContext) NULL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNULL_, 0)
}

func (s *KeywordContext) OF_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOF_, 0)
}

func (s *KeywordContext) OFFSET_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOFFSET_, 0)
}

func (s *KeywordContext) ON_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserON_, 0)
}

func (s *KeywordContext) OR_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOR_, 0)
}

func (s *KeywordContext) ORDER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserORDER_, 0)
}

func (s *KeywordContext) OUTER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOUTER_, 0)
}

func (s *KeywordContext) PLAN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPLAN_, 0)
}

func (s *KeywordContext) PRAGMA_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPRAGMA_, 0)
}

func (s *KeywordContext) PRIMARY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPRIMARY_, 0)
}

func (s *KeywordContext) QUERY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserQUERY_, 0)
}

func (s *KeywordContext) RAISE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRAISE_, 0)
}

func (s *KeywordContext) RECURSIVE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRECURSIVE_, 0)
}

func (s *KeywordContext) REFERENCES_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserREFERENCES_, 0)
}

func (s *KeywordContext) REGEXP_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserREGEXP_, 0)
}

func (s *KeywordContext) REINDEX_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserREINDEX_, 0)
}

func (s *KeywordContext) RELEASE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRELEASE_, 0)
}

func (s *KeywordContext) RENAME_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRENAME_, 0)
}

func (s *KeywordContext) REPLACE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserREPLACE_, 0)
}

func (s *KeywordContext) RESTRICT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRESTRICT_, 0)
}

func (s *KeywordContext) RIGHT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRIGHT_, 0)
}

func (s *KeywordContext) ROLLBACK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROLLBACK_, 0)
}

func (s *KeywordContext) ROW_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROW_, 0)
}

func (s *KeywordContext) ROWS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROWS_, 0)
}

func (s *KeywordContext) SAVEPOINT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSAVEPOINT_, 0)
}

func (s *KeywordContext) SELECT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSELECT_, 0)
}

func (s *KeywordContext) SET_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSET_, 0)
}

func (s *KeywordContext) TABLE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTABLE_, 0)
}

func (s *KeywordContext) TEMP_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTEMP_, 0)
}

func (s *KeywordContext) TEMPORARY_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTEMPORARY_, 0)
}

func (s *KeywordContext) THEN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTHEN_, 0)
}

func (s *KeywordContext) TO_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTO_, 0)
}

func (s *KeywordContext) TRANSACTION_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTRANSACTION_, 0)
}

func (s *KeywordContext) TRIGGER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTRIGGER_, 0)
}

func (s *KeywordContext) UNION_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUNION_, 0)
}

func (s *KeywordContext) UNIQUE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUNIQUE_, 0)
}

func (s *KeywordContext) UPDATE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUPDATE_, 0)
}

func (s *KeywordContext) USING_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUSING_, 0)
}

func (s *KeywordContext) VACUUM_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserVACUUM_, 0)
}

func (s *KeywordContext) VALUES_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserVALUES_, 0)
}

func (s *KeywordContext) VIEW_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserVIEW_, 0)
}

func (s *KeywordContext) VIRTUAL_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserVIRTUAL_, 0)
}

func (s *KeywordContext) WHEN_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWHEN_, 0)
}

func (s *KeywordContext) WHERE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWHERE_, 0)
}

func (s *KeywordContext) WITH_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWITH_, 0)
}

func (s *KeywordContext) WITHOUT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWITHOUT_, 0)
}

func (s *KeywordContext) FIRST_VALUE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFIRST_VALUE_, 0)
}

func (s *KeywordContext) OVER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOVER_, 0)
}

func (s *KeywordContext) PARTITION_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPARTITION_, 0)
}

func (s *KeywordContext) RANGE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRANGE_, 0)
}

func (s *KeywordContext) PRECEDING_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPRECEDING_, 0)
}

func (s *KeywordContext) UNBOUNDED_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserUNBOUNDED_, 0)
}

func (s *KeywordContext) CURRENT_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCURRENT_, 0)
}

func (s *KeywordContext) FOLLOWING_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFOLLOWING_, 0)
}

func (s *KeywordContext) CUME_DIST_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCUME_DIST_, 0)
}

func (s *KeywordContext) DENSE_RANK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserDENSE_RANK_, 0)
}

func (s *KeywordContext) LAG_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLAG_, 0)
}

func (s *KeywordContext) LAST_VALUE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLAST_VALUE_, 0)
}

func (s *KeywordContext) LEAD_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLEAD_, 0)
}

func (s *KeywordContext) NTH_VALUE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNTH_VALUE_, 0)
}

func (s *KeywordContext) NTILE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNTILE_, 0)
}

func (s *KeywordContext) PERCENT_RANK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserPERCENT_RANK_, 0)
}

func (s *KeywordContext) RANK_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserRANK_, 0)
}

func (s *KeywordContext) ROW_NUMBER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserROW_NUMBER_, 0)
}

func (s *KeywordContext) GENERATED_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserGENERATED_, 0)
}

func (s *KeywordContext) ALWAYS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserALWAYS_, 0)
}

func (s *KeywordContext) STORED_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSTORED_, 0)
}

func (s *KeywordContext) TRUE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserTRUE_, 0)
}

func (s *KeywordContext) FALSE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFALSE_, 0)
}

func (s *KeywordContext) WINDOW_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserWINDOW_, 0)
}

func (s *KeywordContext) NULLS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserNULLS_, 0)
}

func (s *KeywordContext) FIRST_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFIRST_, 0)
}

func (s *KeywordContext) LAST_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserLAST_, 0)
}

func (s *KeywordContext) FILTER_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserFILTER_, 0)
}

func (s *KeywordContext) GROUPS_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserGROUPS_, 0)
}

func (s *KeywordContext) EXCLUDE_() antlr.TerminalNode {
	return s.GetToken(SQLiteParserEXCLUDE_, 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.(SQLiteParserListener); ok {
		listenerT.EnterKeyword(s)
	}
}

func (s *KeywordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitKeyword(s)
	}
}

func (p *SQLiteParser) Keyword() (localctx IKeywordContext) {
	this := p
	_ = this

	localctx = NewKeywordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 170, SQLiteParserRULE_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(1986)
		_la = p.GetTokenStream().LA(1)

		if !((((_la-25)&-(0x1f+1)) == 0 && ((1<<uint((_la-25)))&((1<<(SQLiteParserABORT_-25))|(1<<(SQLiteParserACTION_-25))|(1<<(SQLiteParserADD_-25))|(1<<(SQLiteParserAFTER_-25))|(1<<(SQLiteParserALL_-25))|(1<<(SQLiteParserALTER_-25))|(1<<(SQLiteParserANALYZE_-25))|(1<<(SQLiteParserAND_-25))|(1<<(SQLiteParserAS_-25))|(1<<(SQLiteParserASC_-25))|(1<<(SQLiteParserATTACH_-25))|(1<<(SQLiteParserAUTOINCREMENT_-25))|(1<<(SQLiteParserBEFORE_-25))|(1<<(SQLiteParserBEGIN_-25))|(1<<(SQLiteParserBETWEEN_-25))|(1<<(SQLiteParserBY_-25))|(1<<(SQLiteParserCASCADE_-25))|(1<<(SQLiteParserCASE_-25))|(1<<(SQLiteParserCAST_-25))|(1<<(SQLiteParserCHECK_-25))|(1<<(SQLiteParserCOLLATE_-25))|(1<<(SQLiteParserCOLUMN_-25))|(1<<(SQLiteParserCOMMIT_-25))|(1<<(SQLiteParserCONFLICT_-25))|(1<<(SQLiteParserCONSTRAINT_-25))|(1<<(SQLiteParserCREATE_-25))|(1<<(SQLiteParserCROSS_-25))|(1<<(SQLiteParserCURRENT_DATE_-25))|(1<<(SQLiteParserCURRENT_TIME_-25))|(1<<(SQLiteParserCURRENT_TIMESTAMP_-25))|(1<<(SQLiteParserDATABASE_-25))|(1<<(SQLiteParserDEFAULT_-25)))) != 0) || (((_la-57)&-(0x1f+1)) == 0 && ((1<<uint((_la-57)))&((1<<(SQLiteParserDEFERRABLE_-57))|(1<<(SQLiteParserDEFERRED_-57))|(1<<(SQLiteParserDELETE_-57))|(1<<(SQLiteParserDESC_-57))|(1<<(SQLiteParserDETACH_-57))|(1<<(SQLiteParserDISTINCT_-57))|(1<<(SQLiteParserDROP_-57))|(1<<(SQLiteParserEACH_-57))|(1<<(SQLiteParserELSE_-57))|(1<<(SQLiteParserEND_-57))|(1<<(SQLiteParserESCAPE_-57))|(1<<(SQLiteParserEXCEPT_-57))|(1<<(SQLiteParserEXCLUSIVE_-57))|(1<<(SQLiteParserEXISTS_-57))|(1<<(SQLiteParserEXPLAIN_-57))|(1<<(SQLiteParserFAIL_-57))|(1<<(SQLiteParserFOR_-57))|(1<<(SQLiteParserFOREIGN_-57))|(1<<(SQLiteParserFROM_-57))|(1<<(SQLiteParserFULL_-57))|(1<<(SQLiteParserGLOB_-57))|(1<<(SQLiteParserGROUP_-57))|(1<<(SQLiteParserHAVING_-57))|(1<<(SQLiteParserIF_-57))|(1<<(SQLiteParserIGNORE_-57))|(1<<(SQLiteParserIMMEDIATE_-57))|(1<<(SQLiteParserIN_-57))|(1<<(SQLiteParserINDEX_-57))|(1<<(SQLiteParserINDEXED_-57))|(1<<(SQLiteParserINITIALLY_-57))|(1<<(SQLiteParserINNER_-57))|(1<<(SQLiteParserINSERT_-57)))) != 0) || (((_la-89)&-(0x1f+1)) == 0 && ((1<<uint((_la-89)))&((1<<(SQLiteParserINSTEAD_-89))|(1<<(SQLiteParserINTERSECT_-89))|(1<<(SQLiteParserINTO_-89))|(1<<(SQLiteParserIS_-89))|(1<<(SQLiteParserISNULL_-89))|(1<<(SQLiteParserJOIN_-89))|(1<<(SQLiteParserKEY_-89))|(1<<(SQLiteParserLEFT_-89))|(1<<(SQLiteParserLIKE_-89))|(1<<(SQLiteParserLIMIT_-89))|(1<<(SQLiteParserMATCH_-89))|(1<<(SQLiteParserNATURAL_-89))|(1<<(SQLiteParserNO_-89))|(1<<(SQLiteParserNOT_-89))|(1<<(SQLiteParserNOTNULL_-89))|(1<<(SQLiteParserNULL_-89))|(1<<(SQLiteParserOF_-89))|(1<<(SQLiteParserOFFSET_-89))|(1<<(SQLiteParserON_-89))|(1<<(SQLiteParserOR_-89))|(1<<(SQLiteParserORDER_-89))|(1<<(SQLiteParserOUTER_-89))|(1<<(SQLiteParserPLAN_-89))|(1<<(SQLiteParserPRAGMA_-89))|(1<<(SQLiteParserPRIMARY_-89))|(1<<(SQLiteParserQUERY_-89))|(1<<(SQLiteParserRAISE_-89))|(1<<(SQLiteParserRECURSIVE_-89))|(1<<(SQLiteParserREFERENCES_-89))|(1<<(SQLiteParserREGEXP_-89))|(1<<(SQLiteParserREINDEX_-89))|(1<<(SQLiteParserRELEASE_-89)))) != 0) || (((_la-121)&-(0x1f+1)) == 0 && ((1<<uint((_la-121)))&((1<<(SQLiteParserRENAME_-121))|(1<<(SQLiteParserREPLACE_-121))|(1<<(SQLiteParserRESTRICT_-121))|(1<<(SQLiteParserRIGHT_-121))|(1<<(SQLiteParserROLLBACK_-121))|(1<<(SQLiteParserROW_-121))|(1<<(SQLiteParserROWS_-121))|(1<<(SQLiteParserSAVEPOINT_-121))|(1<<(SQLiteParserSELECT_-121))|(1<<(SQLiteParserSET_-121))|(1<<(SQLiteParserTABLE_-121))|(1<<(SQLiteParserTEMP_-121))|(1<<(SQLiteParserTEMPORARY_-121))|(1<<(SQLiteParserTHEN_-121))|(1<<(SQLiteParserTO_-121))|(1<<(SQLiteParserTRANSACTION_-121))|(1<<(SQLiteParserTRIGGER_-121))|(1<<(SQLiteParserUNION_-121))|(1<<(SQLiteParserUNIQUE_-121))|(1<<(SQLiteParserUPDATE_-121))|(1<<(SQLiteParserUSING_-121))|(1<<(SQLiteParserVACUUM_-121))|(1<<(SQLiteParserVALUES_-121))|(1<<(SQLiteParserVIEW_-121))|(1<<(SQLiteParserVIRTUAL_-121))|(1<<(SQLiteParserWHEN_-121))|(1<<(SQLiteParserWHERE_-121))|(1<<(SQLiteParserWITH_-121))|(1<<(SQLiteParserWITHOUT_-121))|(1<<(SQLiteParserFIRST_VALUE_-121))|(1<<(SQLiteParserOVER_-121))|(1<<(SQLiteParserPARTITION_-121)))) != 0) || (((_la-153)&-(0x1f+1)) == 0 && ((1<<uint((_la-153)))&((1<<(SQLiteParserRANGE_-153))|(1<<(SQLiteParserPRECEDING_-153))|(1<<(SQLiteParserUNBOUNDED_-153))|(1<<(SQLiteParserCURRENT_-153))|(1<<(SQLiteParserFOLLOWING_-153))|(1<<(SQLiteParserCUME_DIST_-153))|(1<<(SQLiteParserDENSE_RANK_-153))|(1<<(SQLiteParserLAG_-153))|(1<<(SQLiteParserLAST_VALUE_-153))|(1<<(SQLiteParserLEAD_-153))|(1<<(SQLiteParserNTH_VALUE_-153))|(1<<(SQLiteParserNTILE_-153))|(1<<(SQLiteParserPERCENT_RANK_-153))|(1<<(SQLiteParserRANK_-153))|(1<<(SQLiteParserROW_NUMBER_-153))|(1<<(SQLiteParserGENERATED_-153))|(1<<(SQLiteParserALWAYS_-153))|(1<<(SQLiteParserSTORED_-153))|(1<<(SQLiteParserTRUE_-153))|(1<<(SQLiteParserFALSE_-153))|(1<<(SQLiteParserWINDOW_-153))|(1<<(SQLiteParserNULLS_-153))|(1<<(SQLiteParserFIRST_-153))|(1<<(SQLiteParserLAST_-153))|(1<<(SQLiteParserFILTER_-153))|(1<<(SQLiteParserGROUPS_-153))|(1<<(SQLiteParserEXCLUDE_-153)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterName(s)
	}
}

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

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

	localctx = NewNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 172, SQLiteParserRULE_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(1988)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterFunction_name(s)
	}
}

func (s *Function_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitFunction_name(s)
	}
}

func (p *SQLiteParser) Function_name() (localctx IFunction_nameContext) {
	this := p
	_ = this

	localctx = NewFunction_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 174, SQLiteParserRULE_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(1990)
		p.Any_name()
	}

	return localctx
}

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

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

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

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

func NewEmptySchema_nameContext() *Schema_nameContext {
	var p = new(Schema_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_schema_name
	return p
}

func (*Schema_nameContext) IsSchema_nameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_schema_name

	return p
}

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

func (s *Schema_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 *Schema_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *Schema_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterSchema_name(s)
	}
}

func (s *Schema_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitSchema_name(s)
	}
}

func (p *SQLiteParser) Schema_name() (localctx ISchema_nameContext) {
	this := p
	_ = this

	localctx = NewSchema_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 176, SQLiteParserRULE_schema_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(1992)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterTable_name(s)
	}
}

func (s *Table_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitTable_name(s)
	}
}

func (p *SQLiteParser) Table_name() (localctx ITable_nameContext) {
	this := p
	_ = this

	localctx = NewTable_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 178, SQLiteParserRULE_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(1994)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterTable_or_index_name(s)
	}
}

func (s *Table_or_index_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitTable_or_index_name(s)
	}
}

func (p *SQLiteParser) Table_or_index_name() (localctx ITable_or_index_nameContext) {
	this := p
	_ = this

	localctx = NewTable_or_index_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 180, SQLiteParserRULE_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(1996)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterNew_table_name(s)
	}
}

func (s *New_table_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitNew_table_name(s)
	}
}

func (p *SQLiteParser) New_table_name() (localctx INew_table_nameContext) {
	this := p
	_ = this

	localctx = NewNew_table_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 182, SQLiteParserRULE_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(1998)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterColumn_name(s)
	}
}

func (s *Column_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitColumn_name(s)
	}
}

func (p *SQLiteParser) Column_name() (localctx IColumn_nameContext) {
	this := p
	_ = this

	localctx = NewColumn_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 184, SQLiteParserRULE_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(2000)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterCollation_name(s)
	}
}

func (s *Collation_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitCollation_name(s)
	}
}

func (p *SQLiteParser) Collation_name() (localctx ICollation_nameContext) {
	this := p
	_ = this

	localctx = NewCollation_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 186, SQLiteParserRULE_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(2002)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterForeign_table(s)
	}
}

func (s *Foreign_tableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitForeign_table(s)
	}
}

func (p *SQLiteParser) Foreign_table() (localctx IForeign_tableContext) {
	this := p
	_ = this

	localctx = NewForeign_tableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 188, SQLiteParserRULE_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(2004)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterIndex_name(s)
	}
}

func (s *Index_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitIndex_name(s)
	}
}

func (p *SQLiteParser) Index_name() (localctx IIndex_nameContext) {
	this := p
	_ = this

	localctx = NewIndex_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 190, SQLiteParserRULE_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(2006)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterTrigger_name(s)
	}
}

func (s *Trigger_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitTrigger_name(s)
	}
}

func (p *SQLiteParser) Trigger_name() (localctx ITrigger_nameContext) {
	this := p
	_ = this

	localctx = NewTrigger_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 192, SQLiteParserRULE_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(2008)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterView_name(s)
	}
}

func (s *View_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitView_name(s)
	}
}

func (p *SQLiteParser) View_name() (localctx IView_nameContext) {
	this := p
	_ = this

	localctx = NewView_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 194, SQLiteParserRULE_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(2010)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterModule_name(s)
	}
}

func (s *Module_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitModule_name(s)
	}
}

func (p *SQLiteParser) Module_name() (localctx IModule_nameContext) {
	this := p
	_ = this

	localctx = NewModule_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 196, SQLiteParserRULE_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(2012)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterPragma_name(s)
	}
}

func (s *Pragma_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitPragma_name(s)
	}
}

func (p *SQLiteParser) Pragma_name() (localctx IPragma_nameContext) {
	this := p
	_ = this

	localctx = NewPragma_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 198, SQLiteParserRULE_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(2014)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterSavepoint_name(s)
	}
}

func (s *Savepoint_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitSavepoint_name(s)
	}
}

func (p *SQLiteParser) Savepoint_name() (localctx ISavepoint_nameContext) {
	this := p
	_ = this

	localctx = NewSavepoint_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 200, SQLiteParserRULE_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(2016)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterTable_alias(s)
	}
}

func (s *Table_aliasContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitTable_alias(s)
	}
}

func (p *SQLiteParser) Table_alias() (localctx ITable_aliasContext) {
	this := p
	_ = this

	localctx = NewTable_aliasContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 202, SQLiteParserRULE_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(2018)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_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.(SQLiteParserListener); ok {
		listenerT.EnterTransaction_name(s)
	}
}

func (s *Transaction_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitTransaction_name(s)
	}
}

func (p *SQLiteParser) Transaction_name() (localctx ITransaction_nameContext) {
	this := p
	_ = this

	localctx = NewTransaction_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 204, SQLiteParserRULE_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(2020)
		p.Any_name()
	}

	return localctx
}

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

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

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

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

func NewEmptyWindow_nameContext() *Window_nameContext {
	var p = new(Window_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_window_name
	return p
}

func (*Window_nameContext) IsWindow_nameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_window_name

	return p
}

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

func (s *Window_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 *Window_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *Window_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterWindow_name(s)
	}
}

func (s *Window_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitWindow_name(s)
	}
}

func (p *SQLiteParser) Window_name() (localctx IWindow_nameContext) {
	this := p
	_ = this

	localctx = NewWindow_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 206, SQLiteParserRULE_window_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(2022)
		p.Any_name()
	}

	return localctx
}

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

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

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

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

func NewEmptyAliasContext() *AliasContext {
	var p = new(AliasContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_alias
	return p
}

func (*AliasContext) IsAliasContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_alias

	return p
}

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

func (s *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 *AliasContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *AliasContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterAlias(s)
	}
}

func (s *AliasContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitAlias(s)
	}
}

func (p *SQLiteParser) Alias() (localctx IAliasContext) {
	this := p
	_ = this

	localctx = NewAliasContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 208, SQLiteParserRULE_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(2024)
		p.Any_name()
	}

	return localctx
}

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

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

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

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

func NewEmptyFilenameContext() *FilenameContext {
	var p = new(FilenameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_filename
	return p
}

func (*FilenameContext) IsFilenameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_filename

	return p
}

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

func (s *FilenameContext) 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 *FilenameContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *FilenameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterFilename(s)
	}
}

func (s *FilenameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitFilename(s)
	}
}

func (p *SQLiteParser) Filename() (localctx IFilenameContext) {
	this := p
	_ = this

	localctx = NewFilenameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 210, SQLiteParserRULE_filename)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2026)
		p.Any_name()
	}

	return localctx
}

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

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

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

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

func NewEmptyBase_window_nameContext() *Base_window_nameContext {
	var p = new(Base_window_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_base_window_name
	return p
}

func (*Base_window_nameContext) IsBase_window_nameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_base_window_name

	return p
}

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

func (s *Base_window_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 *Base_window_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *Base_window_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterBase_window_name(s)
	}
}

func (s *Base_window_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitBase_window_name(s)
	}
}

func (p *SQLiteParser) Base_window_name() (localctx IBase_window_nameContext) {
	this := p
	_ = this

	localctx = NewBase_window_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 212, SQLiteParserRULE_base_window_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(2028)
		p.Any_name()
	}

	return localctx
}

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

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

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

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

func NewEmptySimple_funcContext() *Simple_funcContext {
	var p = new(Simple_funcContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_simple_func
	return p
}

func (*Simple_funcContext) IsSimple_funcContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_simple_func

	return p
}

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

func (s *Simple_funcContext) 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 *Simple_funcContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *Simple_funcContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterSimple_func(s)
	}
}

func (s *Simple_funcContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitSimple_func(s)
	}
}

func (p *SQLiteParser) Simple_func() (localctx ISimple_funcContext) {
	this := p
	_ = this

	localctx = NewSimple_funcContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 214, SQLiteParserRULE_simple_func)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2030)
		p.Any_name()
	}

	return localctx
}

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

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

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

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

func NewEmptyAggregate_funcContext() *Aggregate_funcContext {
	var p = new(Aggregate_funcContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_aggregate_func
	return p
}

func (*Aggregate_funcContext) IsAggregate_funcContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_aggregate_func

	return p
}

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

func (s *Aggregate_funcContext) 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 *Aggregate_funcContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *Aggregate_funcContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterAggregate_func(s)
	}
}

func (s *Aggregate_funcContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitAggregate_func(s)
	}
}

func (p *SQLiteParser) Aggregate_func() (localctx IAggregate_funcContext) {
	this := p
	_ = this

	localctx = NewAggregate_funcContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 216, SQLiteParserRULE_aggregate_func)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(2032)
		p.Any_name()
	}

	return localctx
}

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

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

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

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

func NewEmptyTable_function_nameContext() *Table_function_nameContext {
	var p = new(Table_function_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_table_function_name
	return p
}

func (*Table_function_nameContext) IsTable_function_nameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_table_function_name

	return p
}

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

func (s *Table_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 *Table_function_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

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

func (s *Table_function_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.EnterTable_function_name(s)
	}
}

func (s *Table_function_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitTable_function_name(s)
	}
}

func (p *SQLiteParser) Table_function_name() (localctx ITable_function_nameContext) {
	this := p
	_ = this

	localctx = NewTable_function_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 218, SQLiteParserRULE_table_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(2034)
		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 = SQLiteParserRULE_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 = SQLiteParserRULE_any_name

	return p
}

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

func (s *Any_nameContext) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIDENTIFIER, 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(SQLiteParserSTRING_LITERAL, 0)
}

func (s *Any_nameContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_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(SQLiteParserCLOSE_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.(SQLiteParserListener); ok {
		listenerT.EnterAny_name(s)
	}
}

func (s *Any_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteParserListener); ok {
		listenerT.ExitAny_name(s)
	}
}

func (p *SQLiteParser) Any_name() (localctx IAny_nameContext) {
	this := p
	_ = this

	localctx = NewAny_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 220, SQLiteParserRULE_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(2043)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(2036)
			p.Match(SQLiteParserIDENTIFIER)
		}

	case SQLiteParserABORT_, SQLiteParserACTION_, SQLiteParserADD_, SQLiteParserAFTER_, SQLiteParserALL_, SQLiteParserALTER_, SQLiteParserANALYZE_, SQLiteParserAND_, SQLiteParserAS_, SQLiteParserASC_, SQLiteParserATTACH_, SQLiteParserAUTOINCREMENT_, SQLiteParserBEFORE_, SQLiteParserBEGIN_, SQLiteParserBETWEEN_, SQLiteParserBY_, SQLiteParserCASCADE_, SQLiteParserCASE_, SQLiteParserCAST_, SQLiteParserCHECK_, SQLiteParserCOLLATE_, SQLiteParserCOLUMN_, SQLiteParserCOMMIT_, SQLiteParserCONFLICT_, SQLiteParserCONSTRAINT_, SQLiteParserCREATE_, SQLiteParserCROSS_, SQLiteParserCURRENT_DATE_, SQLiteParserCURRENT_TIME_, SQLiteParserCURRENT_TIMESTAMP_, SQLiteParserDATABASE_, SQLiteParserDEFAULT_, SQLiteParserDEFERRABLE_, SQLiteParserDEFERRED_, SQLiteParserDELETE_, SQLiteParserDESC_, SQLiteParserDETACH_, SQLiteParserDISTINCT_, SQLiteParserDROP_, SQLiteParserEACH_, SQLiteParserELSE_, SQLiteParserEND_, SQLiteParserESCAPE_, SQLiteParserEXCEPT_, SQLiteParserEXCLUSIVE_, SQLiteParserEXISTS_, SQLiteParserEXPLAIN_, SQLiteParserFAIL_, SQLiteParserFOR_, SQLiteParserFOREIGN_, SQLiteParserFROM_, SQLiteParserFULL_, SQLiteParserGLOB_, SQLiteParserGROUP_, SQLiteParserHAVING_, SQLiteParserIF_, SQLiteParserIGNORE_, SQLiteParserIMMEDIATE_, SQLiteParserIN_, SQLiteParserINDEX_, SQLiteParserINDEXED_, SQLiteParserINITIALLY_, SQLiteParserINNER_, SQLiteParserINSERT_, SQLiteParserINSTEAD_, SQLiteParserINTERSECT_, SQLiteParserINTO_, SQLiteParserIS_, SQLiteParserISNULL_, SQLiteParserJOIN_, SQLiteParserKEY_, SQLiteParserLEFT_, SQLiteParserLIKE_, SQLiteParserLIMIT_, SQLiteParserMATCH_, SQLiteParserNATURAL_, SQLiteParserNO_, SQLiteParserNOT_, SQLiteParserNOTNULL_, SQLiteParserNULL_, SQLiteParserOF_, SQLiteParserOFFSET_, SQLiteParserON_, SQLiteParserOR_, SQLiteParserORDER_, SQLiteParserOUTER_, SQLiteParserPLAN_, SQLiteParserPRAGMA_, SQLiteParserPRIMARY_, SQLiteParserQUERY_, SQLiteParserRAISE_, SQLiteParserRECURSIVE_, SQLiteParserREFERENCES_, SQLiteParserREGEXP_, SQLiteParserREINDEX_, SQLiteParserRELEASE_, SQLiteParserRENAME_, SQLiteParserREPLACE_, SQLiteParserRESTRICT_, SQLiteParserRIGHT_, SQLiteParserROLLBACK_, SQLiteParserROW_, SQLiteParserROWS_, SQLiteParserSAVEPOINT_, SQLiteParserSELECT_, SQLiteParserSET_, SQLiteParserTABLE_, SQLiteParserTEMP_, SQLiteParserTEMPORARY_, SQLiteParserTHEN_, SQLiteParserTO_, SQLiteParserTRANSACTION_, SQLiteParserTRIGGER_, SQLiteParserUNION_, SQLiteParserUNIQUE_, SQLiteParserUPDATE_, SQLiteParserUSING_, SQLiteParserVACUUM_, SQLiteParserVALUES_, SQLiteParserVIEW_, SQLiteParserVIRTUAL_, SQLiteParserWHEN_, SQLiteParserWHERE_, SQLiteParserWITH_, SQLiteParserWITHOUT_, SQLiteParserFIRST_VALUE_, SQLiteParserOVER_, SQLiteParserPARTITION_, SQLiteParserRANGE_, SQLiteParserPRECEDING_, SQLiteParserUNBOUNDED_, SQLiteParserCURRENT_, SQLiteParserFOLLOWING_, SQLiteParserCUME_DIST_, SQLiteParserDENSE_RANK_, SQLiteParserLAG_, SQLiteParserLAST_VALUE_, SQLiteParserLEAD_, SQLiteParserNTH_VALUE_, SQLiteParserNTILE_, SQLiteParserPERCENT_RANK_, SQLiteParserRANK_, SQLiteParserROW_NUMBER_, SQLiteParserGENERATED_, SQLiteParserALWAYS_, SQLiteParserSTORED_, SQLiteParserTRUE_, SQLiteParserFALSE_, SQLiteParserWINDOW_, SQLiteParserNULLS_, SQLiteParserFIRST_, SQLiteParserLAST_, SQLiteParserFILTER_, SQLiteParserGROUPS_, SQLiteParserEXCLUDE_:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(2037)
			p.Keyword()
		}

	case SQLiteParserSTRING_LITERAL:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(2038)
			p.Match(SQLiteParserSTRING_LITERAL)
		}

	case SQLiteParserOPEN_PAR:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(2039)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(2040)
			p.Any_name()
		}
		{
			p.SetState(2041)
			p.Match(SQLiteParserCLOSE_PAR)
		}

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

	return localctx
}

func (p *SQLiteParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
	switch ruleIndex {
	case 32:
		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 *SQLiteParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool {
	this := p
	_ = this

	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))
	}
}
