// Code generated from SQLite.g4 by ANTLR 4.8. DO NOT EDIT.

package parser // SQLite

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

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

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

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

type SQLiteParser struct {
	*antlr.BaseParser
}

func NewSQLiteParser(input antlr.TokenStream) *SQLiteParser {
	this := new(SQLiteParser)

	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 = "SQLite.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
	SQLiteParserK_ABORT             = 25
	SQLiteParserK_ACTION            = 26
	SQLiteParserK_ADD               = 27
	SQLiteParserK_AFTER             = 28
	SQLiteParserK_ALL               = 29
	SQLiteParserK_ALTER             = 30
	SQLiteParserK_ANALYZE           = 31
	SQLiteParserK_AND               = 32
	SQLiteParserK_AS                = 33
	SQLiteParserK_ASC               = 34
	SQLiteParserK_ATTACH            = 35
	SQLiteParserK_AUTOINCREMENT     = 36
	SQLiteParserK_BEFORE            = 37
	SQLiteParserK_BEGIN             = 38
	SQLiteParserK_BETWEEN           = 39
	SQLiteParserK_BY                = 40
	SQLiteParserK_CASCADE           = 41
	SQLiteParserK_CASE              = 42
	SQLiteParserK_CAST              = 43
	SQLiteParserK_CHECK             = 44
	SQLiteParserK_COLLATE           = 45
	SQLiteParserK_COLUMN            = 46
	SQLiteParserK_COMMIT            = 47
	SQLiteParserK_CONFLICT          = 48
	SQLiteParserK_CONSTRAINT        = 49
	SQLiteParserK_CREATE            = 50
	SQLiteParserK_CROSS             = 51
	SQLiteParserK_CURRENT_DATE      = 52
	SQLiteParserK_CURRENT_TIME      = 53
	SQLiteParserK_CURRENT_TIMESTAMP = 54
	SQLiteParserK_DATABASE          = 55
	SQLiteParserK_DEFAULT           = 56
	SQLiteParserK_DEFERRABLE        = 57
	SQLiteParserK_DEFERRED          = 58
	SQLiteParserK_DELETE            = 59
	SQLiteParserK_DESC              = 60
	SQLiteParserK_DETACH            = 61
	SQLiteParserK_DISTINCT          = 62
	SQLiteParserK_DROP              = 63
	SQLiteParserK_EACH              = 64
	SQLiteParserK_ELSE              = 65
	SQLiteParserK_END               = 66
	SQLiteParserK_ESCAPE            = 67
	SQLiteParserK_EXCEPT            = 68
	SQLiteParserK_EXCLUSIVE         = 69
	SQLiteParserK_EXISTS            = 70
	SQLiteParserK_EXPLAIN           = 71
	SQLiteParserK_FAIL              = 72
	SQLiteParserK_FOR               = 73
	SQLiteParserK_FOREIGN           = 74
	SQLiteParserK_FROM              = 75
	SQLiteParserK_FULL              = 76
	SQLiteParserK_GLOB              = 77
	SQLiteParserK_GROUP             = 78
	SQLiteParserK_HAVING            = 79
	SQLiteParserK_IF                = 80
	SQLiteParserK_IGNORE            = 81
	SQLiteParserK_IMMEDIATE         = 82
	SQLiteParserK_IN                = 83
	SQLiteParserK_INDEX             = 84
	SQLiteParserK_INDEXED           = 85
	SQLiteParserK_INITIALLY         = 86
	SQLiteParserK_INNER             = 87
	SQLiteParserK_INSERT            = 88
	SQLiteParserK_INSTEAD           = 89
	SQLiteParserK_INTERSECT         = 90
	SQLiteParserK_INTO              = 91
	SQLiteParserK_IS                = 92
	SQLiteParserK_ISNULL            = 93
	SQLiteParserK_JOIN              = 94
	SQLiteParserK_KEY               = 95
	SQLiteParserK_LEFT              = 96
	SQLiteParserK_LIKE              = 97
	SQLiteParserK_LIMIT             = 98
	SQLiteParserK_MATCH             = 99
	SQLiteParserK_NATURAL           = 100
	SQLiteParserK_NO                = 101
	SQLiteParserK_NOT               = 102
	SQLiteParserK_NOTNULL           = 103
	SQLiteParserK_NULL              = 104
	SQLiteParserK_OF                = 105
	SQLiteParserK_OFFSET            = 106
	SQLiteParserK_ON                = 107
	SQLiteParserK_OR                = 108
	SQLiteParserK_ORDER             = 109
	SQLiteParserK_OUTER             = 110
	SQLiteParserK_PLAN              = 111
	SQLiteParserK_PRAGMA            = 112
	SQLiteParserK_PRIMARY           = 113
	SQLiteParserK_QUERY             = 114
	SQLiteParserK_RAISE             = 115
	SQLiteParserK_RECURSIVE         = 116
	SQLiteParserK_REFERENCES        = 117
	SQLiteParserK_REGEXP            = 118
	SQLiteParserK_REINDEX           = 119
	SQLiteParserK_RELEASE           = 120
	SQLiteParserK_RENAME            = 121
	SQLiteParserK_REPLACE           = 122
	SQLiteParserK_RESTRICT          = 123
	SQLiteParserK_RIGHT             = 124
	SQLiteParserK_ROLLBACK          = 125
	SQLiteParserK_ROW               = 126
	SQLiteParserK_SAVEPOINT         = 127
	SQLiteParserK_SELECT            = 128
	SQLiteParserK_SET               = 129
	SQLiteParserK_TABLE             = 130
	SQLiteParserK_TEMP              = 131
	SQLiteParserK_TEMPORARY         = 132
	SQLiteParserK_THEN              = 133
	SQLiteParserK_TO                = 134
	SQLiteParserK_TRANSACTION       = 135
	SQLiteParserK_TRIGGER           = 136
	SQLiteParserK_UNION             = 137
	SQLiteParserK_UNIQUE            = 138
	SQLiteParserK_UPDATE            = 139
	SQLiteParserK_USING             = 140
	SQLiteParserK_VACUUM            = 141
	SQLiteParserK_VALUES            = 142
	SQLiteParserK_VIEW              = 143
	SQLiteParserK_VIRTUAL           = 144
	SQLiteParserK_WHEN              = 145
	SQLiteParserK_WHERE             = 146
	SQLiteParserK_WITH              = 147
	SQLiteParserK_WITHOUT           = 148
	SQLiteParserIDENTIFIER          = 149
	SQLiteParserNUMERIC_LITERAL     = 150
	SQLiteParserBIND_PARAMETER      = 151
	SQLiteParserSTRING_LITERAL      = 152
	SQLiteParserBLOB_LITERAL        = 153
	SQLiteParserSINGLE_LINE_COMMENT = 154
	SQLiteParserMULTILINE_COMMENT   = 155
	SQLiteParserSPACES              = 156
	SQLiteParserUNEXPECTED_CHAR     = 157
)

// 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_compound_select_stmt      = 8
	SQLiteParserRULE_create_index_stmt         = 9
	SQLiteParserRULE_create_table_stmt         = 10
	SQLiteParserRULE_create_trigger_stmt       = 11
	SQLiteParserRULE_create_view_stmt          = 12
	SQLiteParserRULE_create_virtual_table_stmt = 13
	SQLiteParserRULE_delete_stmt               = 14
	SQLiteParserRULE_delete_stmt_limited       = 15
	SQLiteParserRULE_detach_stmt               = 16
	SQLiteParserRULE_drop_index_stmt           = 17
	SQLiteParserRULE_drop_table_stmt           = 18
	SQLiteParserRULE_drop_trigger_stmt         = 19
	SQLiteParserRULE_drop_view_stmt            = 20
	SQLiteParserRULE_factored_select_stmt      = 21
	SQLiteParserRULE_insert_stmt               = 22
	SQLiteParserRULE_pragma_stmt               = 23
	SQLiteParserRULE_reindex_stmt              = 24
	SQLiteParserRULE_release_stmt              = 25
	SQLiteParserRULE_rollback_stmt             = 26
	SQLiteParserRULE_savepoint_stmt            = 27
	SQLiteParserRULE_simple_select_stmt        = 28
	SQLiteParserRULE_select_stmt               = 29
	SQLiteParserRULE_select_or_values          = 30
	SQLiteParserRULE_update_stmt               = 31
	SQLiteParserRULE_update_stmt_limited       = 32
	SQLiteParserRULE_vacuum_stmt               = 33
	SQLiteParserRULE_column_def                = 34
	SQLiteParserRULE_type_name                 = 35
	SQLiteParserRULE_column_constraint         = 36
	SQLiteParserRULE_conflict_clause           = 37
	SQLiteParserRULE_expr                      = 38
	SQLiteParserRULE_foreign_key_clause        = 39
	SQLiteParserRULE_raise_function            = 40
	SQLiteParserRULE_indexed_column            = 41
	SQLiteParserRULE_table_constraint          = 42
	SQLiteParserRULE_with_clause               = 43
	SQLiteParserRULE_qualified_table_name      = 44
	SQLiteParserRULE_ordering_term             = 45
	SQLiteParserRULE_pragma_value              = 46
	SQLiteParserRULE_common_table_expression   = 47
	SQLiteParserRULE_result_column             = 48
	SQLiteParserRULE_table_or_subquery         = 49
	SQLiteParserRULE_join_clause               = 50
	SQLiteParserRULE_join_operator             = 51
	SQLiteParserRULE_join_constraint           = 52
	SQLiteParserRULE_select_core               = 53
	SQLiteParserRULE_compound_operator         = 54
	SQLiteParserRULE_signed_number             = 55
	SQLiteParserRULE_literal_value             = 56
	SQLiteParserRULE_unary_operator            = 57
	SQLiteParserRULE_error_message             = 58
	SQLiteParserRULE_module_argument           = 59
	SQLiteParserRULE_column_alias              = 60
	SQLiteParserRULE_keyword                   = 61
	SQLiteParserRULE_name                      = 62
	SQLiteParserRULE_function_name             = 63
	SQLiteParserRULE_database_name             = 64
	SQLiteParserRULE_schema_name               = 65
	SQLiteParserRULE_table_function_name       = 66
	SQLiteParserRULE_table_name                = 67
	SQLiteParserRULE_table_or_index_name       = 68
	SQLiteParserRULE_new_table_name            = 69
	SQLiteParserRULE_column_name               = 70
	SQLiteParserRULE_new_column_name           = 71
	SQLiteParserRULE_collation_name            = 72
	SQLiteParserRULE_foreign_table             = 73
	SQLiteParserRULE_index_name                = 74
	SQLiteParserRULE_trigger_name              = 75
	SQLiteParserRULE_view_name                 = 76
	SQLiteParserRULE_module_name               = 77
	SQLiteParserRULE_pragma_name               = 78
	SQLiteParserRULE_savepoint_name            = 79
	SQLiteParserRULE_table_alias               = 80
	SQLiteParserRULE_transaction_name          = 81
	SQLiteParserRULE_any_name                  = 82
)

// 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.(SQLiteListener); ok {
		listenerT.EnterParse(s)
	}
}

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

func (p *SQLiteParser) Parse() (localctx IParseContext) {
	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(169)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for (((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SQLiteParserSCOL)|(1<<SQLiteParserK_ALTER)|(1<<SQLiteParserK_ANALYZE))) != 0) || (((_la-35)&-(0x1f+1)) == 0 && ((1<<uint((_la-35)))&((1<<(SQLiteParserK_ATTACH-35))|(1<<(SQLiteParserK_BEGIN-35))|(1<<(SQLiteParserK_COMMIT-35))|(1<<(SQLiteParserK_CREATE-35))|(1<<(SQLiteParserK_DELETE-35))|(1<<(SQLiteParserK_DETACH-35))|(1<<(SQLiteParserK_DROP-35))|(1<<(SQLiteParserK_END-35)))) != 0) || _la == SQLiteParserK_EXPLAIN || _la == SQLiteParserK_INSERT || (((_la-112)&-(0x1f+1)) == 0 && ((1<<uint((_la-112)))&((1<<(SQLiteParserK_PRAGMA-112))|(1<<(SQLiteParserK_REINDEX-112))|(1<<(SQLiteParserK_RELEASE-112))|(1<<(SQLiteParserK_REPLACE-112))|(1<<(SQLiteParserK_ROLLBACK-112))|(1<<(SQLiteParserK_SAVEPOINT-112))|(1<<(SQLiteParserK_SELECT-112))|(1<<(SQLiteParserK_UPDATE-112))|(1<<(SQLiteParserK_VACUUM-112))|(1<<(SQLiteParserK_VALUES-112)))) != 0) || _la == SQLiteParserK_WITH {
		{
			p.SetState(166)
			p.Sql_stmt_list()
		}

		p.SetState(171)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(172)
		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.(SQLiteListener); ok {
		listenerT.EnterSql_stmt_list(s)
	}
}

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

func (p *SQLiteParser) Sql_stmt_list() (localctx ISql_stmt_listContext) {
	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(177)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

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

		p.SetState(179)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(180)
		p.Sql_stmt()
	}
	p.SetState(189)
	p.GetErrorHandler().Sync(p)
	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 3, p.GetParserRuleContext())

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

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

				p.SetState(184)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)
			}
			{
				p.SetState(186)
				p.Sql_stmt()
			}

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

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

		}
		p.SetState(197)
		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) Compound_select_stmt() ICompound_select_stmtContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompound_select_stmtContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICompound_select_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ICreate_index_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ICreate_table_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ICreate_trigger_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ICreate_view_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ICreate_virtual_table_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IDelete_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IDelete_stmt_limitedContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IDetach_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IDrop_index_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IDrop_table_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IDrop_trigger_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IDrop_view_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IFactored_select_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IInsert_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IPragma_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IReindex_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IRelease_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IRollback_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ISavepoint_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ISimple_select_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IUpdate_stmtContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IUpdate_stmt_limitedContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IVacuum_stmtContext)
}

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

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

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

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

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

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

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

func (p *SQLiteParser) Sql_stmt() (localctx ISql_stmtContext) {
	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(203)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_EXPLAIN {
		{
			p.SetState(198)
			p.Match(SQLiteParserK_EXPLAIN)
		}
		p.SetState(201)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserK_QUERY {
			{
				p.SetState(199)
				p.Match(SQLiteParserK_QUERY)
			}
			{
				p.SetState(200)
				p.Match(SQLiteParserK_PLAN)
			}

		}

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

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

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

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

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

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

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

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

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

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

	case 11:
		{
			p.SetState(215)
			p.Create_virtual_table_stmt()
		}

	case 12:
		{
			p.SetState(216)
			p.Delete_stmt()
		}

	case 13:
		{
			p.SetState(217)
			p.Delete_stmt_limited()
		}

	case 14:
		{
			p.SetState(218)
			p.Detach_stmt()
		}

	case 15:
		{
			p.SetState(219)
			p.Drop_index_stmt()
		}

	case 16:
		{
			p.SetState(220)
			p.Drop_table_stmt()
		}

	case 17:
		{
			p.SetState(221)
			p.Drop_trigger_stmt()
		}

	case 18:
		{
			p.SetState(222)
			p.Drop_view_stmt()
		}

	case 19:
		{
			p.SetState(223)
			p.Factored_select_stmt()
		}

	case 20:
		{
			p.SetState(224)
			p.Insert_stmt()
		}

	case 21:
		{
			p.SetState(225)
			p.Pragma_stmt()
		}

	case 22:
		{
			p.SetState(226)
			p.Reindex_stmt()
		}

	case 23:
		{
			p.SetState(227)
			p.Release_stmt()
		}

	case 24:
		{
			p.SetState(228)
			p.Rollback_stmt()
		}

	case 25:
		{
			p.SetState(229)
			p.Savepoint_stmt()
		}

	case 26:
		{
			p.SetState(230)
			p.Simple_select_stmt()
		}

	case 27:
		{
			p.SetState(231)
			p.Select_stmt()
		}

	case 28:
		{
			p.SetState(232)
			p.Update_stmt()
		}

	case 29:
		{
			p.SetState(233)
			p.Update_stmt_limited()
		}

	case 30:
		{
			p.SetState(234)
			p.Vacuum_stmt()
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyAlter_table_stmtContext() *Alter_table_stmtContext {
	var p = new(Alter_table_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_ALTER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ALTER, 0)
}

func (s *Alter_table_stmtContext) K_TABLE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_TABLE, 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) K_RENAME() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_RENAME, 0)
}

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

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

	if t == nil {
		return nil
	}

	return t.(INew_table_nameContext)
}

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

	if t == nil {
		return nil
	}

	return t.(INew_column_nameContext)
}

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

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

	if t == nil {
		return nil
	}

	return t.(IColumn_defContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

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

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

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

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

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

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

func (p *SQLiteParser) Alter_table_stmt() (localctx IAlter_table_stmtContext) {
	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(237)
		p.Match(SQLiteParserK_ALTER)
	}
	{
		p.SetState(238)
		p.Match(SQLiteParserK_TABLE)
	}
	p.SetState(242)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 8, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(239)
			p.Database_name()
		}
		{
			p.SetState(240)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(244)
		p.Table_name()
	}
	p.SetState(261)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 11, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(245)
			p.Match(SQLiteParserK_RENAME)
		}
		{
			p.SetState(246)
			p.Match(SQLiteParserK_TO)
		}
		{
			p.SetState(247)
			p.New_table_name()
		}

	case 2:
		{
			p.SetState(248)
			p.Match(SQLiteParserK_RENAME)
		}
		p.SetState(250)
		p.GetErrorHandler().Sync(p)

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

		}
		{
			p.SetState(252)
			p.Column_name()
		}
		{
			p.SetState(253)
			p.Match(SQLiteParserK_TO)
		}
		{
			p.SetState(254)
			p.New_column_name()
		}

	case 3:
		{
			p.SetState(256)
			p.Match(SQLiteParserK_ADD)
		}
		p.SetState(258)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 10, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(257)
				p.Match(SQLiteParserK_COLUMN)
			}

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

	}

	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) K_ANALYZE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ANALYZE, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ITable_or_index_nameContext)
}

func (s *Analyze_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(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.(SQLiteListener); ok {
		listenerT.EnterAnalyze_stmt(s)
	}
}

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

func (p *SQLiteParser) Analyze_stmt() (localctx IAnalyze_stmtContext) {
	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(263)
		p.Match(SQLiteParserK_ANALYZE)
	}
	p.SetState(270)
	p.GetErrorHandler().Sync(p)

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

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

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 12, p.GetParserRuleContext()) == 3 {
		{
			p.SetState(266)
			p.Database_name()
		}
		{
			p.SetState(267)
			p.Match(SQLiteParserDOT)
		}
		{
			p.SetState(268)
			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) K_ATTACH() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ATTACH, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

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

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

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

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

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

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

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

func (p *SQLiteParser) Attach_stmt() (localctx IAttach_stmtContext) {
	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(272)
		p.Match(SQLiteParserK_ATTACH)
	}
	p.SetState(274)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 13, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(273)
			p.Match(SQLiteParserK_DATABASE)
		}

	}
	{
		p.SetState(276)
		p.expr(0)
	}
	{
		p.SetState(277)
		p.Match(SQLiteParserK_AS)
	}
	{
		p.SetState(278)
		p.Database_name()
	}

	return localctx
}

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

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

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

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

func NewEmptyBegin_stmtContext() *Begin_stmtContext {
	var p = new(Begin_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_BEGIN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_BEGIN, 0)
}

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

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

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

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

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

	if t == nil {
		return nil
	}

	return t.(ITransaction_nameContext)
}

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

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

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

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

func (p *SQLiteParser) Begin_stmt() (localctx IBegin_stmtContext) {
	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(280)
		p.Match(SQLiteParserK_BEGIN)
	}
	p.SetState(282)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if ((_la-58)&-(0x1f+1)) == 0 && ((1<<uint((_la-58)))&((1<<(SQLiteParserK_DEFERRED-58))|(1<<(SQLiteParserK_EXCLUSIVE-58))|(1<<(SQLiteParserK_IMMEDIATE-58)))) != 0 {
		{
			p.SetState(281)
			_la = p.GetTokenStream().LA(1)

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

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

	if _la == SQLiteParserK_TRANSACTION {
		{
			p.SetState(284)
			p.Match(SQLiteParserK_TRANSACTION)
		}
		p.SetState(286)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 15, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(285)
				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) K_COMMIT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_COMMIT, 0)
}

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

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

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

	if t == nil {
		return nil
	}

	return t.(ITransaction_nameContext)
}

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

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

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

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

func (p *SQLiteParser) Commit_stmt() (localctx ICommit_stmtContext) {
	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(290)
		_la = p.GetTokenStream().LA(1)

		if !(_la == SQLiteParserK_COMMIT || _la == SQLiteParserK_END) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}
	p.SetState(295)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_TRANSACTION {
		{
			p.SetState(291)
			p.Match(SQLiteParserK_TRANSACTION)
		}
		p.SetState(293)
		p.GetErrorHandler().Sync(p)

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

		}

	}

	return localctx
}

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

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

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

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

func NewEmptyCompound_select_stmtContext() *Compound_select_stmtContext {
	var p = new(Compound_select_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) 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 *Compound_select_stmtContext) K_ORDER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ORDER, 0)
}

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

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IOrdering_termContext)
}

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

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (p *SQLiteParser) Compound_select_stmt() (localctx ICompound_select_stmtContext) {
	localctx = NewCompound_select_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 16, 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(298)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_WITH {
		{
			p.SetState(297)
			p.With_clause()
		}

	}
	{
		p.SetState(300)
		p.Select_core()
	}
	p.SetState(310)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == SQLiteParserK_EXCEPT || _la == SQLiteParserK_INTERSECT || _la == SQLiteParserK_UNION {
		p.SetState(307)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SQLiteParserK_UNION:
			{
				p.SetState(301)
				p.Match(SQLiteParserK_UNION)
			}
			p.SetState(303)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == SQLiteParserK_ALL {
				{
					p.SetState(302)
					p.Match(SQLiteParserK_ALL)
				}

			}

		case SQLiteParserK_INTERSECT:
			{
				p.SetState(305)
				p.Match(SQLiteParserK_INTERSECT)
			}

		case SQLiteParserK_EXCEPT:
			{
				p.SetState(306)
				p.Match(SQLiteParserK_EXCEPT)
			}

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

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

	if _la == SQLiteParserK_ORDER {
		{
			p.SetState(314)
			p.Match(SQLiteParserK_ORDER)
		}
		{
			p.SetState(315)
			p.Match(SQLiteParserK_BY)
		}
		{
			p.SetState(316)
			p.Ordering_term()
		}
		p.SetState(321)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(317)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(318)
				p.Ordering_term()
			}

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

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

	if _la == SQLiteParserK_LIMIT {
		{
			p.SetState(326)
			p.Match(SQLiteParserK_LIMIT)
		}
		{
			p.SetState(327)
			p.expr(0)
		}
		p.SetState(330)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserCOMMA || _la == SQLiteParserK_OFFSET {
			{
				p.SetState(328)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SQLiteParserCOMMA || _la == SQLiteParserK_OFFSET) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(329)
				p.expr(0)
			}

		}

	}

	return localctx
}

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

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

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

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

func NewEmptyCreate_index_stmtContext() *Create_index_stmtContext {
	var p = new(Create_index_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_CREATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CREATE, 0)
}

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

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

	if t == nil {
		return nil
	}

	return t.(IIndex_nameContext)
}

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

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

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Create_index_stmtContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(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) K_UNIQUE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_UNIQUE, 0)
}

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

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

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

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Create_index_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(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) K_WHERE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_WHERE, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

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

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

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

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

func (p *SQLiteParser) Create_index_stmt() (localctx ICreate_index_stmtContext) {
	localctx = NewCreate_index_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 18, 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(334)
		p.Match(SQLiteParserK_CREATE)
	}
	p.SetState(336)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_UNIQUE {
		{
			p.SetState(335)
			p.Match(SQLiteParserK_UNIQUE)
		}

	}
	{
		p.SetState(338)
		p.Match(SQLiteParserK_INDEX)
	}
	p.SetState(342)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 28, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(339)
			p.Match(SQLiteParserK_IF)
		}
		{
			p.SetState(340)
			p.Match(SQLiteParserK_NOT)
		}
		{
			p.SetState(341)
			p.Match(SQLiteParserK_EXISTS)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 29, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(344)
			p.Database_name()
		}
		{
			p.SetState(345)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(349)
		p.Index_name()
	}
	{
		p.SetState(350)
		p.Match(SQLiteParserK_ON)
	}
	{
		p.SetState(351)
		p.Table_name()
	}
	{
		p.SetState(352)
		p.Match(SQLiteParserOPEN_PAR)
	}
	{
		p.SetState(353)
		p.Indexed_column()
	}
	p.SetState(358)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserCOMMA {
		{
			p.SetState(354)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(355)
			p.Indexed_column()
		}

		p.SetState(360)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(361)
		p.Match(SQLiteParserCLOSE_PAR)
	}
	p.SetState(364)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_WHERE {
		{
			p.SetState(362)
			p.Match(SQLiteParserK_WHERE)
		}
		{
			p.SetState(363)
			p.expr(0)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyCreate_table_stmtContext() *Create_table_stmtContext {
	var p = new(Create_table_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_CREATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CREATE, 0)
}

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

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

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Create_table_stmtContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(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) K_AS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_AS, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

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

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

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

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

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

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

func (s *Create_table_stmtContext) K_TEMPORARY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_TEMPORARY, 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) K_WITHOUT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_WITHOUT, 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.(SQLiteListener); ok {
		listenerT.EnterCreate_table_stmt(s)
	}
}

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

func (p *SQLiteParser) Create_table_stmt() (localctx ICreate_table_stmtContext) {
	localctx = NewCreate_table_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 20, 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(366)
		p.Match(SQLiteParserK_CREATE)
	}
	p.SetState(368)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_TEMP || _la == SQLiteParserK_TEMPORARY {
		{
			p.SetState(367)
			_la = p.GetTokenStream().LA(1)

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

	}
	{
		p.SetState(370)
		p.Match(SQLiteParserK_TABLE)
	}
	p.SetState(374)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 33, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(371)
			p.Match(SQLiteParserK_IF)
		}
		{
			p.SetState(372)
			p.Match(SQLiteParserK_NOT)
		}
		{
			p.SetState(373)
			p.Match(SQLiteParserK_EXISTS)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 34, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(376)
			p.Database_name()
		}
		{
			p.SetState(377)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(381)
		p.Table_name()
	}
	p.SetState(405)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserOPEN_PAR:
		{
			p.SetState(382)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(383)
			p.Column_def()
		}
		p.SetState(388)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 35, p.GetParserRuleContext())

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

			}
			p.SetState(390)
			p.GetErrorHandler().Sync(p)
			_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 35, p.GetParserRuleContext())
		}
		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.Table_constraint()
			}

			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 == SQLiteParserK_WITHOUT {
			{
				p.SetState(399)
				p.Match(SQLiteParserK_WITHOUT)
			}
			{
				p.SetState(400)
				p.Match(SQLiteParserIDENTIFIER)
			}

		}

	case SQLiteParserK_AS:
		{
			p.SetState(403)
			p.Match(SQLiteParserK_AS)
		}
		{
			p.SetState(404)
			p.Select_stmt()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyCreate_trigger_stmtContext() *Create_trigger_stmtContext {
	var p = new(Create_trigger_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_CREATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CREATE, 0)
}

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

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

	if t == nil {
		return nil
	}

	return t.(ITrigger_nameContext)
}

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

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

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

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

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

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

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

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

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

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

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

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

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

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

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

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

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

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

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

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

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

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

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

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

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

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

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

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

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IUpdate_stmtContext)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IInsert_stmtContext)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IDelete_stmtContext)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

func (s *Create_trigger_stmtContext) AllCOMMA() []antlr.TerminalNode {
	return s.GetTokens(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.(SQLiteListener); ok {
		listenerT.EnterCreate_trigger_stmt(s)
	}
}

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

func (p *SQLiteParser) Create_trigger_stmt() (localctx ICreate_trigger_stmtContext) {
	localctx = NewCreate_trigger_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 22, 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(407)
		p.Match(SQLiteParserK_CREATE)
	}
	p.SetState(409)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_TEMP || _la == SQLiteParserK_TEMPORARY {
		{
			p.SetState(408)
			_la = p.GetTokenStream().LA(1)

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

	}
	{
		p.SetState(411)
		p.Match(SQLiteParserK_TRIGGER)
	}
	p.SetState(415)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 40, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(412)
			p.Match(SQLiteParserK_IF)
		}
		{
			p.SetState(413)
			p.Match(SQLiteParserK_NOT)
		}
		{
			p.SetState(414)
			p.Match(SQLiteParserK_EXISTS)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 41, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(417)
			p.Database_name()
		}
		{
			p.SetState(418)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(422)
		p.Trigger_name()
	}
	p.SetState(427)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserK_BEFORE:
		{
			p.SetState(423)
			p.Match(SQLiteParserK_BEFORE)
		}

	case SQLiteParserK_AFTER:
		{
			p.SetState(424)
			p.Match(SQLiteParserK_AFTER)
		}

	case SQLiteParserK_INSTEAD:
		{
			p.SetState(425)
			p.Match(SQLiteParserK_INSTEAD)
		}
		{
			p.SetState(426)
			p.Match(SQLiteParserK_OF)
		}

	case SQLiteParserK_DELETE, SQLiteParserK_INSERT, SQLiteParserK_UPDATE:

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

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserK_DELETE:
		{
			p.SetState(429)
			p.Match(SQLiteParserK_DELETE)
		}

	case SQLiteParserK_INSERT:
		{
			p.SetState(430)
			p.Match(SQLiteParserK_INSERT)
		}

	case SQLiteParserK_UPDATE:
		{
			p.SetState(431)
			p.Match(SQLiteParserK_UPDATE)
		}
		p.SetState(441)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserK_OF {
			{
				p.SetState(432)
				p.Match(SQLiteParserK_OF)
			}
			{
				p.SetState(433)
				p.Column_name()
			}
			p.SetState(438)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(434)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(435)
					p.Column_name()
				}

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

		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(445)
		p.Match(SQLiteParserK_ON)
	}
	p.SetState(449)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 46, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(446)
			p.Database_name()
		}
		{
			p.SetState(447)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(451)
		p.Table_name()
	}
	p.SetState(455)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_FOR {
		{
			p.SetState(452)
			p.Match(SQLiteParserK_FOR)
		}
		{
			p.SetState(453)
			p.Match(SQLiteParserK_EACH)
		}
		{
			p.SetState(454)
			p.Match(SQLiteParserK_ROW)
		}

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

	if _la == SQLiteParserK_WHEN {
		{
			p.SetState(457)
			p.Match(SQLiteParserK_WHEN)
		}
		{
			p.SetState(458)
			p.expr(0)
		}

	}
	{
		p.SetState(461)
		p.Match(SQLiteParserK_BEGIN)
	}
	p.SetState(470)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for ok := true; ok; ok = _la == SQLiteParserK_DELETE || _la == SQLiteParserK_INSERT || (((_la-122)&-(0x1f+1)) == 0 && ((1<<uint((_la-122)))&((1<<(SQLiteParserK_REPLACE-122))|(1<<(SQLiteParserK_SELECT-122))|(1<<(SQLiteParserK_UPDATE-122))|(1<<(SQLiteParserK_VALUES-122))|(1<<(SQLiteParserK_WITH-122)))) != 0) {
		p.SetState(466)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 49, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(462)
				p.Update_stmt()
			}

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

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

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

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

		p.SetState(472)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)
	}
	{
		p.SetState(474)
		p.Match(SQLiteParserK_END)
	}

	return localctx
}

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

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

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

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

func NewEmptyCreate_view_stmtContext() *Create_view_stmtContext {
	var p = new(Create_view_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_CREATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CREATE, 0)
}

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

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

	if t == nil {
		return nil
	}

	return t.(IView_nameContext)
}

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

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

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

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

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

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

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

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

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

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

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

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

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

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

func (p *SQLiteParser) Create_view_stmt() (localctx ICreate_view_stmtContext) {
	localctx = NewCreate_view_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 24, 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(476)
		p.Match(SQLiteParserK_CREATE)
	}
	p.SetState(478)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_TEMP || _la == SQLiteParserK_TEMPORARY {
		{
			p.SetState(477)
			_la = p.GetTokenStream().LA(1)

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

	}
	{
		p.SetState(480)
		p.Match(SQLiteParserK_VIEW)
	}
	p.SetState(484)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 52, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(481)
			p.Match(SQLiteParserK_IF)
		}
		{
			p.SetState(482)
			p.Match(SQLiteParserK_NOT)
		}
		{
			p.SetState(483)
			p.Match(SQLiteParserK_EXISTS)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 53, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(486)
			p.Database_name()
		}
		{
			p.SetState(487)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(491)
		p.View_name()
	}
	{
		p.SetState(492)
		p.Match(SQLiteParserK_AS)
	}
	{
		p.SetState(493)
		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) K_CREATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CREATE, 0)
}

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

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

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

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

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

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

	if t == nil {
		return nil
	}

	return t.(IModule_nameContext)
}

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

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

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

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Create_virtual_table_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(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.(SQLiteListener); ok {
		listenerT.EnterCreate_virtual_table_stmt(s)
	}
}

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

func (p *SQLiteParser) Create_virtual_table_stmt() (localctx ICreate_virtual_table_stmtContext) {
	localctx = NewCreate_virtual_table_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 26, 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(495)
		p.Match(SQLiteParserK_CREATE)
	}
	{
		p.SetState(496)
		p.Match(SQLiteParserK_VIRTUAL)
	}
	{
		p.SetState(497)
		p.Match(SQLiteParserK_TABLE)
	}
	p.SetState(501)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 54, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(498)
			p.Match(SQLiteParserK_IF)
		}
		{
			p.SetState(499)
			p.Match(SQLiteParserK_NOT)
		}
		{
			p.SetState(500)
			p.Match(SQLiteParserK_EXISTS)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 55, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(503)
			p.Database_name()
		}
		{
			p.SetState(504)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(508)
		p.Table_name()
	}
	{
		p.SetState(509)
		p.Match(SQLiteParserK_USING)
	}
	{
		p.SetState(510)
		p.Module_name()
	}
	p.SetState(522)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserOPEN_PAR {
		{
			p.SetState(511)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(512)
			p.Module_argument()
		}
		p.SetState(517)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(513)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(514)
				p.Module_argument()
			}

			p.SetState(519)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(520)
			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) K_DELETE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DELETE, 0)
}

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

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

	if t == nil {
		return nil
	}

	return t.(IQualified_table_nameContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IWith_clauseContext)
}

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

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

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

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

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

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

func (p *SQLiteParser) Delete_stmt() (localctx IDelete_stmtContext) {
	localctx = NewDelete_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 28, 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(525)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_WITH {
		{
			p.SetState(524)
			p.With_clause()
		}

	}
	{
		p.SetState(527)
		p.Match(SQLiteParserK_DELETE)
	}
	{
		p.SetState(528)
		p.Match(SQLiteParserK_FROM)
	}
	{
		p.SetState(529)
		p.Qualified_table_name()
	}
	p.SetState(532)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_WHERE {
		{
			p.SetState(530)
			p.Match(SQLiteParserK_WHERE)
		}
		{
			p.SetState(531)
			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) K_DELETE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DELETE, 0)
}

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

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

	if t == nil {
		return nil
	}

	return t.(IQualified_table_nameContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IWith_clauseContext)
}

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

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

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

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

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

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IOrdering_termContext)
}

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

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

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

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

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

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

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

func (p *SQLiteParser) Delete_stmt_limited() (localctx IDelete_stmt_limitedContext) {
	localctx = NewDelete_stmt_limitedContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 30, 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(535)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_WITH {
		{
			p.SetState(534)
			p.With_clause()
		}

	}
	{
		p.SetState(537)
		p.Match(SQLiteParserK_DELETE)
	}
	{
		p.SetState(538)
		p.Match(SQLiteParserK_FROM)
	}
	{
		p.SetState(539)
		p.Qualified_table_name()
	}
	p.SetState(542)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_WHERE {
		{
			p.SetState(540)
			p.Match(SQLiteParserK_WHERE)
		}
		{
			p.SetState(541)
			p.expr(0)
		}

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

	if _la == SQLiteParserK_LIMIT || _la == SQLiteParserK_ORDER {
		p.SetState(554)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserK_ORDER {
			{
				p.SetState(544)
				p.Match(SQLiteParserK_ORDER)
			}
			{
				p.SetState(545)
				p.Match(SQLiteParserK_BY)
			}
			{
				p.SetState(546)
				p.Ordering_term()
			}
			p.SetState(551)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(547)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(548)
					p.Ordering_term()
				}

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

		}
		{
			p.SetState(556)
			p.Match(SQLiteParserK_LIMIT)
		}
		{
			p.SetState(557)
			p.expr(0)
		}
		p.SetState(560)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserCOMMA || _la == SQLiteParserK_OFFSET {
			{
				p.SetState(558)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SQLiteParserCOMMA || _la == SQLiteParserK_OFFSET) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(559)
				p.expr(0)
			}

		}

	}

	return localctx
}

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

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

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

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

func NewEmptyDetach_stmtContext() *Detach_stmtContext {
	var p = new(Detach_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_DETACH() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DETACH, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Detach_stmtContext) K_DATABASE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DATABASE, 0)
}

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

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

func (s *Detach_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterDetach_stmt(s)
	}
}

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

func (p *SQLiteParser) Detach_stmt() (localctx IDetach_stmtContext) {
	localctx = NewDetach_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 32, 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(564)
		p.Match(SQLiteParserK_DETACH)
	}
	p.SetState(566)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 66, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(565)
			p.Match(SQLiteParserK_DATABASE)
		}

	}
	{
		p.SetState(568)
		p.Database_name()
	}

	return localctx
}

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

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

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

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

func NewEmptyDrop_index_stmtContext() *Drop_index_stmtContext {
	var p = new(Drop_index_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_drop_index_stmt
	return p
}

func (*Drop_index_stmtContext) IsDrop_index_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_drop_index_stmt

	return p
}

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

func (s *Drop_index_stmtContext) K_DROP() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DROP, 0)
}

func (s *Drop_index_stmtContext) K_INDEX() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INDEX, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IIndex_nameContext)
}

func (s *Drop_index_stmtContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IF, 0)
}

func (s *Drop_index_stmtContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_EXISTS, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

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

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

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

func (s *Drop_index_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterDrop_index_stmt(s)
	}
}

func (s *Drop_index_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitDrop_index_stmt(s)
	}
}

func (p *SQLiteParser) Drop_index_stmt() (localctx IDrop_index_stmtContext) {
	localctx = NewDrop_index_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 34, SQLiteParserRULE_drop_index_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(570)
		p.Match(SQLiteParserK_DROP)
	}
	{
		p.SetState(571)
		p.Match(SQLiteParserK_INDEX)
	}
	p.SetState(574)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 67, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(572)
			p.Match(SQLiteParserK_IF)
		}
		{
			p.SetState(573)
			p.Match(SQLiteParserK_EXISTS)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 68, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(576)
			p.Database_name()
		}
		{
			p.SetState(577)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(581)
		p.Index_name()
	}

	return localctx
}

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

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

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

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

func NewEmptyDrop_table_stmtContext() *Drop_table_stmtContext {
	var p = new(Drop_table_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_drop_table_stmt
	return p
}

func (*Drop_table_stmtContext) IsDrop_table_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_drop_table_stmt

	return p
}

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

func (s *Drop_table_stmtContext) K_DROP() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DROP, 0)
}

func (s *Drop_table_stmtContext) K_TABLE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_TABLE, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Drop_table_stmtContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IF, 0)
}

func (s *Drop_table_stmtContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_EXISTS, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

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

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

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

func (s *Drop_table_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterDrop_table_stmt(s)
	}
}

func (s *Drop_table_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitDrop_table_stmt(s)
	}
}

func (p *SQLiteParser) Drop_table_stmt() (localctx IDrop_table_stmtContext) {
	localctx = NewDrop_table_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 36, SQLiteParserRULE_drop_table_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(583)
		p.Match(SQLiteParserK_DROP)
	}
	{
		p.SetState(584)
		p.Match(SQLiteParserK_TABLE)
	}
	p.SetState(587)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 69, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(585)
			p.Match(SQLiteParserK_IF)
		}
		{
			p.SetState(586)
			p.Match(SQLiteParserK_EXISTS)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 70, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(589)
			p.Database_name()
		}
		{
			p.SetState(590)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(594)
		p.Table_name()
	}

	return localctx
}

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

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

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

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

func NewEmptyDrop_trigger_stmtContext() *Drop_trigger_stmtContext {
	var p = new(Drop_trigger_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_drop_trigger_stmt
	return p
}

func (*Drop_trigger_stmtContext) IsDrop_trigger_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_drop_trigger_stmt

	return p
}

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

func (s *Drop_trigger_stmtContext) K_DROP() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DROP, 0)
}

func (s *Drop_trigger_stmtContext) K_TRIGGER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_TRIGGER, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITrigger_nameContext)
}

func (s *Drop_trigger_stmtContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IF, 0)
}

func (s *Drop_trigger_stmtContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_EXISTS, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

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

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

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

func (s *Drop_trigger_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterDrop_trigger_stmt(s)
	}
}

func (s *Drop_trigger_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitDrop_trigger_stmt(s)
	}
}

func (p *SQLiteParser) Drop_trigger_stmt() (localctx IDrop_trigger_stmtContext) {
	localctx = NewDrop_trigger_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 38, SQLiteParserRULE_drop_trigger_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(596)
		p.Match(SQLiteParserK_DROP)
	}
	{
		p.SetState(597)
		p.Match(SQLiteParserK_TRIGGER)
	}
	p.SetState(600)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 71, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(598)
			p.Match(SQLiteParserK_IF)
		}
		{
			p.SetState(599)
			p.Match(SQLiteParserK_EXISTS)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 72, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(602)
			p.Database_name()
		}
		{
			p.SetState(603)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(607)
		p.Trigger_name()
	}

	return localctx
}

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

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

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

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

func NewEmptyDrop_view_stmtContext() *Drop_view_stmtContext {
	var p = new(Drop_view_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_drop_view_stmt
	return p
}

func (*Drop_view_stmtContext) IsDrop_view_stmtContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_drop_view_stmt

	return p
}

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

func (s *Drop_view_stmtContext) K_DROP() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DROP, 0)
}

func (s *Drop_view_stmtContext) K_VIEW() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_VIEW, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IView_nameContext)
}

func (s *Drop_view_stmtContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IF, 0)
}

func (s *Drop_view_stmtContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_EXISTS, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

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

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

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

func (s *Drop_view_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterDrop_view_stmt(s)
	}
}

func (s *Drop_view_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitDrop_view_stmt(s)
	}
}

func (p *SQLiteParser) Drop_view_stmt() (localctx IDrop_view_stmtContext) {
	localctx = NewDrop_view_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 40, SQLiteParserRULE_drop_view_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(609)
		p.Match(SQLiteParserK_DROP)
	}
	{
		p.SetState(610)
		p.Match(SQLiteParserK_VIEW)
	}
	p.SetState(613)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 73, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(611)
			p.Match(SQLiteParserK_IF)
		}
		{
			p.SetState(612)
			p.Match(SQLiteParserK_EXISTS)
		}

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 74, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(615)
			p.Database_name()
		}
		{
			p.SetState(616)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(620)
		p.View_name()
	}

	return localctx
}

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

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

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

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

func NewEmptyFactored_select_stmtContext() *Factored_select_stmtContext {
	var p = new(Factored_select_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) AllSelect_core() []ISelect_coreContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISelect_coreContext)(nil)).Elem())
	var tst = make([]ISelect_coreContext, len(ts))

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(ISelect_coreContext)
}

func (s *Factored_select_stmtContext) 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 *Factored_select_stmtContext) AllCompound_operator() []ICompound_operatorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICompound_operatorContext)(nil)).Elem())
	var tst = make([]ICompound_operatorContext, len(ts))

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

	return tst
}

func (s *Factored_select_stmtContext) Compound_operator(i int) ICompound_operatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompound_operatorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICompound_operatorContext)
}

func (s *Factored_select_stmtContext) K_ORDER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ORDER, 0)
}

func (s *Factored_select_stmtContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_BY, 0)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IOrdering_termContext)
}

func (s *Factored_select_stmtContext) K_LIMIT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_LIMIT, 0)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

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

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

func (s *Factored_select_stmtContext) K_OFFSET() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_OFFSET, 0)
}

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

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

func (s *Factored_select_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterFactored_select_stmt(s)
	}
}

func (s *Factored_select_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitFactored_select_stmt(s)
	}
}

func (p *SQLiteParser) Factored_select_stmt() (localctx IFactored_select_stmtContext) {
	localctx = NewFactored_select_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 42, SQLiteParserRULE_factored_select_stmt)
	var _la int

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

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

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

	if _la == SQLiteParserK_WITH {
		{
			p.SetState(622)
			p.With_clause()
		}

	}
	{
		p.SetState(625)
		p.Select_core()
	}
	p.SetState(631)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserK_EXCEPT || _la == SQLiteParserK_INTERSECT || _la == SQLiteParserK_UNION {
		{
			p.SetState(626)
			p.Compound_operator()
		}
		{
			p.SetState(627)
			p.Select_core()
		}

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

	if _la == SQLiteParserK_ORDER {
		{
			p.SetState(634)
			p.Match(SQLiteParserK_ORDER)
		}
		{
			p.SetState(635)
			p.Match(SQLiteParserK_BY)
		}
		{
			p.SetState(636)
			p.Ordering_term()
		}
		p.SetState(641)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(637)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(638)
				p.Ordering_term()
			}

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

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

	if _la == SQLiteParserK_LIMIT {
		{
			p.SetState(646)
			p.Match(SQLiteParserK_LIMIT)
		}
		{
			p.SetState(647)
			p.expr(0)
		}
		p.SetState(650)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserCOMMA || _la == SQLiteParserK_OFFSET {
			{
				p.SetState(648)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SQLiteParserCOMMA || _la == SQLiteParserK_OFFSET) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(649)
				p.expr(0)
			}

		}

	}

	return localctx
}

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

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

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

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

func NewEmptyInsert_stmtContext() *Insert_stmtContext {
	var p = new(Insert_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_INTO() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INTO, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

func (s *Insert_stmtContext) K_INSERT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INSERT, 0)
}

func (s *Insert_stmtContext) K_REPLACE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_REPLACE, 0)
}

func (s *Insert_stmtContext) K_OR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_OR, 0)
}

func (s *Insert_stmtContext) K_ROLLBACK() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ROLLBACK, 0)
}

func (s *Insert_stmtContext) K_ABORT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ABORT, 0)
}

func (s *Insert_stmtContext) K_FAIL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_FAIL, 0)
}

func (s *Insert_stmtContext) K_IGNORE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IGNORE, 0)
}

func (s *Insert_stmtContext) K_VALUES() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_VALUES, 0)
}

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) AllExpr() []IExprContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExprContext)(nil)).Elem())
	var tst = make([]IExprContext, len(ts))

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Insert_stmtContext) AllCLOSE_PAR() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCLOSE_PAR)
}

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

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

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

func (s *Insert_stmtContext) K_DEFAULT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DEFAULT, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IWith_clauseContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

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

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

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

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

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

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

func (s *Insert_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterInsert_stmt(s)
	}
}

func (s *Insert_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitInsert_stmt(s)
	}
}

func (p *SQLiteParser) Insert_stmt() (localctx IInsert_stmtContext) {
	localctx = NewInsert_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 44, 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.EnterOuterAlt(localctx, 1)
	p.SetState(655)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_WITH {
		{
			p.SetState(654)
			p.With_clause()
		}

	}
	p.SetState(674)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 82, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(657)
			p.Match(SQLiteParserK_INSERT)
		}

	case 2:
		{
			p.SetState(658)
			p.Match(SQLiteParserK_REPLACE)
		}

	case 3:
		{
			p.SetState(659)
			p.Match(SQLiteParserK_INSERT)
		}
		{
			p.SetState(660)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(661)
			p.Match(SQLiteParserK_REPLACE)
		}

	case 4:
		{
			p.SetState(662)
			p.Match(SQLiteParserK_INSERT)
		}
		{
			p.SetState(663)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(664)
			p.Match(SQLiteParserK_ROLLBACK)
		}

	case 5:
		{
			p.SetState(665)
			p.Match(SQLiteParserK_INSERT)
		}
		{
			p.SetState(666)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(667)
			p.Match(SQLiteParserK_ABORT)
		}

	case 6:
		{
			p.SetState(668)
			p.Match(SQLiteParserK_INSERT)
		}
		{
			p.SetState(669)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(670)
			p.Match(SQLiteParserK_FAIL)
		}

	case 7:
		{
			p.SetState(671)
			p.Match(SQLiteParserK_INSERT)
		}
		{
			p.SetState(672)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(673)
			p.Match(SQLiteParserK_IGNORE)
		}

	}
	{
		p.SetState(676)
		p.Match(SQLiteParserK_INTO)
	}
	p.SetState(680)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 83, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(677)
			p.Database_name()
		}
		{
			p.SetState(678)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(682)
		p.Table_name()
	}
	p.SetState(694)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserOPEN_PAR {
		{
			p.SetState(683)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(684)
			p.Column_name()
		}
		p.SetState(689)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(685)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(686)
				p.Column_name()
			}

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

	}
	p.SetState(727)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 89, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(696)
			p.Match(SQLiteParserK_VALUES)
		}
		{
			p.SetState(697)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(698)
			p.expr(0)
		}
		p.SetState(703)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(699)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(700)
				p.expr(0)
			}

			p.SetState(705)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(706)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		p.SetState(721)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(707)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(708)
				p.Match(SQLiteParserOPEN_PAR)
			}
			{
				p.SetState(709)
				p.expr(0)
			}
			p.SetState(714)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(710)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(711)
					p.expr(0)
				}

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

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

	case 2:
		{
			p.SetState(724)
			p.Select_stmt()
		}

	case 3:
		{
			p.SetState(725)
			p.Match(SQLiteParserK_DEFAULT)
		}
		{
			p.SetState(726)
			p.Match(SQLiteParserK_VALUES)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyPragma_stmtContext() *Pragma_stmtContext {
	var p = new(Pragma_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_PRAGMA() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_PRAGMA, 0)
}

func (s *Pragma_stmtContext) Pragma_name() IPragma_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPragma_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IPragma_nameContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Pragma_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(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.(SQLiteListener); ok {
		listenerT.EnterPragma_stmt(s)
	}
}

func (s *Pragma_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitPragma_stmt(s)
	}
}

func (p *SQLiteParser) Pragma_stmt() (localctx IPragma_stmtContext) {
	localctx = NewPragma_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 46, 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(729)
		p.Match(SQLiteParserK_PRAGMA)
	}
	p.SetState(733)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 90, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(730)
			p.Database_name()
		}
		{
			p.SetState(731)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(735)
		p.Pragma_name()
	}
	p.SetState(742)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserASSIGN:
		{
			p.SetState(736)
			p.Match(SQLiteParserASSIGN)
		}
		{
			p.SetState(737)
			p.Pragma_value()
		}

	case SQLiteParserOPEN_PAR:
		{
			p.SetState(738)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(739)
			p.Pragma_value()
		}
		{
			p.SetState(740)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case SQLiteParserEOF, SQLiteParserSCOL, SQLiteParserK_ALTER, SQLiteParserK_ANALYZE, SQLiteParserK_ATTACH, SQLiteParserK_BEGIN, SQLiteParserK_COMMIT, SQLiteParserK_CREATE, SQLiteParserK_DELETE, SQLiteParserK_DETACH, SQLiteParserK_DROP, SQLiteParserK_END, SQLiteParserK_EXPLAIN, SQLiteParserK_INSERT, SQLiteParserK_PRAGMA, SQLiteParserK_REINDEX, SQLiteParserK_RELEASE, SQLiteParserK_REPLACE, SQLiteParserK_ROLLBACK, SQLiteParserK_SAVEPOINT, SQLiteParserK_SELECT, SQLiteParserK_UPDATE, SQLiteParserK_VACUUM, SQLiteParserK_VALUES, SQLiteParserK_WITH:

	default:
	}

	return localctx
}

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

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

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

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

func NewEmptyReindex_stmtContext() *Reindex_stmtContext {
	var p = new(Reindex_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_REINDEX() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_REINDEX, 0)
}

func (s *Reindex_stmtContext) Collation_name() ICollation_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollation_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICollation_nameContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ITable_nameContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IIndex_nameContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

func (s *Reindex_stmtContext) DOT() antlr.TerminalNode {
	return s.GetToken(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.(SQLiteListener); ok {
		listenerT.EnterReindex_stmt(s)
	}
}

func (s *Reindex_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitReindex_stmt(s)
	}
}

func (p *SQLiteParser) Reindex_stmt() (localctx IReindex_stmtContext) {
	localctx = NewReindex_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 48, 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(744)
		p.Match(SQLiteParserK_REINDEX)
	}
	p.SetState(755)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 94, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(745)
			p.Collation_name()
		}

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

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 92, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(746)
				p.Database_name()
			}
			{
				p.SetState(747)
				p.Match(SQLiteParserDOT)
			}

		}
		p.SetState(753)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 93, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(751)
				p.Table_name()
			}

		case 2:
			{
				p.SetState(752)
				p.Index_name()
			}

		}

	}

	return localctx
}

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

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

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

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

func NewEmptyRelease_stmtContext() *Release_stmtContext {
	var p = new(Release_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_RELEASE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_RELEASE, 0)
}

func (s *Release_stmtContext) Savepoint_name() ISavepoint_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISavepoint_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISavepoint_nameContext)
}

func (s *Release_stmtContext) K_SAVEPOINT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_SAVEPOINT, 0)
}

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

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

func (s *Release_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterRelease_stmt(s)
	}
}

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

func (p *SQLiteParser) Release_stmt() (localctx IRelease_stmtContext) {
	localctx = NewRelease_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 50, 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(757)
		p.Match(SQLiteParserK_RELEASE)
	}
	p.SetState(759)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 95, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(758)
			p.Match(SQLiteParserK_SAVEPOINT)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyRollback_stmtContext() *Rollback_stmtContext {
	var p = new(Rollback_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_ROLLBACK() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ROLLBACK, 0)
}

func (s *Rollback_stmtContext) K_TRANSACTION() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_TRANSACTION, 0)
}

func (s *Rollback_stmtContext) K_TO() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_TO, 0)
}

func (s *Rollback_stmtContext) Savepoint_name() ISavepoint_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISavepoint_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISavepoint_nameContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ITransaction_nameContext)
}

func (s *Rollback_stmtContext) K_SAVEPOINT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_SAVEPOINT, 0)
}

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

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

func (s *Rollback_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterRollback_stmt(s)
	}
}

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

func (p *SQLiteParser) Rollback_stmt() (localctx IRollback_stmtContext) {
	localctx = NewRollback_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 52, 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(763)
		p.Match(SQLiteParserK_ROLLBACK)
	}
	p.SetState(768)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_TRANSACTION {
		{
			p.SetState(764)
			p.Match(SQLiteParserK_TRANSACTION)
		}
		p.SetState(766)
		p.GetErrorHandler().Sync(p)

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

		}

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

	if _la == SQLiteParserK_TO {
		{
			p.SetState(770)
			p.Match(SQLiteParserK_TO)
		}
		p.SetState(772)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 98, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(771)
				p.Match(SQLiteParserK_SAVEPOINT)
			}

		}
		{
			p.SetState(774)
			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) K_SAVEPOINT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_SAVEPOINT, 0)
}

func (s *Savepoint_stmtContext) Savepoint_name() ISavepoint_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISavepoint_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ISavepoint_nameContext)
}

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

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

func (s *Savepoint_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterSavepoint_stmt(s)
	}
}

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

func (p *SQLiteParser) Savepoint_stmt() (localctx ISavepoint_stmtContext) {
	localctx = NewSavepoint_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 54, 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(777)
		p.Match(SQLiteParserK_SAVEPOINT)
	}
	{
		p.SetState(778)
		p.Savepoint_name()
	}

	return localctx
}

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

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

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

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

func NewEmptySimple_select_stmtContext() *Simple_select_stmtContext {
	var p = new(Simple_select_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) 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 *Simple_select_stmtContext) K_ORDER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ORDER, 0)
}

func (s *Simple_select_stmtContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_BY, 0)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IOrdering_termContext)
}

func (s *Simple_select_stmtContext) K_LIMIT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_LIMIT, 0)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

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

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

func (s *Simple_select_stmtContext) K_OFFSET() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_OFFSET, 0)
}

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

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

func (s *Simple_select_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterSimple_select_stmt(s)
	}
}

func (s *Simple_select_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitSimple_select_stmt(s)
	}
}

func (p *SQLiteParser) Simple_select_stmt() (localctx ISimple_select_stmtContext) {
	localctx = NewSimple_select_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 56, 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(781)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_WITH {
		{
			p.SetState(780)
			p.With_clause()
		}

	}
	{
		p.SetState(783)
		p.Select_core()
	}
	p.SetState(794)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_ORDER {
		{
			p.SetState(784)
			p.Match(SQLiteParserK_ORDER)
		}
		{
			p.SetState(785)
			p.Match(SQLiteParserK_BY)
		}
		{
			p.SetState(786)
			p.Ordering_term()
		}
		p.SetState(791)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(787)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(788)
				p.Ordering_term()
			}

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

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

	if _la == SQLiteParserK_LIMIT {
		{
			p.SetState(796)
			p.Match(SQLiteParserK_LIMIT)
		}
		{
			p.SetState(797)
			p.expr(0)
		}
		p.SetState(800)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserCOMMA || _la == SQLiteParserK_OFFSET {
			{
				p.SetState(798)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SQLiteParserCOMMA || _la == SQLiteParserK_OFFSET) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(799)
				p.expr(0)
			}

		}

	}

	return localctx
}

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

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

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

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

func NewEmptySelect_stmtContext() *Select_stmtContext {
	var p = new(Select_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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_or_values() []ISelect_or_valuesContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISelect_or_valuesContext)(nil)).Elem())
	var tst = make([]ISelect_or_valuesContext, len(ts))

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

	return tst
}

func (s *Select_stmtContext) Select_or_values(i int) ISelect_or_valuesContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISelect_or_valuesContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ISelect_or_valuesContext)
}

func (s *Select_stmtContext) 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 *Select_stmtContext) AllCompound_operator() []ICompound_operatorContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ICompound_operatorContext)(nil)).Elem())
	var tst = make([]ICompound_operatorContext, len(ts))

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

	return tst
}

func (s *Select_stmtContext) Compound_operator(i int) ICompound_operatorContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICompound_operatorContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ICompound_operatorContext)
}

func (s *Select_stmtContext) K_ORDER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ORDER, 0)
}

func (s *Select_stmtContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_BY, 0)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IOrdering_termContext)
}

func (s *Select_stmtContext) K_LIMIT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_LIMIT, 0)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

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

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

func (s *Select_stmtContext) K_OFFSET() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_OFFSET, 0)
}

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

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

func (s *Select_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterSelect_stmt(s)
	}
}

func (s *Select_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitSelect_stmt(s)
	}
}

func (p *SQLiteParser) Select_stmt() (localctx ISelect_stmtContext) {
	localctx = NewSelect_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 58, 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)
			}
		}
	}()

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

	if _la == SQLiteParserK_WITH {
		{
			p.SetState(804)
			p.With_clause()
		}

	}
	{
		p.SetState(807)
		p.Select_or_values()
	}
	p.SetState(813)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserK_EXCEPT || _la == SQLiteParserK_INTERSECT || _la == SQLiteParserK_UNION {
		{
			p.SetState(808)
			p.Compound_operator()
		}
		{
			p.SetState(809)
			p.Select_or_values()
		}

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

	if _la == SQLiteParserK_ORDER {
		{
			p.SetState(816)
			p.Match(SQLiteParserK_ORDER)
		}
		{
			p.SetState(817)
			p.Match(SQLiteParserK_BY)
		}
		{
			p.SetState(818)
			p.Ordering_term()
		}
		p.SetState(823)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(819)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(820)
				p.Ordering_term()
			}

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

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

	if _la == SQLiteParserK_LIMIT {
		{
			p.SetState(828)
			p.Match(SQLiteParserK_LIMIT)
		}
		{
			p.SetState(829)
			p.expr(0)
		}
		p.SetState(832)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserCOMMA || _la == SQLiteParserK_OFFSET {
			{
				p.SetState(830)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SQLiteParserCOMMA || _la == SQLiteParserK_OFFSET) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(831)
				p.expr(0)
			}

		}

	}

	return localctx
}

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

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

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

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

func NewEmptySelect_or_valuesContext() *Select_or_valuesContext {
	var p = new(Select_or_valuesContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_select_or_values
	return p
}

func (*Select_or_valuesContext) IsSelect_or_valuesContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_select_or_values

	return p
}

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

func (s *Select_or_valuesContext) K_SELECT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_SELECT, 0)
}

func (s *Select_or_valuesContext) AllResult_column() []IResult_columnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IResult_columnContext)(nil)).Elem())
	var tst = make([]IResult_columnContext, len(ts))

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

	return tst
}

func (s *Select_or_valuesContext) Result_column(i int) IResult_columnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResult_columnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IResult_columnContext)
}

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

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

func (s *Select_or_valuesContext) K_FROM() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_FROM, 0)
}

func (s *Select_or_valuesContext) K_WHERE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_WHERE, 0)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Select_or_valuesContext) K_GROUP() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_GROUP, 0)
}

func (s *Select_or_valuesContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_BY, 0)
}

func (s *Select_or_valuesContext) K_DISTINCT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DISTINCT, 0)
}

func (s *Select_or_valuesContext) K_ALL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ALL, 0)
}

func (s *Select_or_valuesContext) AllTable_or_subquery() []ITable_or_subqueryContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITable_or_subqueryContext)(nil)).Elem())
	var tst = make([]ITable_or_subqueryContext, len(ts))

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

	return tst
}

func (s *Select_or_valuesContext) Table_or_subquery(i int) ITable_or_subqueryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_or_subqueryContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITable_or_subqueryContext)
}

func (s *Select_or_valuesContext) Join_clause() IJoin_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IJoin_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IJoin_clauseContext)
}

func (s *Select_or_valuesContext) K_HAVING() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_HAVING, 0)
}

func (s *Select_or_valuesContext) K_VALUES() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_VALUES, 0)
}

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

func (s *Select_or_valuesContext) OPEN_PAR(i int) antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, i)
}

func (s *Select_or_valuesContext) AllCLOSE_PAR() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserCLOSE_PAR)
}

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

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

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

func (s *Select_or_valuesContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterSelect_or_values(s)
	}
}

func (s *Select_or_valuesContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitSelect_or_values(s)
	}
}

func (p *SQLiteParser) Select_or_values() (localctx ISelect_or_valuesContext) {
	localctx = NewSelect_or_valuesContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 60, SQLiteParserRULE_select_or_values)
	var _la int

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

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

	p.SetState(910)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserK_SELECT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(836)
			p.Match(SQLiteParserK_SELECT)
		}
		p.SetState(838)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 111, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(837)
				_la = p.GetTokenStream().LA(1)

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

		}
		{
			p.SetState(840)
			p.Result_column()
		}
		p.SetState(845)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(841)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(842)
				p.Result_column()
			}

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

		if _la == SQLiteParserK_FROM {
			{
				p.SetState(848)
				p.Match(SQLiteParserK_FROM)
			}
			p.SetState(858)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 114, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(849)
					p.Table_or_subquery()
				}
				p.SetState(854)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				for _la == SQLiteParserCOMMA {
					{
						p.SetState(850)
						p.Match(SQLiteParserCOMMA)
					}
					{
						p.SetState(851)
						p.Table_or_subquery()
					}

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

			case 2:
				{
					p.SetState(857)
					p.Join_clause()
				}

			}

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

		if _la == SQLiteParserK_WHERE {
			{
				p.SetState(862)
				p.Match(SQLiteParserK_WHERE)
			}
			{
				p.SetState(863)
				p.expr(0)
			}

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

		if _la == SQLiteParserK_GROUP {
			{
				p.SetState(866)
				p.Match(SQLiteParserK_GROUP)
			}
			{
				p.SetState(867)
				p.Match(SQLiteParserK_BY)
			}
			{
				p.SetState(868)
				p.expr(0)
			}
			p.SetState(873)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(869)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(870)
					p.expr(0)
				}

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

			if _la == SQLiteParserK_HAVING {
				{
					p.SetState(876)
					p.Match(SQLiteParserK_HAVING)
				}
				{
					p.SetState(877)
					p.expr(0)
				}

			}

		}

	case SQLiteParserK_VALUES:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(882)
			p.Match(SQLiteParserK_VALUES)
		}
		{
			p.SetState(883)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(884)
			p.expr(0)
		}
		p.SetState(889)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(885)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(886)
				p.expr(0)
			}

			p.SetState(891)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(892)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		p.SetState(907)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(893)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(894)
				p.Match(SQLiteParserOPEN_PAR)
			}
			{
				p.SetState(895)
				p.expr(0)
			}
			p.SetState(900)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(896)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(897)
					p.expr(0)
				}

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

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

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

	return localctx
}

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

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

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

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

func NewEmptyUpdate_stmtContext() *Update_stmtContext {
	var p = new(Update_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_UPDATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_UPDATE, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IQualified_table_nameContext)
}

func (s *Update_stmtContext) K_SET() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_SET, 0)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

func (s *Update_stmtContext) AllASSIGN() []antlr.TerminalNode {
	return s.GetTokens(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) With_clause() IWith_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWith_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWith_clauseContext)
}

func (s *Update_stmtContext) K_OR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_OR, 0)
}

func (s *Update_stmtContext) K_ROLLBACK() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ROLLBACK, 0)
}

func (s *Update_stmtContext) K_ABORT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ABORT, 0)
}

func (s *Update_stmtContext) K_REPLACE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_REPLACE, 0)
}

func (s *Update_stmtContext) K_FAIL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_FAIL, 0)
}

func (s *Update_stmtContext) K_IGNORE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IGNORE, 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) K_WHERE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_WHERE, 0)
}

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

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

func (s *Update_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterUpdate_stmt(s)
	}
}

func (s *Update_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitUpdate_stmt(s)
	}
}

func (p *SQLiteParser) Update_stmt() (localctx IUpdate_stmtContext) {
	localctx = NewUpdate_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 62, 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(913)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_WITH {
		{
			p.SetState(912)
			p.With_clause()
		}

	}
	{
		p.SetState(915)
		p.Match(SQLiteParserK_UPDATE)
	}
	p.SetState(926)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 125, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(916)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(917)
			p.Match(SQLiteParserK_ROLLBACK)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 125, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(918)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(919)
			p.Match(SQLiteParserK_ABORT)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 125, p.GetParserRuleContext()) == 3 {
		{
			p.SetState(920)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(921)
			p.Match(SQLiteParserK_REPLACE)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 125, p.GetParserRuleContext()) == 4 {
		{
			p.SetState(922)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(923)
			p.Match(SQLiteParserK_FAIL)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 125, p.GetParserRuleContext()) == 5 {
		{
			p.SetState(924)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(925)
			p.Match(SQLiteParserK_IGNORE)
		}

	}
	{
		p.SetState(928)
		p.Qualified_table_name()
	}
	{
		p.SetState(929)
		p.Match(SQLiteParserK_SET)
	}
	{
		p.SetState(930)
		p.Column_name()
	}
	{
		p.SetState(931)
		p.Match(SQLiteParserASSIGN)
	}
	{
		p.SetState(932)
		p.expr(0)
	}
	p.SetState(940)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserCOMMA {
		{
			p.SetState(933)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(934)
			p.Column_name()
		}
		{
			p.SetState(935)
			p.Match(SQLiteParserASSIGN)
		}
		{
			p.SetState(936)
			p.expr(0)
		}

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

	if _la == SQLiteParserK_WHERE {
		{
			p.SetState(943)
			p.Match(SQLiteParserK_WHERE)
		}
		{
			p.SetState(944)
			p.expr(0)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyUpdate_stmt_limitedContext() *Update_stmt_limitedContext {
	var p = new(Update_stmt_limitedContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_UPDATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_UPDATE, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IQualified_table_nameContext)
}

func (s *Update_stmt_limitedContext) K_SET() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_SET, 0)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IColumn_nameContext)
}

func (s *Update_stmt_limitedContext) AllASSIGN() []antlr.TerminalNode {
	return s.GetTokens(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) With_clause() IWith_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IWith_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IWith_clauseContext)
}

func (s *Update_stmt_limitedContext) K_OR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_OR, 0)
}

func (s *Update_stmt_limitedContext) K_ROLLBACK() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ROLLBACK, 0)
}

func (s *Update_stmt_limitedContext) K_ABORT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ABORT, 0)
}

func (s *Update_stmt_limitedContext) K_REPLACE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_REPLACE, 0)
}

func (s *Update_stmt_limitedContext) K_FAIL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_FAIL, 0)
}

func (s *Update_stmt_limitedContext) K_IGNORE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IGNORE, 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) K_WHERE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_WHERE, 0)
}

func (s *Update_stmt_limitedContext) K_LIMIT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_LIMIT, 0)
}

func (s *Update_stmt_limitedContext) K_ORDER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ORDER, 0)
}

func (s *Update_stmt_limitedContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_BY, 0)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IOrdering_termContext)
}

func (s *Update_stmt_limitedContext) K_OFFSET() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_OFFSET, 0)
}

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

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

func (s *Update_stmt_limitedContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterUpdate_stmt_limited(s)
	}
}

func (s *Update_stmt_limitedContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitUpdate_stmt_limited(s)
	}
}

func (p *SQLiteParser) Update_stmt_limited() (localctx IUpdate_stmt_limitedContext) {
	localctx = NewUpdate_stmt_limitedContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 64, 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(948)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_WITH {
		{
			p.SetState(947)
			p.With_clause()
		}

	}
	{
		p.SetState(950)
		p.Match(SQLiteParserK_UPDATE)
	}
	p.SetState(961)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 129, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(951)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(952)
			p.Match(SQLiteParserK_ROLLBACK)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 129, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(953)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(954)
			p.Match(SQLiteParserK_ABORT)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 129, p.GetParserRuleContext()) == 3 {
		{
			p.SetState(955)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(956)
			p.Match(SQLiteParserK_REPLACE)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 129, p.GetParserRuleContext()) == 4 {
		{
			p.SetState(957)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(958)
			p.Match(SQLiteParserK_FAIL)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 129, p.GetParserRuleContext()) == 5 {
		{
			p.SetState(959)
			p.Match(SQLiteParserK_OR)
		}
		{
			p.SetState(960)
			p.Match(SQLiteParserK_IGNORE)
		}

	}
	{
		p.SetState(963)
		p.Qualified_table_name()
	}
	{
		p.SetState(964)
		p.Match(SQLiteParserK_SET)
	}
	{
		p.SetState(965)
		p.Column_name()
	}
	{
		p.SetState(966)
		p.Match(SQLiteParserASSIGN)
	}
	{
		p.SetState(967)
		p.expr(0)
	}
	p.SetState(975)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserCOMMA {
		{
			p.SetState(968)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(969)
			p.Column_name()
		}
		{
			p.SetState(970)
			p.Match(SQLiteParserASSIGN)
		}
		{
			p.SetState(971)
			p.expr(0)
		}

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

	if _la == SQLiteParserK_WHERE {
		{
			p.SetState(978)
			p.Match(SQLiteParserK_WHERE)
		}
		{
			p.SetState(979)
			p.expr(0)
		}

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

	if _la == SQLiteParserK_LIMIT || _la == SQLiteParserK_ORDER {
		p.SetState(992)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserK_ORDER {
			{
				p.SetState(982)
				p.Match(SQLiteParserK_ORDER)
			}
			{
				p.SetState(983)
				p.Match(SQLiteParserK_BY)
			}
			{
				p.SetState(984)
				p.Ordering_term()
			}
			p.SetState(989)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(985)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(986)
					p.Ordering_term()
				}

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

		}
		{
			p.SetState(994)
			p.Match(SQLiteParserK_LIMIT)
		}
		{
			p.SetState(995)
			p.expr(0)
		}
		p.SetState(998)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserCOMMA || _la == SQLiteParserK_OFFSET {
			{
				p.SetState(996)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SQLiteParserCOMMA || _la == SQLiteParserK_OFFSET) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			{
				p.SetState(997)
				p.expr(0)
			}

		}

	}

	return localctx
}

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

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

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

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

func NewEmptyVacuum_stmtContext() *Vacuum_stmtContext {
	var p = new(Vacuum_stmtContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_VACUUM() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_VACUUM, 0)
}

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

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

func (s *Vacuum_stmtContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterVacuum_stmt(s)
	}
}

func (s *Vacuum_stmtContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitVacuum_stmt(s)
	}
}

func (p *SQLiteParser) Vacuum_stmt() (localctx IVacuum_stmtContext) {
	localctx = NewVacuum_stmtContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 66, SQLiteParserRULE_vacuum_stmt)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1002)
		p.Match(SQLiteParserK_VACUUM)
	}

	return localctx
}

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

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

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

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

func NewEmptyColumn_defContext() *Column_defContext {
	var p = new(Column_defContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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.(SQLiteListener); ok {
		listenerT.EnterColumn_def(s)
	}
}

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

func (p *SQLiteParser) Column_def() (localctx IColumn_defContext) {
	localctx = NewColumn_defContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 68, SQLiteParserRULE_column_def)
	var _la int

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1004)
		p.Column_name()
	}
	p.SetState(1006)
	p.GetErrorHandler().Sync(p)

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

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

	for (((_la-44)&-(0x1f+1)) == 0 && ((1<<uint((_la-44)))&((1<<(SQLiteParserK_CHECK-44))|(1<<(SQLiteParserK_COLLATE-44))|(1<<(SQLiteParserK_CONSTRAINT-44))|(1<<(SQLiteParserK_DEFAULT-44)))) != 0) || (((_la-102)&-(0x1f+1)) == 0 && ((1<<uint((_la-102)))&((1<<(SQLiteParserK_NOT-102))|(1<<(SQLiteParserK_NULL-102))|(1<<(SQLiteParserK_PRIMARY-102))|(1<<(SQLiteParserK_REFERENCES-102)))) != 0) || _la == SQLiteParserK_UNIQUE {
		{
			p.SetState(1008)
			p.Column_constraint()
		}

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

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

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

func (p *SQLiteParser) Type_name() (localctx IType_nameContext) {
	localctx = NewType_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 70, 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(1015)
	p.GetErrorHandler().Sync(p)
	_alt = 1 + 1
	for ok := true; ok; ok = _alt != 1 && _alt != antlr.ATNInvalidAltNumber {
		switch _alt {
		case 1 + 1:
			{
				p.SetState(1014)
				p.Name()
			}

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

		p.SetState(1017)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 138, p.GetParserRuleContext())
	}
	p.SetState(1029)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 139, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1019)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1020)
			p.Signed_number()
		}
		{
			p.SetState(1021)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 139, p.GetParserRuleContext()) == 2 {
		{
			p.SetState(1023)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1024)
			p.Signed_number()
		}
		{
			p.SetState(1025)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(1026)
			p.Signed_number()
		}
		{
			p.SetState(1027)
			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) K_PRIMARY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_PRIMARY, 0)
}

func (s *Column_constraintContext) K_KEY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_KEY, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IConflict_clauseContext)
}

func (s *Column_constraintContext) K_NULL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NULL, 0)
}

func (s *Column_constraintContext) K_UNIQUE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_UNIQUE, 0)
}

func (s *Column_constraintContext) K_CHECK() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CHECK, 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) K_DEFAULT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DEFAULT, 0)
}

func (s *Column_constraintContext) K_COLLATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_COLLATE, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ICollation_nameContext)
}

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

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

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

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

func (s *Column_constraintContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NOT, 0)
}

func (s *Column_constraintContext) K_ASC() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ASC, 0)
}

func (s *Column_constraintContext) K_DESC() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DESC, 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.(SQLiteListener); ok {
		listenerT.EnterColumn_constraint(s)
	}
}

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

func (p *SQLiteParser) Column_constraint() (localctx IColumn_constraintContext) {
	localctx = NewColumn_constraintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 72, 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(1033)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_CONSTRAINT {
		{
			p.SetState(1031)
			p.Match(SQLiteParserK_CONSTRAINT)
		}
		{
			p.SetState(1032)
			p.Name()
		}

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

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserK_PRIMARY:
		{
			p.SetState(1035)
			p.Match(SQLiteParserK_PRIMARY)
		}
		{
			p.SetState(1036)
			p.Match(SQLiteParserK_KEY)
		}
		p.SetState(1038)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserK_ASC || _la == SQLiteParserK_DESC {
			{
				p.SetState(1037)
				_la = p.GetTokenStream().LA(1)

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

		}
		{
			p.SetState(1040)
			p.Conflict_clause()
		}
		p.SetState(1042)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserK_AUTOINCREMENT {
			{
				p.SetState(1041)
				p.Match(SQLiteParserK_AUTOINCREMENT)
			}

		}

	case SQLiteParserK_NOT, SQLiteParserK_NULL:
		p.SetState(1045)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserK_NOT {
			{
				p.SetState(1044)
				p.Match(SQLiteParserK_NOT)
			}

		}
		{
			p.SetState(1047)
			p.Match(SQLiteParserK_NULL)
		}
		{
			p.SetState(1048)
			p.Conflict_clause()
		}

	case SQLiteParserK_UNIQUE:
		{
			p.SetState(1049)
			p.Match(SQLiteParserK_UNIQUE)
		}
		{
			p.SetState(1050)
			p.Conflict_clause()
		}

	case SQLiteParserK_CHECK:
		{
			p.SetState(1051)
			p.Match(SQLiteParserK_CHECK)
		}
		{
			p.SetState(1052)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1053)
			p.expr(0)
		}
		{
			p.SetState(1054)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case SQLiteParserK_DEFAULT:
		{
			p.SetState(1056)
			p.Match(SQLiteParserK_DEFAULT)
		}
		p.SetState(1063)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 144, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1057)
				p.Signed_number()
			}

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

		case 3:
			{
				p.SetState(1059)
				p.Match(SQLiteParserOPEN_PAR)
			}
			{
				p.SetState(1060)
				p.expr(0)
			}
			{
				p.SetState(1061)
				p.Match(SQLiteParserCLOSE_PAR)
			}

		}

	case SQLiteParserK_COLLATE:
		{
			p.SetState(1065)
			p.Match(SQLiteParserK_COLLATE)
		}
		{
			p.SetState(1066)
			p.Collation_name()
		}

	case SQLiteParserK_REFERENCES:
		{
			p.SetState(1067)
			p.Foreign_key_clause()
		}

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

	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) K_ON() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ON, 0)
}

func (s *Conflict_clauseContext) K_CONFLICT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CONFLICT, 0)
}

func (s *Conflict_clauseContext) K_ROLLBACK() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ROLLBACK, 0)
}

func (s *Conflict_clauseContext) K_ABORT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ABORT, 0)
}

func (s *Conflict_clauseContext) K_FAIL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_FAIL, 0)
}

func (s *Conflict_clauseContext) K_IGNORE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IGNORE, 0)
}

func (s *Conflict_clauseContext) K_REPLACE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_REPLACE, 0)
}

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

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

func (s *Conflict_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterConflict_clause(s)
	}
}

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

func (p *SQLiteParser) Conflict_clause() (localctx IConflict_clauseContext) {
	localctx = NewConflict_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 74, 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(1073)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_ON {
		{
			p.SetState(1070)
			p.Match(SQLiteParserK_ON)
		}
		{
			p.SetState(1071)
			p.Match(SQLiteParserK_CONFLICT)
		}
		{
			p.SetState(1072)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SQLiteParserK_ABORT || _la == SQLiteParserK_FAIL || _la == SQLiteParserK_IGNORE || _la == SQLiteParserK_REPLACE || _la == SQLiteParserK_ROLLBACK) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyExprContext() *ExprContext {
	var p = new(ExprContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IUnary_operatorContext)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

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

	if t == nil {
		return nil
	}

	return t.(IFunction_nameContext)
}

func (s *ExprContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(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) K_DISTINCT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DISTINCT, 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) K_CAST() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CAST, 0)
}

func (s *ExprContext) K_AS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_AS, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IType_nameContext)
}

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

	if t == nil {
		return nil
	}

	return t.(ISelect_stmtContext)
}

func (s *ExprContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_EXISTS, 0)
}

func (s *ExprContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NOT, 0)
}

func (s *ExprContext) K_CASE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CASE, 0)
}

func (s *ExprContext) K_END() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_END, 0)
}

func (s *ExprContext) AllK_WHEN() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserK_WHEN)
}

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

func (s *ExprContext) AllK_THEN() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserK_THEN)
}

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

func (s *ExprContext) K_ELSE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ELSE, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IRaise_functionContext)
}

func (s *ExprContext) PIPE2() antlr.TerminalNode {
	return s.GetToken(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) K_AND() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_AND, 0)
}

func (s *ExprContext) K_OR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_OR, 0)
}

func (s *ExprContext) K_IS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IS, 0)
}

func (s *ExprContext) K_BETWEEN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_BETWEEN, 0)
}

func (s *ExprContext) K_IN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IN, 0)
}

func (s *ExprContext) K_COLLATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_COLLATE, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(ICollation_nameContext)
}

func (s *ExprContext) K_LIKE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_LIKE, 0)
}

func (s *ExprContext) K_GLOB() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_GLOB, 0)
}

func (s *ExprContext) K_REGEXP() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_REGEXP, 0)
}

func (s *ExprContext) K_MATCH() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_MATCH, 0)
}

func (s *ExprContext) K_ESCAPE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ESCAPE, 0)
}

func (s *ExprContext) K_ISNULL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ISNULL, 0)
}

func (s *ExprContext) K_NOTNULL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NOTNULL, 0)
}

func (s *ExprContext) K_NULL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NULL, 0)
}

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

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

func (s *ExprContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterExpr(s)
	}
}

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

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

func (p *SQLiteParser) expr(_p int) (localctx IExprContext) {
	var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext()
	_parentState := p.GetState()
	localctx = NewExprContext(p, p.GetParserRuleContext(), _parentState)
	var _prevctx IExprContext = localctx
	var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning.
	_startState := 76
	p.EnterRecursionRule(localctx, 76, 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(1151)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 157, p.GetParserRuleContext()) {
	case 1:
		{
			p.SetState(1076)
			p.Literal_value()
		}

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

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

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

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 147, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1078)
					p.Database_name()
				}
				{
					p.SetState(1079)
					p.Match(SQLiteParserDOT)
				}

			}
			{
				p.SetState(1083)
				p.Table_name()
			}
			{
				p.SetState(1084)
				p.Match(SQLiteParserDOT)
			}

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

	case 4:
		{
			p.SetState(1089)
			p.Unary_operator()
		}
		{
			p.SetState(1090)
			p.expr(21)
		}

	case 5:
		{
			p.SetState(1092)
			p.Function_name()
		}
		{
			p.SetState(1093)
			p.Match(SQLiteParserOPEN_PAR)
		}
		p.SetState(1106)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SQLiteParserOPEN_PAR, SQLiteParserPLUS, SQLiteParserMINUS, SQLiteParserTILDE, SQLiteParserK_ABORT, SQLiteParserK_ACTION, SQLiteParserK_ADD, SQLiteParserK_AFTER, SQLiteParserK_ALL, SQLiteParserK_ALTER, SQLiteParserK_ANALYZE, SQLiteParserK_AND, SQLiteParserK_AS, SQLiteParserK_ASC, SQLiteParserK_ATTACH, SQLiteParserK_AUTOINCREMENT, SQLiteParserK_BEFORE, SQLiteParserK_BEGIN, SQLiteParserK_BETWEEN, SQLiteParserK_BY, SQLiteParserK_CASCADE, SQLiteParserK_CASE, SQLiteParserK_CAST, SQLiteParserK_CHECK, SQLiteParserK_COLLATE, SQLiteParserK_COLUMN, SQLiteParserK_COMMIT, SQLiteParserK_CONFLICT, SQLiteParserK_CONSTRAINT, SQLiteParserK_CREATE, SQLiteParserK_CROSS, SQLiteParserK_CURRENT_DATE, SQLiteParserK_CURRENT_TIME, SQLiteParserK_CURRENT_TIMESTAMP, SQLiteParserK_DATABASE, SQLiteParserK_DEFAULT, SQLiteParserK_DEFERRABLE, SQLiteParserK_DEFERRED, SQLiteParserK_DELETE, SQLiteParserK_DESC, SQLiteParserK_DETACH, SQLiteParserK_DISTINCT, SQLiteParserK_DROP, SQLiteParserK_EACH, SQLiteParserK_ELSE, SQLiteParserK_END, SQLiteParserK_ESCAPE, SQLiteParserK_EXCEPT, SQLiteParserK_EXCLUSIVE, SQLiteParserK_EXISTS, SQLiteParserK_EXPLAIN, SQLiteParserK_FAIL, SQLiteParserK_FOR, SQLiteParserK_FOREIGN, SQLiteParserK_FROM, SQLiteParserK_FULL, SQLiteParserK_GLOB, SQLiteParserK_GROUP, SQLiteParserK_HAVING, SQLiteParserK_IF, SQLiteParserK_IGNORE, SQLiteParserK_IMMEDIATE, SQLiteParserK_IN, SQLiteParserK_INDEX, SQLiteParserK_INDEXED, SQLiteParserK_INITIALLY, SQLiteParserK_INNER, SQLiteParserK_INSERT, SQLiteParserK_INSTEAD, SQLiteParserK_INTERSECT, SQLiteParserK_INTO, SQLiteParserK_IS, SQLiteParserK_ISNULL, SQLiteParserK_JOIN, SQLiteParserK_KEY, SQLiteParserK_LEFT, SQLiteParserK_LIKE, SQLiteParserK_LIMIT, SQLiteParserK_MATCH, SQLiteParserK_NATURAL, SQLiteParserK_NO, SQLiteParserK_NOT, SQLiteParserK_NOTNULL, SQLiteParserK_NULL, SQLiteParserK_OF, SQLiteParserK_OFFSET, SQLiteParserK_ON, SQLiteParserK_OR, SQLiteParserK_ORDER, SQLiteParserK_OUTER, SQLiteParserK_PLAN, SQLiteParserK_PRAGMA, SQLiteParserK_PRIMARY, SQLiteParserK_QUERY, SQLiteParserK_RAISE, SQLiteParserK_RECURSIVE, SQLiteParserK_REFERENCES, SQLiteParserK_REGEXP, SQLiteParserK_REINDEX, SQLiteParserK_RELEASE, SQLiteParserK_RENAME, SQLiteParserK_REPLACE, SQLiteParserK_RESTRICT, SQLiteParserK_RIGHT, SQLiteParserK_ROLLBACK, SQLiteParserK_ROW, SQLiteParserK_SAVEPOINT, SQLiteParserK_SELECT, SQLiteParserK_SET, SQLiteParserK_TABLE, SQLiteParserK_TEMP, SQLiteParserK_TEMPORARY, SQLiteParserK_THEN, SQLiteParserK_TO, SQLiteParserK_TRANSACTION, SQLiteParserK_TRIGGER, SQLiteParserK_UNION, SQLiteParserK_UNIQUE, SQLiteParserK_UPDATE, SQLiteParserK_USING, SQLiteParserK_VACUUM, SQLiteParserK_VALUES, SQLiteParserK_VIEW, SQLiteParserK_VIRTUAL, SQLiteParserK_WHEN, SQLiteParserK_WHERE, SQLiteParserK_WITH, SQLiteParserK_WITHOUT, SQLiteParserIDENTIFIER, SQLiteParserNUMERIC_LITERAL, SQLiteParserBIND_PARAMETER, SQLiteParserSTRING_LITERAL, SQLiteParserBLOB_LITERAL:
			p.SetState(1095)
			p.GetErrorHandler().Sync(p)

			if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 149, p.GetParserRuleContext()) == 1 {
				{
					p.SetState(1094)
					p.Match(SQLiteParserK_DISTINCT)
				}

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

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(1098)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(1099)
					p.expr(0)
				}

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

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

		case SQLiteParserCLOSE_PAR:

		default:
		}
		{
			p.SetState(1108)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case 6:
		{
			p.SetState(1110)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1111)
			p.expr(0)
		}
		{
			p.SetState(1112)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case 7:
		{
			p.SetState(1114)
			p.Match(SQLiteParserK_CAST)
		}
		{
			p.SetState(1115)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1116)
			p.expr(0)
		}
		{
			p.SetState(1117)
			p.Match(SQLiteParserK_AS)
		}
		{
			p.SetState(1118)
			p.Type_name()
		}
		{
			p.SetState(1119)
			p.Match(SQLiteParserCLOSE_PAR)
		}

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

		if _la == SQLiteParserK_EXISTS || _la == SQLiteParserK_NOT {
			p.SetState(1122)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == SQLiteParserK_NOT {
				{
					p.SetState(1121)
					p.Match(SQLiteParserK_NOT)
				}

			}
			{
				p.SetState(1124)
				p.Match(SQLiteParserK_EXISTS)
			}

		}
		{
			p.SetState(1127)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1128)
			p.Select_stmt()
		}
		{
			p.SetState(1129)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case 9:
		{
			p.SetState(1131)
			p.Match(SQLiteParserK_CASE)
		}
		p.SetState(1133)
		p.GetErrorHandler().Sync(p)

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

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

		for ok := true; ok; ok = _la == SQLiteParserK_WHEN {
			{
				p.SetState(1135)
				p.Match(SQLiteParserK_WHEN)
			}
			{
				p.SetState(1136)
				p.expr(0)
			}
			{
				p.SetState(1137)
				p.Match(SQLiteParserK_THEN)
			}
			{
				p.SetState(1138)
				p.expr(0)
			}

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

		if _la == SQLiteParserK_ELSE {
			{
				p.SetState(1144)
				p.Match(SQLiteParserK_ELSE)
			}
			{
				p.SetState(1145)
				p.expr(0)
			}

		}
		{
			p.SetState(1148)
			p.Match(SQLiteParserK_END)
		}

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

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

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

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

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

				if !(p.Precpred(p.GetParserRuleContext(), 19)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 19)", ""))
				}
				{
					p.SetState(1157)
					_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(1158)
					p.expr(20)
				}

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

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

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

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

				if !(p.Precpred(p.GetParserRuleContext(), 17)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 17)", ""))
				}
				{
					p.SetState(1163)
					_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(1164)
					p.expr(18)
				}

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

				if !(p.Precpred(p.GetParserRuleContext(), 16)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 16)", ""))
				}
				{
					p.SetState(1166)
					_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(1167)
					p.expr(17)
				}

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

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

					if !(((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SQLiteParserASSIGN)|(1<<SQLiteParserEQ)|(1<<SQLiteParserNOT_EQ1)|(1<<SQLiteParserNOT_EQ2))) != 0) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1170)
					p.expr(16)
				}

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

				if !(p.Precpred(p.GetParserRuleContext(), 13)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 13)", ""))
				}
				{
					p.SetState(1172)
					p.Match(SQLiteParserK_AND)
				}
				{
					p.SetState(1173)
					p.expr(14)
				}

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

				if !(p.Precpred(p.GetParserRuleContext(), 12)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 12)", ""))
				}
				{
					p.SetState(1175)
					p.Match(SQLiteParserK_OR)
				}
				{
					p.SetState(1176)
					p.expr(13)
				}

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

				if !(p.Precpred(p.GetParserRuleContext(), 5)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
				}
				{
					p.SetState(1178)
					p.Match(SQLiteParserK_IS)
				}
				p.SetState(1180)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 158, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(1179)
						p.Match(SQLiteParserK_NOT)
					}

				}
				{
					p.SetState(1182)
					p.expr(6)
				}

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

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

				if _la == SQLiteParserK_NOT {
					{
						p.SetState(1184)
						p.Match(SQLiteParserK_NOT)
					}

				}
				{
					p.SetState(1187)
					p.Match(SQLiteParserK_BETWEEN)
				}
				{
					p.SetState(1188)
					p.expr(0)
				}
				{
					p.SetState(1189)
					p.Match(SQLiteParserK_AND)
				}
				{
					p.SetState(1190)
					p.expr(5)
				}

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

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

				if _la == SQLiteParserK_NOT {
					{
						p.SetState(1193)
						p.Match(SQLiteParserK_NOT)
					}

				}
				{
					p.SetState(1196)
					p.Match(SQLiteParserK_IN)
				}
				p.SetState(1216)
				p.GetErrorHandler().Sync(p)
				switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 164, p.GetParserRuleContext()) {
				case 1:
					{
						p.SetState(1197)
						p.Match(SQLiteParserOPEN_PAR)
					}
					p.SetState(1207)
					p.GetErrorHandler().Sync(p)

					if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 162, p.GetParserRuleContext()) == 1 {
						{
							p.SetState(1198)
							p.Select_stmt()
						}

					} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 162, p.GetParserRuleContext()) == 2 {
						{
							p.SetState(1199)
							p.expr(0)
						}
						p.SetState(1204)
						p.GetErrorHandler().Sync(p)
						_la = p.GetTokenStream().LA(1)

						for _la == SQLiteParserCOMMA {
							{
								p.SetState(1200)
								p.Match(SQLiteParserCOMMA)
							}
							{
								p.SetState(1201)
								p.expr(0)
							}

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

					}
					{
						p.SetState(1209)
						p.Match(SQLiteParserCLOSE_PAR)
					}

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

					if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 163, p.GetParserRuleContext()) == 1 {
						{
							p.SetState(1210)
							p.Database_name()
						}
						{
							p.SetState(1211)
							p.Match(SQLiteParserDOT)
						}

					}
					{
						p.SetState(1215)
						p.Table_name()
					}

				}

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

				if !(p.Precpred(p.GetParserRuleContext(), 8)) {
					panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", ""))
				}
				{
					p.SetState(1219)
					p.Match(SQLiteParserK_COLLATE)
				}
				{
					p.SetState(1220)
					p.Collation_name()
				}

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

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

				if _la == SQLiteParserK_NOT {
					{
						p.SetState(1222)
						p.Match(SQLiteParserK_NOT)
					}

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

					if !((((_la-77)&-(0x1f+1)) == 0 && ((1<<uint((_la-77)))&((1<<(SQLiteParserK_GLOB-77))|(1<<(SQLiteParserK_LIKE-77))|(1<<(SQLiteParserK_MATCH-77)))) != 0) || _la == SQLiteParserK_REGEXP) {
						p.GetErrorHandler().RecoverInline(p)
					} else {
						p.GetErrorHandler().ReportMatch(p)
						p.Consume()
					}
				}
				{
					p.SetState(1226)
					p.expr(0)
				}
				p.SetState(1229)
				p.GetErrorHandler().Sync(p)

				if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 166, p.GetParserRuleContext()) == 1 {
					{
						p.SetState(1227)
						p.Match(SQLiteParserK_ESCAPE)
					}
					{
						p.SetState(1228)
						p.expr(0)
					}

				}

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

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

				switch p.GetTokenStream().LA(1) {
				case SQLiteParserK_ISNULL:
					{
						p.SetState(1232)
						p.Match(SQLiteParserK_ISNULL)
					}

				case SQLiteParserK_NOTNULL:
					{
						p.SetState(1233)
						p.Match(SQLiteParserK_NOTNULL)
					}

				case SQLiteParserK_NOT:
					{
						p.SetState(1234)
						p.Match(SQLiteParserK_NOT)
					}
					{
						p.SetState(1235)
						p.Match(SQLiteParserK_NULL)
					}

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

			}

		}
		p.SetState(1242)
		p.GetErrorHandler().Sync(p)
		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 169, p.GetParserRuleContext())
	}

	return localctx
}

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

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

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

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

func NewEmptyForeign_key_clauseContext() *Foreign_key_clauseContext {
	var p = new(Foreign_key_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_REFERENCES() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_REFERENCES, 0)
}

func (s *Foreign_key_clauseContext) Foreign_table() IForeign_tableContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IForeign_tableContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IForeign_tableContext)
}

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

func (s *Foreign_key_clauseContext) AllK_ON() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserK_ON)
}

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

func (s *Foreign_key_clauseContext) AllK_MATCH() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserK_MATCH)
}

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

func (s *Foreign_key_clauseContext) AllName() []INameContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*INameContext)(nil)).Elem())
	var tst = make([]INameContext, len(ts))

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

	return tst
}

func (s *Foreign_key_clauseContext) Name(i int) INameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*INameContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

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

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

func (s *Foreign_key_clauseContext) AllK_DELETE() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserK_DELETE)
}

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

func (s *Foreign_key_clauseContext) AllK_UPDATE() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserK_UPDATE)
}

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

func (s *Foreign_key_clauseContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NOT, 0)
}

func (s *Foreign_key_clauseContext) K_INITIALLY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INITIALLY, 0)
}

func (s *Foreign_key_clauseContext) K_DEFERRED() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DEFERRED, 0)
}

func (s *Foreign_key_clauseContext) K_IMMEDIATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IMMEDIATE, 0)
}

func (s *Foreign_key_clauseContext) AllK_SET() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserK_SET)
}

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

func (s *Foreign_key_clauseContext) AllK_NULL() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserK_NULL)
}

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

func (s *Foreign_key_clauseContext) AllK_DEFAULT() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserK_DEFAULT)
}

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

func (s *Foreign_key_clauseContext) AllK_CASCADE() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserK_CASCADE)
}

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

func (s *Foreign_key_clauseContext) AllK_RESTRICT() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserK_RESTRICT)
}

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

func (s *Foreign_key_clauseContext) AllK_NO() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserK_NO)
}

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

func (s *Foreign_key_clauseContext) AllK_ACTION() []antlr.TerminalNode {
	return s.GetTokens(SQLiteParserK_ACTION)
}

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

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

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

func (s *Foreign_key_clauseContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterForeign_key_clause(s)
	}
}

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

func (p *SQLiteParser) Foreign_key_clause() (localctx IForeign_key_clauseContext) {
	localctx = NewForeign_key_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 78, 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(1243)
		p.Match(SQLiteParserK_REFERENCES)
	}
	{
		p.SetState(1244)
		p.Foreign_table()
	}
	p.SetState(1256)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserOPEN_PAR {
		{
			p.SetState(1245)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1246)
			p.Column_name()
		}
		p.SetState(1251)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1247)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1248)
				p.Column_name()
			}

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

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

	for _la == SQLiteParserK_MATCH || _la == SQLiteParserK_ON {
		p.SetState(1272)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SQLiteParserK_ON:
			{
				p.SetState(1258)
				p.Match(SQLiteParserK_ON)
			}
			{
				p.SetState(1259)
				_la = p.GetTokenStream().LA(1)

				if !(_la == SQLiteParserK_DELETE || _la == SQLiteParserK_UPDATE) {
					p.GetErrorHandler().RecoverInline(p)
				} else {
					p.GetErrorHandler().ReportMatch(p)
					p.Consume()
				}
			}
			p.SetState(1268)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 172, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(1260)
					p.Match(SQLiteParserK_SET)
				}
				{
					p.SetState(1261)
					p.Match(SQLiteParserK_NULL)
				}

			case 2:
				{
					p.SetState(1262)
					p.Match(SQLiteParserK_SET)
				}
				{
					p.SetState(1263)
					p.Match(SQLiteParserK_DEFAULT)
				}

			case 3:
				{
					p.SetState(1264)
					p.Match(SQLiteParserK_CASCADE)
				}

			case 4:
				{
					p.SetState(1265)
					p.Match(SQLiteParserK_RESTRICT)
				}

			case 5:
				{
					p.SetState(1266)
					p.Match(SQLiteParserK_NO)
				}
				{
					p.SetState(1267)
					p.Match(SQLiteParserK_ACTION)
				}

			}

		case SQLiteParserK_MATCH:
			{
				p.SetState(1270)
				p.Match(SQLiteParserK_MATCH)
			}
			{
				p.SetState(1271)
				p.Name()
			}

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

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

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

		if _la == SQLiteParserK_NOT {
			{
				p.SetState(1279)
				p.Match(SQLiteParserK_NOT)
			}

		}
		{
			p.SetState(1282)
			p.Match(SQLiteParserK_DEFERRABLE)
		}
		p.SetState(1287)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 176, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1283)
				p.Match(SQLiteParserK_INITIALLY)
			}
			{
				p.SetState(1284)
				p.Match(SQLiteParserK_DEFERRED)
			}

		} else if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 176, p.GetParserRuleContext()) == 2 {
			{
				p.SetState(1285)
				p.Match(SQLiteParserK_INITIALLY)
			}
			{
				p.SetState(1286)
				p.Match(SQLiteParserK_IMMEDIATE)
			}

		}

	}

	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) K_RAISE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_RAISE, 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) K_IGNORE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IGNORE, 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) K_ROLLBACK() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ROLLBACK, 0)
}

func (s *Raise_functionContext) K_ABORT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ABORT, 0)
}

func (s *Raise_functionContext) K_FAIL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_FAIL, 0)
}

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

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

func (s *Raise_functionContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterRaise_function(s)
	}
}

func (s *Raise_functionContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitRaise_function(s)
	}
}

func (p *SQLiteParser) Raise_function() (localctx IRaise_functionContext) {
	localctx = NewRaise_functionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 80, 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(1291)
		p.Match(SQLiteParserK_RAISE)
	}
	{
		p.SetState(1292)
		p.Match(SQLiteParserOPEN_PAR)
	}
	p.SetState(1297)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserK_IGNORE:
		{
			p.SetState(1293)
			p.Match(SQLiteParserK_IGNORE)
		}

	case SQLiteParserK_ABORT, SQLiteParserK_FAIL, SQLiteParserK_ROLLBACK:
		{
			p.SetState(1294)
			_la = p.GetTokenStream().LA(1)

			if !(_la == SQLiteParserK_ABORT || _la == SQLiteParserK_FAIL || _la == SQLiteParserK_ROLLBACK) {
				p.GetErrorHandler().RecoverInline(p)
			} else {
				p.GetErrorHandler().ReportMatch(p)
				p.Consume()
			}
		}
		{
			p.SetState(1295)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(1296)
			p.Error_message()
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}
	{
		p.SetState(1299)
		p.Match(SQLiteParserCLOSE_PAR)
	}

	return localctx
}

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

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

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

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

func NewEmptyIndexed_columnContext() *Indexed_columnContext {
	var p = new(Indexed_columnContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_COLLATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_COLLATE, 0)
}

func (s *Indexed_columnContext) Collation_name() ICollation_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollation_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICollation_nameContext)
}

func (s *Indexed_columnContext) K_ASC() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ASC, 0)
}

func (s *Indexed_columnContext) K_DESC() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DESC, 0)
}

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

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

func (s *Indexed_columnContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterIndexed_column(s)
	}
}

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

func (p *SQLiteParser) Indexed_column() (localctx IIndexed_columnContext) {
	localctx = NewIndexed_columnContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 82, 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(1301)
		p.Column_name()
	}
	p.SetState(1304)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_COLLATE {
		{
			p.SetState(1302)
			p.Match(SQLiteParserK_COLLATE)
		}
		{
			p.SetState(1303)
			p.Collation_name()
		}

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

	if _la == SQLiteParserK_ASC || _la == SQLiteParserK_DESC {
		{
			p.SetState(1306)
			_la = p.GetTokenStream().LA(1)

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

	}

	return localctx
}

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

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

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

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

func NewEmptyTable_constraintContext() *Table_constraintContext {
	var p = new(Table_constraintContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) 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) K_CHECK() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CHECK, 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) K_FOREIGN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_FOREIGN, 0)
}

func (s *Table_constraintContext) K_KEY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_KEY, 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) K_CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CONSTRAINT, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(INameContext)
}

func (s *Table_constraintContext) K_PRIMARY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_PRIMARY, 0)
}

func (s *Table_constraintContext) K_UNIQUE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_UNIQUE, 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) 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.(SQLiteListener); ok {
		listenerT.EnterTable_constraint(s)
	}
}

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

func (p *SQLiteParser) Table_constraint() (localctx ITable_constraintContext) {
	localctx = NewTable_constraintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 84, 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(1311)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_CONSTRAINT {
		{
			p.SetState(1309)
			p.Match(SQLiteParserK_CONSTRAINT)
		}
		{
			p.SetState(1310)
			p.Name()
		}

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

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserK_PRIMARY, SQLiteParserK_UNIQUE:
		p.SetState(1316)
		p.GetErrorHandler().Sync(p)

		switch p.GetTokenStream().LA(1) {
		case SQLiteParserK_PRIMARY:
			{
				p.SetState(1313)
				p.Match(SQLiteParserK_PRIMARY)
			}
			{
				p.SetState(1314)
				p.Match(SQLiteParserK_KEY)
			}

		case SQLiteParserK_UNIQUE:
			{
				p.SetState(1315)
				p.Match(SQLiteParserK_UNIQUE)
			}

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

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1320)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1321)
				p.Indexed_column()
			}

			p.SetState(1326)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1327)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		{
			p.SetState(1328)
			p.Conflict_clause()
		}

	case SQLiteParserK_CHECK:
		{
			p.SetState(1330)
			p.Match(SQLiteParserK_CHECK)
		}
		{
			p.SetState(1331)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1332)
			p.expr(0)
		}
		{
			p.SetState(1333)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case SQLiteParserK_FOREIGN:
		{
			p.SetState(1335)
			p.Match(SQLiteParserK_FOREIGN)
		}
		{
			p.SetState(1336)
			p.Match(SQLiteParserK_KEY)
		}
		{
			p.SetState(1337)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1338)
			p.Column_name()
		}
		p.SetState(1343)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1339)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1340)
				p.Column_name()
			}

			p.SetState(1345)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1346)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		{
			p.SetState(1347)
			p.Foreign_key_clause()
		}

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

	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) K_WITH() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_WITH, 0)
}

func (s *With_clauseContext) 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 *With_clauseContext) 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 *With_clauseContext) K_RECURSIVE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_RECURSIVE, 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.(SQLiteListener); ok {
		listenerT.EnterWith_clause(s)
	}
}

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

func (p *SQLiteParser) With_clause() (localctx IWith_clauseContext) {
	localctx = NewWith_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 86, 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(1351)
		p.Match(SQLiteParserK_WITH)
	}
	p.SetState(1353)
	p.GetErrorHandler().Sync(p)

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 186, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1352)
			p.Match(SQLiteParserK_RECURSIVE)
		}

	}
	{
		p.SetState(1355)
		p.Common_table_expression()
	}
	p.SetState(1360)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserCOMMA {
		{
			p.SetState(1356)
			p.Match(SQLiteParserCOMMA)
		}
		{
			p.SetState(1357)
			p.Common_table_expression()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyQualified_table_nameContext() *Qualified_table_nameContext {
	var p = new(Qualified_table_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) Database_name() IDatabase_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDatabase_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IDatabase_nameContext)
}

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

func (s *Qualified_table_nameContext) K_INDEXED() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INDEXED, 0)
}

func (s *Qualified_table_nameContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_BY, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IIndex_nameContext)
}

func (s *Qualified_table_nameContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NOT, 0)
}

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

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

func (s *Qualified_table_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterQualified_table_name(s)
	}
}

func (s *Qualified_table_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitQualified_table_name(s)
	}
}

func (p *SQLiteParser) Qualified_table_name() (localctx IQualified_table_nameContext) {
	localctx = NewQualified_table_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 88, SQLiteParserRULE_qualified_table_name)

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

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

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

	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 188, p.GetParserRuleContext()) == 1 {
		{
			p.SetState(1363)
			p.Database_name()
		}
		{
			p.SetState(1364)
			p.Match(SQLiteParserDOT)
		}

	}
	{
		p.SetState(1368)
		p.Table_name()
	}
	p.SetState(1374)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserK_INDEXED:
		{
			p.SetState(1369)
			p.Match(SQLiteParserK_INDEXED)
		}
		{
			p.SetState(1370)
			p.Match(SQLiteParserK_BY)
		}
		{
			p.SetState(1371)
			p.Index_name()
		}

	case SQLiteParserK_NOT:
		{
			p.SetState(1372)
			p.Match(SQLiteParserK_NOT)
		}
		{
			p.SetState(1373)
			p.Match(SQLiteParserK_INDEXED)
		}

	case SQLiteParserEOF, SQLiteParserSCOL, SQLiteParserK_ALTER, SQLiteParserK_ANALYZE, SQLiteParserK_ATTACH, SQLiteParserK_BEGIN, SQLiteParserK_COMMIT, SQLiteParserK_CREATE, SQLiteParserK_DELETE, SQLiteParserK_DETACH, SQLiteParserK_DROP, SQLiteParserK_END, SQLiteParserK_EXPLAIN, SQLiteParserK_INSERT, SQLiteParserK_LIMIT, SQLiteParserK_ORDER, SQLiteParserK_PRAGMA, SQLiteParserK_REINDEX, SQLiteParserK_RELEASE, SQLiteParserK_REPLACE, SQLiteParserK_ROLLBACK, SQLiteParserK_SAVEPOINT, SQLiteParserK_SELECT, SQLiteParserK_SET, SQLiteParserK_UPDATE, SQLiteParserK_VACUUM, SQLiteParserK_VALUES, SQLiteParserK_WHERE, SQLiteParserK_WITH:

	default:
	}

	return localctx
}

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

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

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

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

func NewEmptyOrdering_termContext() *Ordering_termContext {
	var p = new(Ordering_termContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_COLLATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_COLLATE, 0)
}

func (s *Ordering_termContext) Collation_name() ICollation_nameContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ICollation_nameContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(ICollation_nameContext)
}

func (s *Ordering_termContext) K_ASC() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ASC, 0)
}

func (s *Ordering_termContext) K_DESC() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DESC, 0)
}

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

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

func (s *Ordering_termContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterOrdering_term(s)
	}
}

func (s *Ordering_termContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitOrdering_term(s)
	}
}

func (p *SQLiteParser) Ordering_term() (localctx IOrdering_termContext) {
	localctx = NewOrdering_termContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 90, 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(1376)
		p.expr(0)
	}
	p.SetState(1379)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserK_COLLATE {
		{
			p.SetState(1377)
			p.Match(SQLiteParserK_COLLATE)
		}
		{
			p.SetState(1378)
			p.Collation_name()
		}

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

	if _la == SQLiteParserK_ASC || _la == SQLiteParserK_DESC {
		{
			p.SetState(1381)
			_la = p.GetTokenStream().LA(1)

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

	}

	return localctx
}

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

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

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

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

func NewEmptyPragma_valueContext() *Pragma_valueContext {
	var p = new(Pragma_valueContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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.(SQLiteListener); ok {
		listenerT.EnterPragma_value(s)
	}
}

func (s *Pragma_valueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitPragma_value(s)
	}
}

func (p *SQLiteParser) Pragma_value() (localctx IPragma_valueContext) {
	localctx = NewPragma_valueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 92, 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(1387)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 192, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1384)
			p.Signed_number()
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1385)
			p.Name()
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1386)
			p.Match(SQLiteParserSTRING_LITERAL)
		}

	}

	return localctx
}

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

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

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

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

func NewEmptyCommon_table_expressionContext() *Common_table_expressionContext {
	var p = new(Common_table_expressionContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_AS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_AS, 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.(SQLiteListener); ok {
		listenerT.EnterCommon_table_expression(s)
	}
}

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

func (p *SQLiteParser) Common_table_expression() (localctx ICommon_table_expressionContext) {
	localctx = NewCommon_table_expressionContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 94, 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(1389)
		p.Table_name()
	}
	p.SetState(1401)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	if _la == SQLiteParserOPEN_PAR {
		{
			p.SetState(1390)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1391)
			p.Column_name()
		}
		p.SetState(1396)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1392)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1393)
				p.Column_name()
			}

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

	}
	{
		p.SetState(1403)
		p.Match(SQLiteParserK_AS)
	}
	{
		p.SetState(1404)
		p.Match(SQLiteParserOPEN_PAR)
	}
	{
		p.SetState(1405)
		p.Select_stmt()
	}
	{
		p.SetState(1406)
		p.Match(SQLiteParserCLOSE_PAR)
	}

	return localctx
}

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

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

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

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

func NewEmptyResult_columnContext() *Result_columnContext {
	var p = new(Result_columnContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_AS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_AS, 0)
}

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

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

func (s *Result_columnContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterResult_column(s)
	}
}

func (s *Result_columnContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitResult_column(s)
	}
}

func (p *SQLiteParser) Result_column() (localctx IResult_columnContext) {
	localctx = NewResult_columnContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 96, 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(1420)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 197, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1408)
			p.Match(SQLiteParserSTAR)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1409)
			p.Table_name()
		}
		{
			p.SetState(1410)
			p.Match(SQLiteParserDOT)
		}
		{
			p.SetState(1411)
			p.Match(SQLiteParserSTAR)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1413)
			p.expr(0)
		}
		p.SetState(1418)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserK_AS || _la == SQLiteParserIDENTIFIER || _la == SQLiteParserSTRING_LITERAL {
			p.SetState(1415)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == SQLiteParserK_AS {
				{
					p.SetState(1414)
					p.Match(SQLiteParserK_AS)
				}

			}
			{
				p.SetState(1417)
				p.Column_alias()
			}

		}

	}

	return localctx
}

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

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

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

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

func NewEmptyTable_or_subqueryContext() *Table_or_subqueryContext {
	var p = new(Table_or_subqueryContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_INDEXED() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INDEXED, 0)
}

func (s *Table_or_subqueryContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_BY, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IIndex_nameContext)
}

func (s *Table_or_subqueryContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NOT, 0)
}

func (s *Table_or_subqueryContext) K_AS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_AS, 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) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_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) 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.(SQLiteListener); ok {
		listenerT.EnterTable_or_subquery(s)
	}
}

func (s *Table_or_subqueryContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitTable_or_subquery(s)
	}
}

func (p *SQLiteParser) Table_or_subquery() (localctx ITable_or_subqueryContext) {
	localctx = NewTable_or_subqueryContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 98, 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(1488)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 211, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		p.SetState(1425)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 198, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1422)
				p.Schema_name()
			}
			{
				p.SetState(1423)
				p.Match(SQLiteParserDOT)
			}

		}
		{
			p.SetState(1427)
			p.Table_name()
		}
		p.SetState(1432)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserOPEN_PAR || _la == SQLiteParserK_AS || _la == SQLiteParserIDENTIFIER || _la == SQLiteParserSTRING_LITERAL {
			p.SetState(1429)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == SQLiteParserK_AS {
				{
					p.SetState(1428)
					p.Match(SQLiteParserK_AS)
				}

			}
			{
				p.SetState(1431)
				p.Table_alias()
			}

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

		switch p.GetTokenStream().LA(1) {
		case SQLiteParserK_INDEXED:
			{
				p.SetState(1434)
				p.Match(SQLiteParserK_INDEXED)
			}
			{
				p.SetState(1435)
				p.Match(SQLiteParserK_BY)
			}
			{
				p.SetState(1436)
				p.Index_name()
			}

		case SQLiteParserK_NOT:
			{
				p.SetState(1437)
				p.Match(SQLiteParserK_NOT)
			}
			{
				p.SetState(1438)
				p.Match(SQLiteParserK_INDEXED)
			}

		case SQLiteParserEOF, SQLiteParserSCOL, SQLiteParserCLOSE_PAR, SQLiteParserCOMMA, SQLiteParserK_ALTER, SQLiteParserK_ANALYZE, SQLiteParserK_ATTACH, SQLiteParserK_BEGIN, SQLiteParserK_COMMIT, SQLiteParserK_CREATE, SQLiteParserK_CROSS, SQLiteParserK_DELETE, SQLiteParserK_DETACH, SQLiteParserK_DROP, SQLiteParserK_END, SQLiteParserK_EXCEPT, SQLiteParserK_EXPLAIN, SQLiteParserK_GROUP, SQLiteParserK_INNER, SQLiteParserK_INSERT, SQLiteParserK_INTERSECT, SQLiteParserK_JOIN, SQLiteParserK_LEFT, SQLiteParserK_LIMIT, SQLiteParserK_NATURAL, SQLiteParserK_ON, SQLiteParserK_ORDER, SQLiteParserK_PRAGMA, SQLiteParserK_REINDEX, SQLiteParserK_RELEASE, SQLiteParserK_REPLACE, SQLiteParserK_ROLLBACK, SQLiteParserK_SAVEPOINT, SQLiteParserK_SELECT, SQLiteParserK_UNION, SQLiteParserK_UPDATE, SQLiteParserK_USING, SQLiteParserK_VACUUM, SQLiteParserK_VALUES, SQLiteParserK_WHERE, SQLiteParserK_WITH:

		default:
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(1444)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 202, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1441)
				p.Schema_name()
			}
			{
				p.SetState(1442)
				p.Match(SQLiteParserDOT)
			}

		}
		{
			p.SetState(1446)
			p.Table_function_name()
		}
		{
			p.SetState(1447)
			p.Match(SQLiteParserOPEN_PAR)
		}
		p.SetState(1456)
		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<<SQLiteParserK_ABORT)|(1<<SQLiteParserK_ACTION)|(1<<SQLiteParserK_ADD)|(1<<SQLiteParserK_AFTER)|(1<<SQLiteParserK_ALL)|(1<<SQLiteParserK_ALTER)|(1<<SQLiteParserK_ANALYZE))) != 0) || (((_la-32)&-(0x1f+1)) == 0 && ((1<<uint((_la-32)))&((1<<(SQLiteParserK_AND-32))|(1<<(SQLiteParserK_AS-32))|(1<<(SQLiteParserK_ASC-32))|(1<<(SQLiteParserK_ATTACH-32))|(1<<(SQLiteParserK_AUTOINCREMENT-32))|(1<<(SQLiteParserK_BEFORE-32))|(1<<(SQLiteParserK_BEGIN-32))|(1<<(SQLiteParserK_BETWEEN-32))|(1<<(SQLiteParserK_BY-32))|(1<<(SQLiteParserK_CASCADE-32))|(1<<(SQLiteParserK_CASE-32))|(1<<(SQLiteParserK_CAST-32))|(1<<(SQLiteParserK_CHECK-32))|(1<<(SQLiteParserK_COLLATE-32))|(1<<(SQLiteParserK_COLUMN-32))|(1<<(SQLiteParserK_COMMIT-32))|(1<<(SQLiteParserK_CONFLICT-32))|(1<<(SQLiteParserK_CONSTRAINT-32))|(1<<(SQLiteParserK_CREATE-32))|(1<<(SQLiteParserK_CROSS-32))|(1<<(SQLiteParserK_CURRENT_DATE-32))|(1<<(SQLiteParserK_CURRENT_TIME-32))|(1<<(SQLiteParserK_CURRENT_TIMESTAMP-32))|(1<<(SQLiteParserK_DATABASE-32))|(1<<(SQLiteParserK_DEFAULT-32))|(1<<(SQLiteParserK_DEFERRABLE-32))|(1<<(SQLiteParserK_DEFERRED-32))|(1<<(SQLiteParserK_DELETE-32))|(1<<(SQLiteParserK_DESC-32))|(1<<(SQLiteParserK_DETACH-32))|(1<<(SQLiteParserK_DISTINCT-32))|(1<<(SQLiteParserK_DROP-32)))) != 0) || (((_la-64)&-(0x1f+1)) == 0 && ((1<<uint((_la-64)))&((1<<(SQLiteParserK_EACH-64))|(1<<(SQLiteParserK_ELSE-64))|(1<<(SQLiteParserK_END-64))|(1<<(SQLiteParserK_ESCAPE-64))|(1<<(SQLiteParserK_EXCEPT-64))|(1<<(SQLiteParserK_EXCLUSIVE-64))|(1<<(SQLiteParserK_EXISTS-64))|(1<<(SQLiteParserK_EXPLAIN-64))|(1<<(SQLiteParserK_FAIL-64))|(1<<(SQLiteParserK_FOR-64))|(1<<(SQLiteParserK_FOREIGN-64))|(1<<(SQLiteParserK_FROM-64))|(1<<(SQLiteParserK_FULL-64))|(1<<(SQLiteParserK_GLOB-64))|(1<<(SQLiteParserK_GROUP-64))|(1<<(SQLiteParserK_HAVING-64))|(1<<(SQLiteParserK_IF-64))|(1<<(SQLiteParserK_IGNORE-64))|(1<<(SQLiteParserK_IMMEDIATE-64))|(1<<(SQLiteParserK_IN-64))|(1<<(SQLiteParserK_INDEX-64))|(1<<(SQLiteParserK_INDEXED-64))|(1<<(SQLiteParserK_INITIALLY-64))|(1<<(SQLiteParserK_INNER-64))|(1<<(SQLiteParserK_INSERT-64))|(1<<(SQLiteParserK_INSTEAD-64))|(1<<(SQLiteParserK_INTERSECT-64))|(1<<(SQLiteParserK_INTO-64))|(1<<(SQLiteParserK_IS-64))|(1<<(SQLiteParserK_ISNULL-64))|(1<<(SQLiteParserK_JOIN-64))|(1<<(SQLiteParserK_KEY-64)))) != 0) || (((_la-96)&-(0x1f+1)) == 0 && ((1<<uint((_la-96)))&((1<<(SQLiteParserK_LEFT-96))|(1<<(SQLiteParserK_LIKE-96))|(1<<(SQLiteParserK_LIMIT-96))|(1<<(SQLiteParserK_MATCH-96))|(1<<(SQLiteParserK_NATURAL-96))|(1<<(SQLiteParserK_NO-96))|(1<<(SQLiteParserK_NOT-96))|(1<<(SQLiteParserK_NOTNULL-96))|(1<<(SQLiteParserK_NULL-96))|(1<<(SQLiteParserK_OF-96))|(1<<(SQLiteParserK_OFFSET-96))|(1<<(SQLiteParserK_ON-96))|(1<<(SQLiteParserK_OR-96))|(1<<(SQLiteParserK_ORDER-96))|(1<<(SQLiteParserK_OUTER-96))|(1<<(SQLiteParserK_PLAN-96))|(1<<(SQLiteParserK_PRAGMA-96))|(1<<(SQLiteParserK_PRIMARY-96))|(1<<(SQLiteParserK_QUERY-96))|(1<<(SQLiteParserK_RAISE-96))|(1<<(SQLiteParserK_RECURSIVE-96))|(1<<(SQLiteParserK_REFERENCES-96))|(1<<(SQLiteParserK_REGEXP-96))|(1<<(SQLiteParserK_REINDEX-96))|(1<<(SQLiteParserK_RELEASE-96))|(1<<(SQLiteParserK_RENAME-96))|(1<<(SQLiteParserK_REPLACE-96))|(1<<(SQLiteParserK_RESTRICT-96))|(1<<(SQLiteParserK_RIGHT-96))|(1<<(SQLiteParserK_ROLLBACK-96))|(1<<(SQLiteParserK_ROW-96))|(1<<(SQLiteParserK_SAVEPOINT-96)))) != 0) || (((_la-128)&-(0x1f+1)) == 0 && ((1<<uint((_la-128)))&((1<<(SQLiteParserK_SELECT-128))|(1<<(SQLiteParserK_SET-128))|(1<<(SQLiteParserK_TABLE-128))|(1<<(SQLiteParserK_TEMP-128))|(1<<(SQLiteParserK_TEMPORARY-128))|(1<<(SQLiteParserK_THEN-128))|(1<<(SQLiteParserK_TO-128))|(1<<(SQLiteParserK_TRANSACTION-128))|(1<<(SQLiteParserK_TRIGGER-128))|(1<<(SQLiteParserK_UNION-128))|(1<<(SQLiteParserK_UNIQUE-128))|(1<<(SQLiteParserK_UPDATE-128))|(1<<(SQLiteParserK_USING-128))|(1<<(SQLiteParserK_VACUUM-128))|(1<<(SQLiteParserK_VALUES-128))|(1<<(SQLiteParserK_VIEW-128))|(1<<(SQLiteParserK_VIRTUAL-128))|(1<<(SQLiteParserK_WHEN-128))|(1<<(SQLiteParserK_WHERE-128))|(1<<(SQLiteParserK_WITH-128))|(1<<(SQLiteParserK_WITHOUT-128))|(1<<(SQLiteParserIDENTIFIER-128))|(1<<(SQLiteParserNUMERIC_LITERAL-128))|(1<<(SQLiteParserBIND_PARAMETER-128))|(1<<(SQLiteParserSTRING_LITERAL-128))|(1<<(SQLiteParserBLOB_LITERAL-128)))) != 0) {
			{
				p.SetState(1448)
				p.expr(0)
			}
			p.SetState(1453)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(1449)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(1450)
					p.expr(0)
				}

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

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

		if _la == SQLiteParserOPEN_PAR || _la == SQLiteParserK_AS || _la == SQLiteParserIDENTIFIER || _la == SQLiteParserSTRING_LITERAL {
			p.SetState(1460)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == SQLiteParserK_AS {
				{
					p.SetState(1459)
					p.Match(SQLiteParserK_AS)
				}

			}
			{
				p.SetState(1462)
				p.Table_alias()
			}

		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1465)
			p.Match(SQLiteParserOPEN_PAR)
		}
		p.SetState(1475)
		p.GetErrorHandler().Sync(p)
		switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 208, p.GetParserRuleContext()) {
		case 1:
			{
				p.SetState(1466)
				p.Table_or_subquery()
			}
			p.SetState(1471)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(1467)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(1468)
					p.Table_or_subquery()
				}

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

		case 2:
			{
				p.SetState(1474)
				p.Join_clause()
			}

		}
		{
			p.SetState(1477)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1479)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1480)
			p.Select_stmt()
		}
		{
			p.SetState(1481)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		p.SetState(1486)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserOPEN_PAR || _la == SQLiteParserK_AS || _la == SQLiteParserIDENTIFIER || _la == SQLiteParserSTRING_LITERAL {
			p.SetState(1483)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == SQLiteParserK_AS {
				{
					p.SetState(1482)
					p.Match(SQLiteParserK_AS)
				}

			}
			{
				p.SetState(1485)
				p.Table_alias()
			}

		}

	}

	return localctx
}

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

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

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

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

func NewEmptyJoin_clauseContext() *Join_clauseContext {
	var p = new(Join_clauseContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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.(SQLiteListener); ok {
		listenerT.EnterJoin_clause(s)
	}
}

func (s *Join_clauseContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitJoin_clause(s)
	}
}

func (p *SQLiteParser) Join_clause() (localctx IJoin_clauseContext) {
	localctx = NewJoin_clauseContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 100, 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(1490)
		p.Table_or_subquery()
	}
	p.SetState(1497)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

	for _la == SQLiteParserCOMMA || _la == SQLiteParserK_CROSS || (((_la-87)&-(0x1f+1)) == 0 && ((1<<uint((_la-87)))&((1<<(SQLiteParserK_INNER-87))|(1<<(SQLiteParserK_JOIN-87))|(1<<(SQLiteParserK_LEFT-87))|(1<<(SQLiteParserK_NATURAL-87)))) != 0) {
		{
			p.SetState(1491)
			p.Join_operator()
		}
		{
			p.SetState(1492)
			p.Table_or_subquery()
		}
		{
			p.SetState(1493)
			p.Join_constraint()
		}

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

	return localctx
}

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

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

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

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

func NewEmptyJoin_operatorContext() *Join_operatorContext {
	var p = new(Join_operatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_JOIN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_JOIN, 0)
}

func (s *Join_operatorContext) K_NATURAL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NATURAL, 0)
}

func (s *Join_operatorContext) K_LEFT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_LEFT, 0)
}

func (s *Join_operatorContext) K_INNER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INNER, 0)
}

func (s *Join_operatorContext) K_CROSS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CROSS, 0)
}

func (s *Join_operatorContext) K_OUTER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_OUTER, 0)
}

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

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

func (s *Join_operatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterJoin_operator(s)
	}
}

func (s *Join_operatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitJoin_operator(s)
	}
}

func (p *SQLiteParser) Join_operator() (localctx IJoin_operatorContext) {
	localctx = NewJoin_operatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 102, 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(1513)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserCOMMA:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1500)
			p.Match(SQLiteParserCOMMA)
		}

	case SQLiteParserK_CROSS, SQLiteParserK_INNER, SQLiteParserK_JOIN, SQLiteParserK_LEFT, SQLiteParserK_NATURAL:
		p.EnterOuterAlt(localctx, 2)
		p.SetState(1502)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		if _la == SQLiteParserK_NATURAL {
			{
				p.SetState(1501)
				p.Match(SQLiteParserK_NATURAL)
			}

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

		switch p.GetTokenStream().LA(1) {
		case SQLiteParserK_LEFT:
			{
				p.SetState(1504)
				p.Match(SQLiteParserK_LEFT)
			}
			p.SetState(1506)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			if _la == SQLiteParserK_OUTER {
				{
					p.SetState(1505)
					p.Match(SQLiteParserK_OUTER)
				}

			}

		case SQLiteParserK_INNER:
			{
				p.SetState(1508)
				p.Match(SQLiteParserK_INNER)
			}

		case SQLiteParserK_CROSS:
			{
				p.SetState(1509)
				p.Match(SQLiteParserK_CROSS)
			}

		case SQLiteParserK_JOIN:

		default:
		}
		{
			p.SetState(1512)
			p.Match(SQLiteParserK_JOIN)
		}

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

	return localctx
}

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

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

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

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

func NewEmptyJoin_constraintContext() *Join_constraintContext {
	var p = new(Join_constraintContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_ON() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ON, 0)
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Join_constraintContext) K_USING() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_USING, 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.(SQLiteListener); ok {
		listenerT.EnterJoin_constraint(s)
	}
}

func (s *Join_constraintContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitJoin_constraint(s)
	}
}

func (p *SQLiteParser) Join_constraint() (localctx IJoin_constraintContext) {
	localctx = NewJoin_constraintContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 104, 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.EnterOuterAlt(localctx, 1)
	p.SetState(1529)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserK_ON:
		{
			p.SetState(1515)
			p.Match(SQLiteParserK_ON)
		}
		{
			p.SetState(1516)
			p.expr(0)
		}

	case SQLiteParserK_USING:
		{
			p.SetState(1517)
			p.Match(SQLiteParserK_USING)
		}
		{
			p.SetState(1518)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1519)
			p.Column_name()
		}
		p.SetState(1524)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1520)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1521)
				p.Column_name()
			}

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

	case SQLiteParserEOF, SQLiteParserSCOL, SQLiteParserCLOSE_PAR, SQLiteParserCOMMA, SQLiteParserK_ALTER, SQLiteParserK_ANALYZE, SQLiteParserK_ATTACH, SQLiteParserK_BEGIN, SQLiteParserK_COMMIT, SQLiteParserK_CREATE, SQLiteParserK_CROSS, SQLiteParserK_DELETE, SQLiteParserK_DETACH, SQLiteParserK_DROP, SQLiteParserK_END, SQLiteParserK_EXCEPT, SQLiteParserK_EXPLAIN, SQLiteParserK_GROUP, SQLiteParserK_INNER, SQLiteParserK_INSERT, SQLiteParserK_INTERSECT, SQLiteParserK_JOIN, SQLiteParserK_LEFT, SQLiteParserK_LIMIT, SQLiteParserK_NATURAL, SQLiteParserK_ORDER, SQLiteParserK_PRAGMA, SQLiteParserK_REINDEX, SQLiteParserK_RELEASE, SQLiteParserK_REPLACE, SQLiteParserK_ROLLBACK, SQLiteParserK_SAVEPOINT, SQLiteParserK_SELECT, SQLiteParserK_UNION, SQLiteParserK_UPDATE, SQLiteParserK_VACUUM, SQLiteParserK_VALUES, SQLiteParserK_WHERE, SQLiteParserK_WITH:

	default:
	}

	return localctx
}

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

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

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

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

func NewEmptySelect_coreContext() *Select_coreContext {
	var p = new(Select_coreContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_SELECT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_SELECT, 0)
}

func (s *Select_coreContext) AllResult_column() []IResult_columnContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IResult_columnContext)(nil)).Elem())
	var tst = make([]IResult_columnContext, len(ts))

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

	return tst
}

func (s *Select_coreContext) Result_column(i int) IResult_columnContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IResult_columnContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(IResult_columnContext)
}

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

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

func (s *Select_coreContext) K_FROM() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_FROM, 0)
}

func (s *Select_coreContext) K_WHERE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_WHERE, 0)
}

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

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

	return tst
}

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

	if t == nil {
		return nil
	}

	return t.(IExprContext)
}

func (s *Select_coreContext) K_GROUP() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_GROUP, 0)
}

func (s *Select_coreContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_BY, 0)
}

func (s *Select_coreContext) K_DISTINCT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DISTINCT, 0)
}

func (s *Select_coreContext) K_ALL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ALL, 0)
}

func (s *Select_coreContext) AllTable_or_subquery() []ITable_or_subqueryContext {
	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITable_or_subqueryContext)(nil)).Elem())
	var tst = make([]ITable_or_subqueryContext, len(ts))

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

	return tst
}

func (s *Select_coreContext) Table_or_subquery(i int) ITable_or_subqueryContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITable_or_subqueryContext)(nil)).Elem(), i)

	if t == nil {
		return nil
	}

	return t.(ITable_or_subqueryContext)
}

func (s *Select_coreContext) Join_clause() IJoin_clauseContext {
	var t = s.GetTypedRuleContext(reflect.TypeOf((*IJoin_clauseContext)(nil)).Elem(), 0)

	if t == nil {
		return nil
	}

	return t.(IJoin_clauseContext)
}

func (s *Select_coreContext) K_HAVING() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_HAVING, 0)
}

func (s *Select_coreContext) K_VALUES() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_VALUES, 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.(SQLiteListener); ok {
		listenerT.EnterSelect_core(s)
	}
}

func (s *Select_coreContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitSelect_core(s)
	}
}

func (p *SQLiteParser) Select_core() (localctx ISelect_coreContext) {
	localctx = NewSelect_coreContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 106, 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(1605)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserK_SELECT:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1531)
			p.Match(SQLiteParserK_SELECT)
		}
		p.SetState(1533)
		p.GetErrorHandler().Sync(p)

		if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 219, p.GetParserRuleContext()) == 1 {
			{
				p.SetState(1532)
				_la = p.GetTokenStream().LA(1)

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

		}
		{
			p.SetState(1535)
			p.Result_column()
		}
		p.SetState(1540)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1536)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1537)
				p.Result_column()
			}

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

		if _la == SQLiteParserK_FROM {
			{
				p.SetState(1543)
				p.Match(SQLiteParserK_FROM)
			}
			p.SetState(1553)
			p.GetErrorHandler().Sync(p)
			switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 222, p.GetParserRuleContext()) {
			case 1:
				{
					p.SetState(1544)
					p.Table_or_subquery()
				}
				p.SetState(1549)
				p.GetErrorHandler().Sync(p)
				_la = p.GetTokenStream().LA(1)

				for _la == SQLiteParserCOMMA {
					{
						p.SetState(1545)
						p.Match(SQLiteParserCOMMA)
					}
					{
						p.SetState(1546)
						p.Table_or_subquery()
					}

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

			case 2:
				{
					p.SetState(1552)
					p.Join_clause()
				}

			}

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

		if _la == SQLiteParserK_WHERE {
			{
				p.SetState(1557)
				p.Match(SQLiteParserK_WHERE)
			}
			{
				p.SetState(1558)
				p.expr(0)
			}

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

		if _la == SQLiteParserK_GROUP {
			{
				p.SetState(1561)
				p.Match(SQLiteParserK_GROUP)
			}
			{
				p.SetState(1562)
				p.Match(SQLiteParserK_BY)
			}
			{
				p.SetState(1563)
				p.expr(0)
			}
			p.SetState(1568)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(1564)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(1565)
					p.expr(0)
				}

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

			if _la == SQLiteParserK_HAVING {
				{
					p.SetState(1571)
					p.Match(SQLiteParserK_HAVING)
				}
				{
					p.SetState(1572)
					p.expr(0)
				}

			}

		}

	case SQLiteParserK_VALUES:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1577)
			p.Match(SQLiteParserK_VALUES)
		}
		{
			p.SetState(1578)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1579)
			p.expr(0)
		}
		p.SetState(1584)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1580)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1581)
				p.expr(0)
			}

			p.SetState(1586)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)
		}
		{
			p.SetState(1587)
			p.Match(SQLiteParserCLOSE_PAR)
		}
		p.SetState(1602)
		p.GetErrorHandler().Sync(p)
		_la = p.GetTokenStream().LA(1)

		for _la == SQLiteParserCOMMA {
			{
				p.SetState(1588)
				p.Match(SQLiteParserCOMMA)
			}
			{
				p.SetState(1589)
				p.Match(SQLiteParserOPEN_PAR)
			}
			{
				p.SetState(1590)
				p.expr(0)
			}
			p.SetState(1595)
			p.GetErrorHandler().Sync(p)
			_la = p.GetTokenStream().LA(1)

			for _la == SQLiteParserCOMMA {
				{
					p.SetState(1591)
					p.Match(SQLiteParserCOMMA)
				}
				{
					p.SetState(1592)
					p.expr(0)
				}

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

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

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

	return localctx
}

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

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

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

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

func NewEmptyCompound_operatorContext() *Compound_operatorContext {
	var p = new(Compound_operatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_UNION() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_UNION, 0)
}

func (s *Compound_operatorContext) K_ALL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ALL, 0)
}

func (s *Compound_operatorContext) K_INTERSECT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INTERSECT, 0)
}

func (s *Compound_operatorContext) K_EXCEPT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_EXCEPT, 0)
}

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

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

func (s *Compound_operatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterCompound_operator(s)
	}
}

func (s *Compound_operatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitCompound_operator(s)
	}
}

func (p *SQLiteParser) Compound_operator() (localctx ICompound_operatorContext) {
	localctx = NewCompound_operatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 108, SQLiteParserRULE_compound_operator)

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

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

	p.SetState(1612)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 232, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1607)
			p.Match(SQLiteParserK_UNION)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1608)
			p.Match(SQLiteParserK_UNION)
		}
		{
			p.SetState(1609)
			p.Match(SQLiteParserK_ALL)
		}

	case 3:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1610)
			p.Match(SQLiteParserK_INTERSECT)
		}

	case 4:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1611)
			p.Match(SQLiteParserK_EXCEPT)
		}

	}

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

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

func (p *SQLiteParser) Signed_number() (localctx ISigned_numberContext) {
	localctx = NewSigned_numberContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 110, 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(1615)
	p.GetErrorHandler().Sync(p)
	_la = p.GetTokenStream().LA(1)

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

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

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

	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) K_NULL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NULL, 0)
}

func (s *Literal_valueContext) K_CURRENT_TIME() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CURRENT_TIME, 0)
}

func (s *Literal_valueContext) K_CURRENT_DATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CURRENT_DATE, 0)
}

func (s *Literal_valueContext) K_CURRENT_TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CURRENT_TIMESTAMP, 0)
}

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

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

func (s *Literal_valueContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterLiteral_value(s)
	}
}

func (s *Literal_valueContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitLiteral_value(s)
	}
}

func (p *SQLiteParser) Literal_value() (localctx ILiteral_valueContext) {
	localctx = NewLiteral_valueContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 112, 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(1619)
		_la = p.GetTokenStream().LA(1)

		if !((((_la-52)&-(0x1f+1)) == 0 && ((1<<uint((_la-52)))&((1<<(SQLiteParserK_CURRENT_DATE-52))|(1<<(SQLiteParserK_CURRENT_TIME-52))|(1<<(SQLiteParserK_CURRENT_TIMESTAMP-52)))) != 0) || _la == SQLiteParserK_NULL || (((_la-150)&-(0x1f+1)) == 0 && ((1<<uint((_la-150)))&((1<<(SQLiteParserNUMERIC_LITERAL-150))|(1<<(SQLiteParserSTRING_LITERAL-150))|(1<<(SQLiteParserBLOB_LITERAL-150)))) != 0)) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

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

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

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

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

func NewEmptyUnary_operatorContext() *Unary_operatorContext {
	var p = new(Unary_operatorContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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) K_NOT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NOT, 0)
}

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

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

func (s *Unary_operatorContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterUnary_operator(s)
	}
}

func (s *Unary_operatorContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitUnary_operator(s)
	}
}

func (p *SQLiteParser) Unary_operator() (localctx IUnary_operatorContext) {
	localctx = NewUnary_operatorContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 114, 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(1621)
		_la = p.GetTokenStream().LA(1)

		if !((((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<SQLiteParserPLUS)|(1<<SQLiteParserMINUS)|(1<<SQLiteParserTILDE))) != 0) || _la == SQLiteParserK_NOT) {
			p.GetErrorHandler().RecoverInline(p)
		} else {
			p.GetErrorHandler().ReportMatch(p)
			p.Consume()
		}
	}

	return localctx
}

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

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

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

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

func NewEmptyError_messageContext() *Error_messageContext {
	var p = new(Error_messageContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = 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.(SQLiteListener); ok {
		listenerT.EnterError_message(s)
	}
}

func (s *Error_messageContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitError_message(s)
	}
}

func (p *SQLiteParser) Error_message() (localctx IError_messageContext) {
	localctx = NewError_messageContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 116, 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(1623)
		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.(SQLiteListener); ok {
		listenerT.EnterModule_argument(s)
	}
}

func (s *Module_argumentContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitModule_argument(s)
	}
}

func (p *SQLiteParser) Module_argument() (localctx IModule_argumentContext) {
	localctx = NewModule_argumentContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 118, 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(1627)
	p.GetErrorHandler().Sync(p)
	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 234, p.GetParserRuleContext()) {
	case 1:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1625)
			p.expr(0)
		}

	case 2:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1626)
			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.(SQLiteListener); ok {
		listenerT.EnterColumn_alias(s)
	}
}

func (s *Column_aliasContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitColumn_alias(s)
	}
}

func (p *SQLiteParser) Column_alias() (localctx IColumn_aliasContext) {
	localctx = NewColumn_aliasContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 120, 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(1629)
		_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) K_ABORT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ABORT, 0)
}

func (s *KeywordContext) K_ACTION() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ACTION, 0)
}

func (s *KeywordContext) K_ADD() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ADD, 0)
}

func (s *KeywordContext) K_AFTER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_AFTER, 0)
}

func (s *KeywordContext) K_ALL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ALL, 0)
}

func (s *KeywordContext) K_ALTER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ALTER, 0)
}

func (s *KeywordContext) K_ANALYZE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ANALYZE, 0)
}

func (s *KeywordContext) K_AND() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_AND, 0)
}

func (s *KeywordContext) K_AS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_AS, 0)
}

func (s *KeywordContext) K_ASC() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ASC, 0)
}

func (s *KeywordContext) K_ATTACH() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ATTACH, 0)
}

func (s *KeywordContext) K_AUTOINCREMENT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_AUTOINCREMENT, 0)
}

func (s *KeywordContext) K_BEFORE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_BEFORE, 0)
}

func (s *KeywordContext) K_BEGIN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_BEGIN, 0)
}

func (s *KeywordContext) K_BETWEEN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_BETWEEN, 0)
}

func (s *KeywordContext) K_BY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_BY, 0)
}

func (s *KeywordContext) K_CASCADE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CASCADE, 0)
}

func (s *KeywordContext) K_CASE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CASE, 0)
}

func (s *KeywordContext) K_CAST() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CAST, 0)
}

func (s *KeywordContext) K_CHECK() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CHECK, 0)
}

func (s *KeywordContext) K_COLLATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_COLLATE, 0)
}

func (s *KeywordContext) K_COLUMN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_COLUMN, 0)
}

func (s *KeywordContext) K_COMMIT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_COMMIT, 0)
}

func (s *KeywordContext) K_CONFLICT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CONFLICT, 0)
}

func (s *KeywordContext) K_CONSTRAINT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CONSTRAINT, 0)
}

func (s *KeywordContext) K_CREATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CREATE, 0)
}

func (s *KeywordContext) K_CROSS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CROSS, 0)
}

func (s *KeywordContext) K_CURRENT_DATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CURRENT_DATE, 0)
}

func (s *KeywordContext) K_CURRENT_TIME() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CURRENT_TIME, 0)
}

func (s *KeywordContext) K_CURRENT_TIMESTAMP() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_CURRENT_TIMESTAMP, 0)
}

func (s *KeywordContext) K_DATABASE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DATABASE, 0)
}

func (s *KeywordContext) K_DEFAULT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DEFAULT, 0)
}

func (s *KeywordContext) K_DEFERRABLE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DEFERRABLE, 0)
}

func (s *KeywordContext) K_DEFERRED() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DEFERRED, 0)
}

func (s *KeywordContext) K_DELETE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DELETE, 0)
}

func (s *KeywordContext) K_DESC() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DESC, 0)
}

func (s *KeywordContext) K_DETACH() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DETACH, 0)
}

func (s *KeywordContext) K_DISTINCT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DISTINCT, 0)
}

func (s *KeywordContext) K_DROP() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_DROP, 0)
}

func (s *KeywordContext) K_EACH() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_EACH, 0)
}

func (s *KeywordContext) K_ELSE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ELSE, 0)
}

func (s *KeywordContext) K_END() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_END, 0)
}

func (s *KeywordContext) K_ESCAPE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ESCAPE, 0)
}

func (s *KeywordContext) K_EXCEPT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_EXCEPT, 0)
}

func (s *KeywordContext) K_EXCLUSIVE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_EXCLUSIVE, 0)
}

func (s *KeywordContext) K_EXISTS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_EXISTS, 0)
}

func (s *KeywordContext) K_EXPLAIN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_EXPLAIN, 0)
}

func (s *KeywordContext) K_FAIL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_FAIL, 0)
}

func (s *KeywordContext) K_FOR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_FOR, 0)
}

func (s *KeywordContext) K_FOREIGN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_FOREIGN, 0)
}

func (s *KeywordContext) K_FROM() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_FROM, 0)
}

func (s *KeywordContext) K_FULL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_FULL, 0)
}

func (s *KeywordContext) K_GLOB() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_GLOB, 0)
}

func (s *KeywordContext) K_GROUP() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_GROUP, 0)
}

func (s *KeywordContext) K_HAVING() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_HAVING, 0)
}

func (s *KeywordContext) K_IF() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IF, 0)
}

func (s *KeywordContext) K_IGNORE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IGNORE, 0)
}

func (s *KeywordContext) K_IMMEDIATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IMMEDIATE, 0)
}

func (s *KeywordContext) K_IN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IN, 0)
}

func (s *KeywordContext) K_INDEX() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INDEX, 0)
}

func (s *KeywordContext) K_INDEXED() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INDEXED, 0)
}

func (s *KeywordContext) K_INITIALLY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INITIALLY, 0)
}

func (s *KeywordContext) K_INNER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INNER, 0)
}

func (s *KeywordContext) K_INSERT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INSERT, 0)
}

func (s *KeywordContext) K_INSTEAD() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INSTEAD, 0)
}

func (s *KeywordContext) K_INTERSECT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INTERSECT, 0)
}

func (s *KeywordContext) K_INTO() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_INTO, 0)
}

func (s *KeywordContext) K_IS() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_IS, 0)
}

func (s *KeywordContext) K_ISNULL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ISNULL, 0)
}

func (s *KeywordContext) K_JOIN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_JOIN, 0)
}

func (s *KeywordContext) K_KEY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_KEY, 0)
}

func (s *KeywordContext) K_LEFT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_LEFT, 0)
}

func (s *KeywordContext) K_LIKE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_LIKE, 0)
}

func (s *KeywordContext) K_LIMIT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_LIMIT, 0)
}

func (s *KeywordContext) K_MATCH() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_MATCH, 0)
}

func (s *KeywordContext) K_NATURAL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NATURAL, 0)
}

func (s *KeywordContext) K_NO() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NO, 0)
}

func (s *KeywordContext) K_NOT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NOT, 0)
}

func (s *KeywordContext) K_NOTNULL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NOTNULL, 0)
}

func (s *KeywordContext) K_NULL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_NULL, 0)
}

func (s *KeywordContext) K_OF() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_OF, 0)
}

func (s *KeywordContext) K_OFFSET() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_OFFSET, 0)
}

func (s *KeywordContext) K_ON() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ON, 0)
}

func (s *KeywordContext) K_OR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_OR, 0)
}

func (s *KeywordContext) K_ORDER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ORDER, 0)
}

func (s *KeywordContext) K_OUTER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_OUTER, 0)
}

func (s *KeywordContext) K_PLAN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_PLAN, 0)
}

func (s *KeywordContext) K_PRAGMA() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_PRAGMA, 0)
}

func (s *KeywordContext) K_PRIMARY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_PRIMARY, 0)
}

func (s *KeywordContext) K_QUERY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_QUERY, 0)
}

func (s *KeywordContext) K_RAISE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_RAISE, 0)
}

func (s *KeywordContext) K_RECURSIVE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_RECURSIVE, 0)
}

func (s *KeywordContext) K_REFERENCES() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_REFERENCES, 0)
}

func (s *KeywordContext) K_REGEXP() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_REGEXP, 0)
}

func (s *KeywordContext) K_REINDEX() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_REINDEX, 0)
}

func (s *KeywordContext) K_RELEASE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_RELEASE, 0)
}

func (s *KeywordContext) K_RENAME() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_RENAME, 0)
}

func (s *KeywordContext) K_REPLACE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_REPLACE, 0)
}

func (s *KeywordContext) K_RESTRICT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_RESTRICT, 0)
}

func (s *KeywordContext) K_RIGHT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_RIGHT, 0)
}

func (s *KeywordContext) K_ROLLBACK() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ROLLBACK, 0)
}

func (s *KeywordContext) K_ROW() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_ROW, 0)
}

func (s *KeywordContext) K_SAVEPOINT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_SAVEPOINT, 0)
}

func (s *KeywordContext) K_SELECT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_SELECT, 0)
}

func (s *KeywordContext) K_SET() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_SET, 0)
}

func (s *KeywordContext) K_TABLE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_TABLE, 0)
}

func (s *KeywordContext) K_TEMP() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_TEMP, 0)
}

func (s *KeywordContext) K_TEMPORARY() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_TEMPORARY, 0)
}

func (s *KeywordContext) K_THEN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_THEN, 0)
}

func (s *KeywordContext) K_TO() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_TO, 0)
}

func (s *KeywordContext) K_TRANSACTION() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_TRANSACTION, 0)
}

func (s *KeywordContext) K_TRIGGER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_TRIGGER, 0)
}

func (s *KeywordContext) K_UNION() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_UNION, 0)
}

func (s *KeywordContext) K_UNIQUE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_UNIQUE, 0)
}

func (s *KeywordContext) K_UPDATE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_UPDATE, 0)
}

func (s *KeywordContext) K_USING() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_USING, 0)
}

func (s *KeywordContext) K_VACUUM() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_VACUUM, 0)
}

func (s *KeywordContext) K_VALUES() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_VALUES, 0)
}

func (s *KeywordContext) K_VIEW() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_VIEW, 0)
}

func (s *KeywordContext) K_VIRTUAL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_VIRTUAL, 0)
}

func (s *KeywordContext) K_WHEN() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_WHEN, 0)
}

func (s *KeywordContext) K_WHERE() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_WHERE, 0)
}

func (s *KeywordContext) K_WITH() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_WITH, 0)
}

func (s *KeywordContext) K_WITHOUT() antlr.TerminalNode {
	return s.GetToken(SQLiteParserK_WITHOUT, 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.(SQLiteListener); ok {
		listenerT.EnterKeyword(s)
	}
}

func (s *KeywordContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitKeyword(s)
	}
}

func (p *SQLiteParser) Keyword() (localctx IKeywordContext) {
	localctx = NewKeywordContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 122, 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(1631)
		_la = p.GetTokenStream().LA(1)

		if !((((_la-25)&-(0x1f+1)) == 0 && ((1<<uint((_la-25)))&((1<<(SQLiteParserK_ABORT-25))|(1<<(SQLiteParserK_ACTION-25))|(1<<(SQLiteParserK_ADD-25))|(1<<(SQLiteParserK_AFTER-25))|(1<<(SQLiteParserK_ALL-25))|(1<<(SQLiteParserK_ALTER-25))|(1<<(SQLiteParserK_ANALYZE-25))|(1<<(SQLiteParserK_AND-25))|(1<<(SQLiteParserK_AS-25))|(1<<(SQLiteParserK_ASC-25))|(1<<(SQLiteParserK_ATTACH-25))|(1<<(SQLiteParserK_AUTOINCREMENT-25))|(1<<(SQLiteParserK_BEFORE-25))|(1<<(SQLiteParserK_BEGIN-25))|(1<<(SQLiteParserK_BETWEEN-25))|(1<<(SQLiteParserK_BY-25))|(1<<(SQLiteParserK_CASCADE-25))|(1<<(SQLiteParserK_CASE-25))|(1<<(SQLiteParserK_CAST-25))|(1<<(SQLiteParserK_CHECK-25))|(1<<(SQLiteParserK_COLLATE-25))|(1<<(SQLiteParserK_COLUMN-25))|(1<<(SQLiteParserK_COMMIT-25))|(1<<(SQLiteParserK_CONFLICT-25))|(1<<(SQLiteParserK_CONSTRAINT-25))|(1<<(SQLiteParserK_CREATE-25))|(1<<(SQLiteParserK_CROSS-25))|(1<<(SQLiteParserK_CURRENT_DATE-25))|(1<<(SQLiteParserK_CURRENT_TIME-25))|(1<<(SQLiteParserK_CURRENT_TIMESTAMP-25))|(1<<(SQLiteParserK_DATABASE-25))|(1<<(SQLiteParserK_DEFAULT-25)))) != 0) || (((_la-57)&-(0x1f+1)) == 0 && ((1<<uint((_la-57)))&((1<<(SQLiteParserK_DEFERRABLE-57))|(1<<(SQLiteParserK_DEFERRED-57))|(1<<(SQLiteParserK_DELETE-57))|(1<<(SQLiteParserK_DESC-57))|(1<<(SQLiteParserK_DETACH-57))|(1<<(SQLiteParserK_DISTINCT-57))|(1<<(SQLiteParserK_DROP-57))|(1<<(SQLiteParserK_EACH-57))|(1<<(SQLiteParserK_ELSE-57))|(1<<(SQLiteParserK_END-57))|(1<<(SQLiteParserK_ESCAPE-57))|(1<<(SQLiteParserK_EXCEPT-57))|(1<<(SQLiteParserK_EXCLUSIVE-57))|(1<<(SQLiteParserK_EXISTS-57))|(1<<(SQLiteParserK_EXPLAIN-57))|(1<<(SQLiteParserK_FAIL-57))|(1<<(SQLiteParserK_FOR-57))|(1<<(SQLiteParserK_FOREIGN-57))|(1<<(SQLiteParserK_FROM-57))|(1<<(SQLiteParserK_FULL-57))|(1<<(SQLiteParserK_GLOB-57))|(1<<(SQLiteParserK_GROUP-57))|(1<<(SQLiteParserK_HAVING-57))|(1<<(SQLiteParserK_IF-57))|(1<<(SQLiteParserK_IGNORE-57))|(1<<(SQLiteParserK_IMMEDIATE-57))|(1<<(SQLiteParserK_IN-57))|(1<<(SQLiteParserK_INDEX-57))|(1<<(SQLiteParserK_INDEXED-57))|(1<<(SQLiteParserK_INITIALLY-57))|(1<<(SQLiteParserK_INNER-57))|(1<<(SQLiteParserK_INSERT-57)))) != 0) || (((_la-89)&-(0x1f+1)) == 0 && ((1<<uint((_la-89)))&((1<<(SQLiteParserK_INSTEAD-89))|(1<<(SQLiteParserK_INTERSECT-89))|(1<<(SQLiteParserK_INTO-89))|(1<<(SQLiteParserK_IS-89))|(1<<(SQLiteParserK_ISNULL-89))|(1<<(SQLiteParserK_JOIN-89))|(1<<(SQLiteParserK_KEY-89))|(1<<(SQLiteParserK_LEFT-89))|(1<<(SQLiteParserK_LIKE-89))|(1<<(SQLiteParserK_LIMIT-89))|(1<<(SQLiteParserK_MATCH-89))|(1<<(SQLiteParserK_NATURAL-89))|(1<<(SQLiteParserK_NO-89))|(1<<(SQLiteParserK_NOT-89))|(1<<(SQLiteParserK_NOTNULL-89))|(1<<(SQLiteParserK_NULL-89))|(1<<(SQLiteParserK_OF-89))|(1<<(SQLiteParserK_OFFSET-89))|(1<<(SQLiteParserK_ON-89))|(1<<(SQLiteParserK_OR-89))|(1<<(SQLiteParserK_ORDER-89))|(1<<(SQLiteParserK_OUTER-89))|(1<<(SQLiteParserK_PLAN-89))|(1<<(SQLiteParserK_PRAGMA-89))|(1<<(SQLiteParserK_PRIMARY-89))|(1<<(SQLiteParserK_QUERY-89))|(1<<(SQLiteParserK_RAISE-89))|(1<<(SQLiteParserK_RECURSIVE-89))|(1<<(SQLiteParserK_REFERENCES-89))|(1<<(SQLiteParserK_REGEXP-89))|(1<<(SQLiteParserK_REINDEX-89))|(1<<(SQLiteParserK_RELEASE-89)))) != 0) || (((_la-121)&-(0x1f+1)) == 0 && ((1<<uint((_la-121)))&((1<<(SQLiteParserK_RENAME-121))|(1<<(SQLiteParserK_REPLACE-121))|(1<<(SQLiteParserK_RESTRICT-121))|(1<<(SQLiteParserK_RIGHT-121))|(1<<(SQLiteParserK_ROLLBACK-121))|(1<<(SQLiteParserK_ROW-121))|(1<<(SQLiteParserK_SAVEPOINT-121))|(1<<(SQLiteParserK_SELECT-121))|(1<<(SQLiteParserK_SET-121))|(1<<(SQLiteParserK_TABLE-121))|(1<<(SQLiteParserK_TEMP-121))|(1<<(SQLiteParserK_TEMPORARY-121))|(1<<(SQLiteParserK_THEN-121))|(1<<(SQLiteParserK_TO-121))|(1<<(SQLiteParserK_TRANSACTION-121))|(1<<(SQLiteParserK_TRIGGER-121))|(1<<(SQLiteParserK_UNION-121))|(1<<(SQLiteParserK_UNIQUE-121))|(1<<(SQLiteParserK_UPDATE-121))|(1<<(SQLiteParserK_USING-121))|(1<<(SQLiteParserK_VACUUM-121))|(1<<(SQLiteParserK_VALUES-121))|(1<<(SQLiteParserK_VIEW-121))|(1<<(SQLiteParserK_VIRTUAL-121))|(1<<(SQLiteParserK_WHEN-121))|(1<<(SQLiteParserK_WHERE-121))|(1<<(SQLiteParserK_WITH-121))|(1<<(SQLiteParserK_WITHOUT-121)))) != 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.(SQLiteListener); ok {
		listenerT.EnterName(s)
	}
}

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

func (p *SQLiteParser) Name() (localctx INameContext) {
	localctx = NewNameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 124, 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(1633)
		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.(SQLiteListener); ok {
		listenerT.EnterFunction_name(s)
	}
}

func (s *Function_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitFunction_name(s)
	}
}

func (p *SQLiteParser) Function_name() (localctx IFunction_nameContext) {
	localctx = NewFunction_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 126, 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(1635)
		p.Any_name()
	}

	return localctx
}

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

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

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

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

func NewEmptyDatabase_nameContext() *Database_nameContext {
	var p = new(Database_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_database_name
	return p
}

func (*Database_nameContext) IsDatabase_nameContext() {}

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

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

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_database_name

	return p
}

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

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

	if t == nil {
		return nil
	}

	return t.(IAny_nameContext)
}

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

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

func (s *Database_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterDatabase_name(s)
	}
}

func (s *Database_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitDatabase_name(s)
	}
}

func (p *SQLiteParser) Database_name() (localctx IDatabase_nameContext) {
	localctx = NewDatabase_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 128, SQLiteParserRULE_database_name)

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

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

	p.EnterOuterAlt(localctx, 1)
	{
		p.SetState(1637)
		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.(SQLiteListener); ok {
		listenerT.EnterSchema_name(s)
	}
}

func (s *Schema_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitSchema_name(s)
	}
}

func (p *SQLiteParser) Schema_name() (localctx ISchema_nameContext) {
	localctx = NewSchema_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 130, 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(1639)
		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.(SQLiteListener); ok {
		listenerT.EnterTable_function_name(s)
	}
}

func (s *Table_function_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitTable_function_name(s)
	}
}

func (p *SQLiteParser) Table_function_name() (localctx ITable_function_nameContext) {
	localctx = NewTable_function_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 132, 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(1641)
		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.(SQLiteListener); ok {
		listenerT.EnterTable_name(s)
	}
}

func (s *Table_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitTable_name(s)
	}
}

func (p *SQLiteParser) Table_name() (localctx ITable_nameContext) {
	localctx = NewTable_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 134, 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(1643)
		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.(SQLiteListener); ok {
		listenerT.EnterTable_or_index_name(s)
	}
}

func (s *Table_or_index_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitTable_or_index_name(s)
	}
}

func (p *SQLiteParser) Table_or_index_name() (localctx ITable_or_index_nameContext) {
	localctx = NewTable_or_index_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 136, 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(1645)
		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.(SQLiteListener); ok {
		listenerT.EnterNew_table_name(s)
	}
}

func (s *New_table_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitNew_table_name(s)
	}
}

func (p *SQLiteParser) New_table_name() (localctx INew_table_nameContext) {
	localctx = NewNew_table_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 138, 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(1647)
		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.(SQLiteListener); ok {
		listenerT.EnterColumn_name(s)
	}
}

func (s *Column_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitColumn_name(s)
	}
}

func (p *SQLiteParser) Column_name() (localctx IColumn_nameContext) {
	localctx = NewColumn_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 140, 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(1649)
		p.Any_name()
	}

	return localctx
}

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

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

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

type New_column_nameContext struct {
	*antlr.BaseParserRuleContext
	parser antlr.Parser
}

func NewEmptyNew_column_nameContext() *New_column_nameContext {
	var p = new(New_column_nameContext)
	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
	p.RuleIndex = SQLiteParserRULE_new_column_name
	return p
}

func (*New_column_nameContext) IsNew_column_nameContext() {}

func NewNew_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_column_nameContext {
	var p = new(New_column_nameContext)

	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)

	p.parser = parser
	p.RuleIndex = SQLiteParserRULE_new_column_name

	return p
}

func (s *New_column_nameContext) GetParser() antlr.Parser { return s.parser }

func (s *New_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 *New_column_nameContext) GetRuleContext() antlr.RuleContext {
	return s
}

func (s *New_column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
	return antlr.TreesStringTree(s, ruleNames, recog)
}

func (s *New_column_nameContext) EnterRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.EnterNew_column_name(s)
	}
}

func (s *New_column_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitNew_column_name(s)
	}
}

func (p *SQLiteParser) New_column_name() (localctx INew_column_nameContext) {
	localctx = NewNew_column_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 142, SQLiteParserRULE_new_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(1651)
		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.(SQLiteListener); ok {
		listenerT.EnterCollation_name(s)
	}
}

func (s *Collation_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitCollation_name(s)
	}
}

func (p *SQLiteParser) Collation_name() (localctx ICollation_nameContext) {
	localctx = NewCollation_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 144, 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(1653)
		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.(SQLiteListener); ok {
		listenerT.EnterForeign_table(s)
	}
}

func (s *Foreign_tableContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitForeign_table(s)
	}
}

func (p *SQLiteParser) Foreign_table() (localctx IForeign_tableContext) {
	localctx = NewForeign_tableContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 146, 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(1655)
		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.(SQLiteListener); ok {
		listenerT.EnterIndex_name(s)
	}
}

func (s *Index_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitIndex_name(s)
	}
}

func (p *SQLiteParser) Index_name() (localctx IIndex_nameContext) {
	localctx = NewIndex_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 148, 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(1657)
		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.(SQLiteListener); ok {
		listenerT.EnterTrigger_name(s)
	}
}

func (s *Trigger_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitTrigger_name(s)
	}
}

func (p *SQLiteParser) Trigger_name() (localctx ITrigger_nameContext) {
	localctx = NewTrigger_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 150, 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(1659)
		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.(SQLiteListener); ok {
		listenerT.EnterView_name(s)
	}
}

func (s *View_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitView_name(s)
	}
}

func (p *SQLiteParser) View_name() (localctx IView_nameContext) {
	localctx = NewView_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 152, 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(1661)
		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.(SQLiteListener); ok {
		listenerT.EnterModule_name(s)
	}
}

func (s *Module_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitModule_name(s)
	}
}

func (p *SQLiteParser) Module_name() (localctx IModule_nameContext) {
	localctx = NewModule_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 154, 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(1663)
		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.(SQLiteListener); ok {
		listenerT.EnterPragma_name(s)
	}
}

func (s *Pragma_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitPragma_name(s)
	}
}

func (p *SQLiteParser) Pragma_name() (localctx IPragma_nameContext) {
	localctx = NewPragma_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 156, 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(1665)
		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.(SQLiteListener); ok {
		listenerT.EnterSavepoint_name(s)
	}
}

func (s *Savepoint_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitSavepoint_name(s)
	}
}

func (p *SQLiteParser) Savepoint_name() (localctx ISavepoint_nameContext) {
	localctx = NewSavepoint_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 158, 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(1667)
		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) IDENTIFIER() antlr.TerminalNode {
	return s.GetToken(SQLiteParserIDENTIFIER, 0)
}

func (s *Table_aliasContext) STRING_LITERAL() antlr.TerminalNode {
	return s.GetToken(SQLiteParserSTRING_LITERAL, 0)
}

func (s *Table_aliasContext) OPEN_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserOPEN_PAR, 0)
}

func (s *Table_aliasContext) 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_aliasContext) CLOSE_PAR() antlr.TerminalNode {
	return s.GetToken(SQLiteParserCLOSE_PAR, 0)
}

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.(SQLiteListener); ok {
		listenerT.EnterTable_alias(s)
	}
}

func (s *Table_aliasContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitTable_alias(s)
	}
}

func (p *SQLiteParser) Table_alias() (localctx ITable_aliasContext) {
	localctx = NewTable_aliasContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 160, 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.SetState(1675)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1669)
			p.Match(SQLiteParserIDENTIFIER)
		}

	case SQLiteParserSTRING_LITERAL:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1670)
			p.Match(SQLiteParserSTRING_LITERAL)
		}

	case SQLiteParserOPEN_PAR:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1671)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1672)
			p.Table_alias()
		}
		{
			p.SetState(1673)
			p.Match(SQLiteParserCLOSE_PAR)
		}

	default:
		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
	}

	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.(SQLiteListener); ok {
		listenerT.EnterTransaction_name(s)
	}
}

func (s *Transaction_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitTransaction_name(s)
	}
}

func (p *SQLiteParser) Transaction_name() (localctx ITransaction_nameContext) {
	localctx = NewTransaction_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 162, 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(1677)
		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.(SQLiteListener); ok {
		listenerT.EnterAny_name(s)
	}
}

func (s *Any_nameContext) ExitRule(listener antlr.ParseTreeListener) {
	if listenerT, ok := listener.(SQLiteListener); ok {
		listenerT.ExitAny_name(s)
	}
}

func (p *SQLiteParser) Any_name() (localctx IAny_nameContext) {
	localctx = NewAny_nameContext(p, p.GetParserRuleContext(), p.GetState())
	p.EnterRule(localctx, 164, 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(1686)
	p.GetErrorHandler().Sync(p)

	switch p.GetTokenStream().LA(1) {
	case SQLiteParserIDENTIFIER:
		p.EnterOuterAlt(localctx, 1)
		{
			p.SetState(1679)
			p.Match(SQLiteParserIDENTIFIER)
		}

	case SQLiteParserK_ABORT, SQLiteParserK_ACTION, SQLiteParserK_ADD, SQLiteParserK_AFTER, SQLiteParserK_ALL, SQLiteParserK_ALTER, SQLiteParserK_ANALYZE, SQLiteParserK_AND, SQLiteParserK_AS, SQLiteParserK_ASC, SQLiteParserK_ATTACH, SQLiteParserK_AUTOINCREMENT, SQLiteParserK_BEFORE, SQLiteParserK_BEGIN, SQLiteParserK_BETWEEN, SQLiteParserK_BY, SQLiteParserK_CASCADE, SQLiteParserK_CASE, SQLiteParserK_CAST, SQLiteParserK_CHECK, SQLiteParserK_COLLATE, SQLiteParserK_COLUMN, SQLiteParserK_COMMIT, SQLiteParserK_CONFLICT, SQLiteParserK_CONSTRAINT, SQLiteParserK_CREATE, SQLiteParserK_CROSS, SQLiteParserK_CURRENT_DATE, SQLiteParserK_CURRENT_TIME, SQLiteParserK_CURRENT_TIMESTAMP, SQLiteParserK_DATABASE, SQLiteParserK_DEFAULT, SQLiteParserK_DEFERRABLE, SQLiteParserK_DEFERRED, SQLiteParserK_DELETE, SQLiteParserK_DESC, SQLiteParserK_DETACH, SQLiteParserK_DISTINCT, SQLiteParserK_DROP, SQLiteParserK_EACH, SQLiteParserK_ELSE, SQLiteParserK_END, SQLiteParserK_ESCAPE, SQLiteParserK_EXCEPT, SQLiteParserK_EXCLUSIVE, SQLiteParserK_EXISTS, SQLiteParserK_EXPLAIN, SQLiteParserK_FAIL, SQLiteParserK_FOR, SQLiteParserK_FOREIGN, SQLiteParserK_FROM, SQLiteParserK_FULL, SQLiteParserK_GLOB, SQLiteParserK_GROUP, SQLiteParserK_HAVING, SQLiteParserK_IF, SQLiteParserK_IGNORE, SQLiteParserK_IMMEDIATE, SQLiteParserK_IN, SQLiteParserK_INDEX, SQLiteParserK_INDEXED, SQLiteParserK_INITIALLY, SQLiteParserK_INNER, SQLiteParserK_INSERT, SQLiteParserK_INSTEAD, SQLiteParserK_INTERSECT, SQLiteParserK_INTO, SQLiteParserK_IS, SQLiteParserK_ISNULL, SQLiteParserK_JOIN, SQLiteParserK_KEY, SQLiteParserK_LEFT, SQLiteParserK_LIKE, SQLiteParserK_LIMIT, SQLiteParserK_MATCH, SQLiteParserK_NATURAL, SQLiteParserK_NO, SQLiteParserK_NOT, SQLiteParserK_NOTNULL, SQLiteParserK_NULL, SQLiteParserK_OF, SQLiteParserK_OFFSET, SQLiteParserK_ON, SQLiteParserK_OR, SQLiteParserK_ORDER, SQLiteParserK_OUTER, SQLiteParserK_PLAN, SQLiteParserK_PRAGMA, SQLiteParserK_PRIMARY, SQLiteParserK_QUERY, SQLiteParserK_RAISE, SQLiteParserK_RECURSIVE, SQLiteParserK_REFERENCES, SQLiteParserK_REGEXP, SQLiteParserK_REINDEX, SQLiteParserK_RELEASE, SQLiteParserK_RENAME, SQLiteParserK_REPLACE, SQLiteParserK_RESTRICT, SQLiteParserK_RIGHT, SQLiteParserK_ROLLBACK, SQLiteParserK_ROW, SQLiteParserK_SAVEPOINT, SQLiteParserK_SELECT, SQLiteParserK_SET, SQLiteParserK_TABLE, SQLiteParserK_TEMP, SQLiteParserK_TEMPORARY, SQLiteParserK_THEN, SQLiteParserK_TO, SQLiteParserK_TRANSACTION, SQLiteParserK_TRIGGER, SQLiteParserK_UNION, SQLiteParserK_UNIQUE, SQLiteParserK_UPDATE, SQLiteParserK_USING, SQLiteParserK_VACUUM, SQLiteParserK_VALUES, SQLiteParserK_VIEW, SQLiteParserK_VIRTUAL, SQLiteParserK_WHEN, SQLiteParserK_WHERE, SQLiteParserK_WITH, SQLiteParserK_WITHOUT:
		p.EnterOuterAlt(localctx, 2)
		{
			p.SetState(1680)
			p.Keyword()
		}

	case SQLiteParserSTRING_LITERAL:
		p.EnterOuterAlt(localctx, 3)
		{
			p.SetState(1681)
			p.Match(SQLiteParserSTRING_LITERAL)
		}

	case SQLiteParserOPEN_PAR:
		p.EnterOuterAlt(localctx, 4)
		{
			p.SetState(1682)
			p.Match(SQLiteParserOPEN_PAR)
		}
		{
			p.SetState(1683)
			p.Any_name()
		}
		{
			p.SetState(1684)
			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 38:
		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 {
	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(), 13)

	case 7:
		return p.Precpred(p.GetParserRuleContext(), 12)

	case 8:
		return p.Precpred(p.GetParserRuleContext(), 5)

	case 9:
		return p.Precpred(p.GetParserRuleContext(), 4)

	case 10:
		return p.Precpred(p.GetParserRuleContext(), 14)

	case 11:
		return p.Precpred(p.GetParserRuleContext(), 8)

	case 12:
		return p.Precpred(p.GetParserRuleContext(), 7)

	case 13:
		return p.Precpred(p.GetParserRuleContext(), 6)

	default:
		panic("No predicate with index: " + fmt.Sprint(predIndex))
	}
}
